2020_11_17 每日一题 1030. 距离顺序排列矩阵单元格

给出 R 行 C 列的矩阵，其中的单元格的整数坐标为 (r, c)，满足 0 <= r < R 且 0 <= c < C。

另外，我们在该矩阵中给出了一个坐标为 (r0, c0) 的单元格。

返回矩阵中的所有单元格的坐标，并按到 (r0, c0) 的距离从最小到最大的顺序排，其中，两单元格(r1, c1) 和 (r2, c2)
之间的距离是曼哈顿距离，|r1 - r2| + |c1 - c2|。（你可以按任何满足此条件的顺序返回答案。）

示例 1：

输入：R = 1, C = 2, r0 = 0, c0 = 0

输出：[[0,0],[0,1]]

解释：从 (r0, c0) 到其他单元格的距离为：[0,1]

示例 2：

输入：R = 2, C = 2, r0 = 0, c0 = 1

输出：[[0,1],[0,0],[1,1],[1,0]]

解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2]

[[0,1],[1,1],[0,0],[1,0]] 也会被视作正确答案。

示例 3：

输入：R = 2, C = 3, r0 = 1, c0 = 2

输出：[[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]

解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2,2,3]

其他满足题目要求的答案也会被视为正确，例如 [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]]。

提示：

1 <= R <= 100

1 <= C <= 100

0 <= r0 < R

0 <= c0 < C

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/matrix-cells-in-distance-order

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

愣了一会反应到可以bfs，实现了bfs的做法：

class Solution {
    public int[][] allCellsDistOrder(int R, int C, int r0, int c0) {
        //bfs
        int[][] ret = new int[R * C][];
        int retIndex = 0;
        LinkedList<int[]> q = new LinkedList<>();
        q.add(new int[]{r0, c0});
        boolean[][] visited = new boolean[R][C];
        visited[r0][c0] = true;
        while(!q.isEmpty()) {
            
            int[] cur = q.poll();
            int r = cur[0], c = cur[1];
            ret[retIndex++] = cur;
            
            if(r > 0 && !visited[r - 1][c]) {
                q.add(new int[]{r - 1, c});
                visited[r - 1][c] = true;
            }
            if(c > 0 && !visited[r][c - 1]) {
                q.add(new int[]{r, c - 1});
                visited[r][c - 1] = true;
            }
            if(r < R - 1 && !visited[r + 1][c]) {
                q.add(new int[]{r + 1, c});
                visited[r + 1][c] = true;
            }
            if(c < C - 1 && !visited[r][c + 1]) {
                q.add(new int[]{r, c + 1});
                visited[r][c + 1] = true;
            }
        }
        return ret;
    }
}

看了看题解 其实bfs个过程可以用一层一层走来实现，那样不需要保存当前层的点和是否走过，一层层往外走就好：

class Solution {
    public int[][] allCellsDistOrder(int R, int C, int r0, int c0) {
        //bfs
        int[][] ret = new int[R * C][];
        int retIndex = 1;
        int r = r0, c = c0;

        int[] difRow = {1, 1, -1, -1};
        int[] difCol = {1, -1, -1, 1};
        ret[0] = new int[]{r0, c0};
        while(retIndex < R * C) {
            --r;//进入下一圈
            int dist = r0 - r;
            for(int i = 0; i < 4; ++i) {
                for(int walk = 0; walk < dist; ++walk) {
                    if(r >= 0 && r < R && c >= 0 && c < C) {
                        ret[retIndex++] = new int[]{r, c};
                    }
                    r += difRow[i];
                    c += difCol[i];
                }
            }
        }

        return ret;
    }
}

会经过一些不用经过的点 不过无所谓，还是这样更快一些