LeetCode 第134场周赛

5039. 移动石子直到连续

三枚石子放置在数轴上，位置分别为 a，b，c。

每一回合，我们假设这三枚石子当前分别位于位置 x, y, z 且 x < y < z。从位置 x 或者是位置 z 拿起一枚石子，并将该石子移动到某一整数位置 k 处，其中 x < k < z 且 k != y。

当你无法进行任何移动时，即，这些石子的位置连续时，游戏结束。

要使游戏结束，你可以执行的最小和最大移动次数分别是多少？ 以长度为 2 的数组形式返回答案：answer = [minimum_moves, maximum_moves]

示例 1：

输入：a = 1, b = 2, c = 5
输出：[1, 2]
解释：将石子从 5 移动到 4 再移动到 3，或者我们可以直接将石子移动到 3。

示例 2：

输入：a = 4, b = 3, c = 2
输出：[0, 0]
解释：我们无法进行任何移动。

提示：

1. 1 <= a <= 100
2. 1 <= b <= 100
3. 1 <= c <= 100
4. a != b, b != c, c != a

---

哇这第一题直接给我干懵了

最终目的是要求三个数连续，求最大移动和最小移动

处理前要排序，python没有swap，因为是以引用的形式管理对象，所以我们可以直接交换引用

或者写一个神奇的函数(在我看来)

class Solution(object):
    def sort(self, a, b, c):
        return sorted([a, b, c])
    def numMovesStones(self, a, b, c):
        """
        :type a: int
        :type b: int
        :type c: int
        :rtype: List[int]
        """ 
        """if a > b:
            a, b = b, a
        if a > c:
            a, c = c, a
        if b > c:
            b, c = c, b
        """
        a, b, c = self.sort(a, b, c)
        maxn = c - a - 2
        if maxn == 0:
            return [0, 0]
        if b - a <= 2 or c - b <= 2:
            return [1, maxn]
        return [2, maxn]

---

5040. 边框着色

给出一个二维整数网格 grid，网格中的每个值表示该位置处的网格块的颜色。

只有当两个网格块的颜色相同，而且在四个方向中任意一个方向上相邻时，它们属于同一连通分量。

连通分量的边界是指连通分量中的所有与不在分量中的正方形相邻（四个方向上）的所有正方形，或者在网格的边界上（第一行/列或最后一行/列）的所有正方形。

给出位于 (r0, c0) 的网格块和颜色 color，使用指定颜色 color 为所给网格块的连通分量的边界进行着色，并返回最终的网格 grid 。

示例 1：

输入：grid = [[1,1],[1,2]], r0 = 0, c0 = 0, color = 3
输出：[[3, 3], [3, 2]]

示例 2：

输入：grid = [[1,2,2],[2,3,2]], r0 = 0, c0 = 1, color = 3
输出：[[1, 3, 3], [2, 3, 3]]

示例 3：

输入：grid = [[1,1,1],[1,1,1],[1,1,1]], r0 = 1, c0 = 1, color = 2
输出：[[2, 2, 2], [2, 1, 2], [2, 2, 2]]

提示：

1. 1 <= grid.length <= 50
2. 1 <= grid[0].length <= 50
3. 1 <= grid[i][j] <= 1000
4. 0 <= r0 < grid.length
5. 0 <= c0 < grid[0].length
6. 1 <= color <= 1000

---

BFS

又是看了半天没看懂题系列，简单一句话就是寻找连通分量最外面那一圈

如果当前连通分量点中有一个点是边缘或者是四个方向上有一个点不是连通分量的点，那么就是最外圈

class Solution {
public:
    vector<vector<int>> colorBorder(vector<vector<int>>& grid, int r0, int c0, int color) {
        using paii = pair<int, int>;
        const int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
        
        int n = grid.size(), m = grid[0].size();
        vector<vector<int>> ans(grid), vis(n, vector<int>(m, 0));
        queue<paii> q;
        q.push(paii(r0, c0));
        vis[r0][c0] = 1;
        
        while (!q.empty())
        {
            int x = q.front().first, y = q.front().second;
            q.pop();
            for (int i = 0; i < 4; ++i)
            {
                int dx = x + dir[i][0], dy = y + dir[i][1];
                if (dx >= 0 && dx < n && dy >= 0 && dy < m && 
                    !vis[dx][dy] && grid[dx][dy] == grid[r0][c0])
                {
                    vis[dx][dy] = 1;
                    q.push(paii(dx, dy));
                }
                //边缘或者四周有一个不是连通分量里的点
                if (!(dx >= 0 && dx < n && dy >= 0 && dy < m 
                      && grid[dx][dy] == grid[r0][c0]))
                    ans[x][y] = color;
            }
        }
        return ans;
    }
};