3274. 检查棋盘方格颜色是否相同

给你两个字符串 coordinate1 和 coordinate2，代表 8 x 8 国际象棋棋盘上的两个方格的坐标。

以下是棋盘的参考图。

如果这两个方格颜色相同，返回 true，否则返回 false。

坐标总是表示有效的棋盘方格。坐标的格式总是先字母（表示列），再数字（表示行）。

示例 1：

输入： coordinate1 = "a1", coordinate2 = "c3"

输出： true

解释：

两个方格均为黑色。

示例 2：

输入： coordinate1 = "a1", coordinate2 = "h3"

输出： false

解释：

方格 "a1" 是黑色，而 "h3" 是白色。 

提示：

• coordinate1.length == coordinate2.length == 2
• 'a' <= coordinate1[0], coordinate2[0] <= 'h'
• '1' <= coordinate1[1], coordinate2[1] <= '8'

# 有一个性质，同种颜色的纵坐标加上他的和坐标的奇偶性一样
class Solution:
    def checkTwoChessboards(self, coordinate1: str, coordinate2: str) -> bool:
        if (ord(coordinate1[0]) - 96 + int(coordinate1[1])) % 2 == 0 and (ord(coordinate2[0]) - 96 + int(coordinate2[1])) % 2 == 0:
            return True
        if (ord(coordinate1[0]) - 96 + int(coordinate1[1])) % 2 != 0 and (ord(coordinate2[0]) - 96 + int(coordinate2[1])) % 2 != 0:
            return True 
        return False

3275. 第 K 近障碍物查询 

有一个无限大的二维平面。

给你一个正整数 k ，同时给你一个二维数组 queries ，包含一系列查询：

• queries[i] = [x, y] ：在平面上坐标 (x, y) 处建一个障碍物，数据保证之前的查询 不会 在这个坐标处建立任何障碍物。

每次查询后，你需要找到离原点第 k 近 障碍物到原点的 距离 。

请你返回一个整数数组 results ，其中 results[i] 表示建立第 i 个障碍物以后，离原地第 k 近障碍物距离原点的距离。如果少于 k 个障碍物，results[i] == -1 。

注意，一开始 没有 任何障碍物。

坐标在 (x, y) 处的点距离原点的距离定义为 |x| + |y| 。

示例 1：

输入：queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2

输出：[-1,7,5,3]

解释：

最初，不存在障碍物。

• queries[0] 之后，少于 2 个障碍物。
• queries[1] 之后， 两个障碍物距离原点的距离分别为 3 和 7 。
• queries[2] 之后，障碍物距离原点的距离分别为 3 ，5 和 7 。
• queries[3] 之后，障碍物距离原点的距离分别为 3，3，5 和 7 。

示例 2：

输入：queries = [[5,5],[4,4],[3,3]], k = 1

输出：[10,8,6]

解释：

• queries[0] 之后，只有一个障碍物，距离原点距离为 10 。
• queries[1] 之后，障碍物距离原点距离分别为 8 和 10 。
• queries[2] 之后，障碍物距离原点的距离分别为 6， 8 和10 。

提示：

• 1 <= queries.length <= 2 * 10**5
• 所有 queries[i] 互不相同。
• -10**9 <= queries[i][0], queries[i][1] <= 10**9
• 1 <= k <= 10**5

# 由于数据偏大，所以我们每次查找第k个值不能暴力排序再找
# 我的想法是用堆优化因为他有一个性质，总是取第k个值，当这个堆比k多的时候再在后面找，如果比第k个值大那么这个数就不用管，如果比这个数小就要加入排序。
# 每次取第k个数，且这个数是在这个堆里最大的，我们不妨想到堆排序
# 我这里用的是两个堆来维护
class Solution:
    def resultsArray(self, queries: List[List[int]], k: int) -> List[int]:
        # 建两个堆，一个是k及其k以后的数的排序，另一个是k以前的顺序
        heap1 = []
        heap2 = []
        n = len(queries)
        results = [-1] * n
        for i in range(n):
            if i < k - 1:
                heapq.heappush(heap1,(abs(queries[i][0]) + abs(queries[i][1])) * (-1))
            if i == k - 1:
                heapq.heappush(heap1,(abs(queries[i][0]) + abs(queries[i][1])) * (-1))
                heapq.heappush(heap2,int(abs((heapq.heappop(heap1)))))
                results[i] = heap2[0]
            if i > k - 1:
                if abs(queries[i][0]) + abs(queries[i][1]) >= heap2[0]:
                    results[i] = heap2[0]
                else:
                    heapq.heappush(heap1,(abs(queries[i][0]) + abs(queries[i][1])) * (-1))
                    heapq.heappush(heap2,int(abs((heapq.heappop(heap1)))))
                    results[i] = heap2[0]
        return results
# 用一个堆来维护的可以找灵神的题解。