每日一道Leetcode——距离顺序排列矩阵单元格

题目：

我的解法：
思路：计算出每个单元格与给定坐标的距离d，将单元格[i,j]的坐标加入距离d形成三元组[i,j,d]，保存到一个数组中。对这个数组中的单元格，重写sort函数，使其根据d进行排序。最终再取排序后的数组中每个单元格的坐标，保存到最终的结果数组中。

class Solution {
    public int[][] allCellsDistOrder(int R, int C, int r0, int c0) {
        // 创建三元组数组，保存每个单元格的距离d
        int[][] triple_tuple = new int[R*C][];
        int index = 0;
        for(int i=0; i<R; i++){
            for(int j=0; j<C; j++){
                int d1 = i>r0 ? i-r0:r0-i;
                int d2 = j>c0 ? j-c0:c0-j;
                int d = d1 + d2;
                int[] block = new int[]{i,j,d};
                triple_tuple[index] = block;
                index++;
            }
        }
        // 根据d对三元组数组进行排序
        Arrays.sort(triple_tuple, new Comparator<int[]>() {
            public int compare(int[] block1, int[] block2) {
                    return block1[2] - block2[2];
            }
        });
        // 最后从排序后的三元组数组中取出每个单元格坐标
        int len = triple_tuple.length;
        int[][] result = new int[len][];
        for(int k=0; k<len; k++){
            result[k] = new int[]{triple_tuple[k][0], triple_tuple[k][1]};
        }
        return result;

    }
}

官方题解一：直接排序

class Solution {
    public int[][] allCellsDistOrder(int R, int C, int r0, int c0) {
        int[][] ret = new int[R * C][];
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                ret[i * C + j] = new int[]{i, j};
            }
        }
        Arrays.sort(ret, new Comparator<int[]>() {
            public int compare(int[] a, int[] b) {
                return (Math.abs(a[0] - r0) + Math.abs(a[1] - c0)) - (Math.abs(b[0] - r0) + Math.abs(b[1] - c0));
            }
        });
        return ret;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/matrix-cells-in-distance-order/solution/ju-chi-shun-xu-pai-lie-ju-zhen-dan-yuan-ge-by-leet/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

官方题解二：桶排序

class Solution {
    public int[][] allCellsDistOrder(int R, int C, int r0, int c0) {
        int maxDist = Math.max(r0, R - 1 - r0) + Math.max(c0, C - 1 - c0);
        List<List<int[]>> bucket = new ArrayList<List<int[]>>();
        for (int i = 0; i <= maxDist; i++) {
            bucket.add(new ArrayList<int[]>());
        }

        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                int d = dist(i, j, r0, c0);
                bucket.get(d).add(new int[]{i, j});
            }
        }
        int[][] ret = new int[R * C][];
        int index = 0;
        for (int i = 0; i <= maxDist; i++) {
            for (int[] it : bucket.get(i)) {
                ret[index++] = it;
            }
        }
        return ret;
    }

    public int dist(int r1, int c1, int r2, int c2) {
        return Math.abs(r1 - r2) + Math.abs(c1 - c2);
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/matrix-cells-in-distance-order/solution/ju-chi-shun-xu-pai-lie-ju-zhen-dan-yuan-ge-by-leet/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

官方题解三：几何法

class Solution {
    int[] dr = {1, 1, -1, -1};
    int[] dc = {1, -1, -1, 1};

    public int[][] allCellsDistOrder(int R, int C, int r0, int c0) {
        int maxDist = Math.max(r0, R - 1 - r0) + Math.max(c0, C - 1 - c0);
        int[][] ret = new int[R * C][];
        int row = r0, col = c0;
        int index = 0;
        ret[index++] = new int[]{row, col};
        for (int dist = 1; dist <= maxDist; dist++) {
            row--;
            for (int i = 0; i < 4; i++) {
                while ((i % 2 == 0 && row != r0) || (i % 2 != 0 && col != c0)) {
                    if (row >= 0 && row < R && col >= 0 && col < C) {
                        ret[index++] = new int[]{row, col};
                    }
                    row += dr[i];
                    col += dc[i];
                }
            }
        }
        return ret;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/matrix-cells-in-distance-order/solution/ju-chi-shun-xu-pai-lie-ju-zhen-dan-yuan-ge-by-leet/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。