距离顺序排列矩阵单元格

给出 R 行 C 列的矩阵，其中的单元格的整数坐标为 (r, c)，满足 0 <= r < R 且 0 <= c < C。
另外，我们在该矩阵中给出了一个坐标为 (r0, c0) 的单元格。

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

输入：R = 1, C = 2, r0 = 0, c0 = 0
输出：[[0,0],[0,1]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1]
输入：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]] 也会被视作正确答案。
输入：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]]。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/matrix-cells-in-distance-order

思路：
嗯…这个思路大概都是算两个abs然后加在一块吧，问题是排序的方法不怎么好整，接下来都是我自己在瞎bb：我想的用生成1[0,1]这样的字符串列表，用sort排序排首位，结果遇到距离是两位数的就gg了，然后想的是用len先排一下，在按sort排，然后[]中有两位数以上又gg了…
最后直接按距离排的，用个蛇皮字符串…绕一大圈还搞不出来，离谱
ps：字符串我感觉能用index找"["来排序，懒得试了…

class Solution:
    def allCellsDistOrder(self, R: int, C: int, r0: int, c0: int) -> List[List[int]]:
        d = []
        for i in range(R):
            for p in range(C):
                d.append([i,p])
        d.sort(key = lambda x: abs(x[0] - r0) + abs(x[1] - c0))
        return d

之后附两个大佬的代码，当是做笔记用了
BFS，collections用法：https://www.cnblogs.com/dianel/p/10787693.html
讲的蛮详细的

class Solution:
    def allCellsDistOrder(self, R: int, C: int, r0: int, c0: int) -> List[List[int]]:
        # 四个方位
        dire = [(-1, 0), (0, 1), (1, 0), (0, -1)]

        # 标记是否已经被扩散访问过
        signed = [[False] * C for _ in range(R)]

        queue = collections.deque()
        # 添加起始点
        queue.append([r0, c0])
        # 标记已扩散
        signed[r0][c0] = True

        res = []
        while queue:
            # 出列，准备扩散
            cur =  queue.popleft()
            res.append(cur)

            r, c = cur
            # 开始往四周扩散
            for i, j in dire:
                nr = r + i
                nc = c + j
                # 注意边界，以及是否被扩散访问过
                if 0 <= nr < R and 0 <= nc < C and not signed[nr][nc]:
                    queue.append([nr, nc])
                    signed[nr][nc] = True
        
        return res

桶排序法，这个比上面那个好理解多了

class Solution:
    def allCellsDistOrder(self, R: int, C: int, r0: int, c0: int) -> List[List[int]]:
        def get_d(r, c, r0, c0):
            """求曼哈顿距离
            """
            return abs(r-r0) + abs(c-c0)

        # 确定曼哈顿距离的最大值，进而确定桶数量
        max_d = max(r0, R - 1 - r0) + max(c0, C - 1 - c0)
        # 初始化桶，遍历将坐标放入根据曼哈顿距离放到对应的桶中
        bucket = {}
        for r in range(R):
            for c in range(C):
                d = get_d(r, c, r0, c0)
                if d not in bucket:
                    bucket[d] = []
                bucket[d].append([r, c])

        # 将桶中元素添加到结果列表中
        res = []
        for i in range(max_d+1):
            res.extend(bucket[i])
        return res