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
解法一：直接排序数组
显然，最暴力的解法是按照距离排序，然后依次输出坐标。
注意：
本解法可以使用哈希表优化，即使用坐标作 key，使用距离作 value，然后按照距离排序，这样就不会因为多次对同一下标进行比较而重复计算距离
无论如何优化，核心仍然是直接排序，时间复杂度不会优于 O(RClog(R*C))
代码：
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
struct node{
int x;
int y;
int distance;
};
node arr[100];
int cmp(const node& a,const node& b){
return a.distance<b.distance;
}
int main(){
int R,C,t=0;
cin>>R>>C;
int r0,c0;
cin>>r0>>c0;
for (int i = 0; i < R; i++)
{
for (int j = 0; j < C; j++)
{
arr[t].x=i;
arr[t].y=j;
arr[t++].distance=abs(i-r0)+abs(j-c0);
}
}
sort(arr,arr+t,cmp);
for (int i = 0; i < t; i++)
{
cout<<"x= "<<arr[i].x<<" y= "<<arr[i].y<<" distance= "<<arr[i].distance<<endl;
}
}
输入：
2 3
1 2
输出：
x= 1 y= 2 distance= 0
x= 0 y= 2 distance= 1
x= 1 y= 1 distance= 1
x= 0 y= 1 distance= 2
x= 1 y= 0 distance= 2
x= 0 y= 0 distance= 3
解法二：桶排序
遍历所有坐标，按照距离的大小分组，每组的距离相等（即放入一个桶中）
按照距离从小到大的原则，遍历所有桶，并输出结果
本解法关键在于求得可能的最大距离，即行距离和列距离都最大时：max(r0, R - 1 - r0) + max(c0, C - 1 - c0)
注意：
此解法时间复杂度为 O(R*C)，理论上已达到最快可能
实际时间消耗会比预估要差，不同语言便利程度和优化不一，原因如下：
桶的制作涉及大量容器的初始化和存取
桶中要存储大量的坐标信息，不论是直接使用长度为 2 的小数组存储，还是用新的简单数据类，都会耗费很多时间
vector<vector<int> > allCellsDistOrder(int R, int C, int r0, int c0) {
vector<vector<int> > ans(R * C, vector<int>(2, 0));
vector<vector<int> > m(R + C);
for (int i = 0; i < R; ++i)
for (int j = 0; j < C; ++j) {
int dis = abs(i - r0) + abs(j - c0);
m[dis].push_back(i);
m[dis].push_back(j);
}
// for (int i = 0; i < R + C; ++i) {
// for (int j = 0; j < m[i].size(); j += 2)
// {
// cout<<m[i][j]<<" "<<m[i][j+1]<<endl;
// }
// }
int cnt = 0;
for (int i = 0; i < R + C; ++i) {
for (int j = 0; j < m[i].size(); j += 2)
{
ans[cnt][0] = m[i][j];
ans[cnt][1] = m[i][j + 1];
++cnt;
}
}
// for (int i = 0; i < cnt; i++)
// {
// cout<<ans[i][0]<<" "<<ans[i][1]<<endl;
// }
return ans;
}
解法三：BFS
可以把所有的坐标看作树的结点，距离相等的结点位于树的同一层
而对于每一层的结点，它们的距离 dist 可以分为行距离和列距离，且 rowDist + colDist = dist 必然成立
使 rowDist 从 0 到 dist 递增，colDist 相应有不同的值，可以得到不同的坐标：
横坐标为：r0 - rowDist 或 r0 + rowDist
纵坐标为：c0 - colDist 或 c0 + colDist
注意特殊情况：rowDist 或 colDist 为 0 时，每组只有一个正确值
对步骤 3 中，所有在矩阵范围内的坐标进行记录
注意：
此解法不关心最大距离，只要步骤 4 中记录的结果达到 R * C 的数量就可以终止搜索
此解法的时间复杂度是 O((R+C)^2)，因为对每一种距离 dist，rowDist 都要进行从 0 开始递增到 dist 的遍历操作，而距离可能的最大值为 R + C
此解法时间复杂度大于 O(R * C) 的原因是：每种距离可能产生多个不在矩阵内的坐标，但搜索算法必须依次检查予以排除
理论上此解法并不比桶排序优秀，但是代码中极少创建额外的容器和对象，所以实际的运行效率不会太差
class Solution {
public int[][] allCellsDistOrder(int R, int C, int r0, int c0) {
int[][] re = new int[R * C][2];
int dist = 0;
int cnt = 0;
int[] factor = {-1, 1};
while (cnt < R * C) {
for (int rowDist = 0; rowDist <= dist; rowDist++) {
int colDist = dist - rowDist;
for (int i = 0; i < 2; i++) {
int row = r0 + factor[i] * rowDist;
for (int j = 0; j < 2; j++) {
int col = c0 + factor[j] * colDist;
if (row >= 0 && row < R && col >= 0 && col < C) {
re[cnt][0] = row;
re[cnt][1] = col;
cnt++;
}
if (colDist == 0) break;
}
if (rowDist == 0) break;
}
}
dist++;
}
return re;
}
}
解法四：几何法（类 BFS）
如果把矩阵当作二维直角坐标系中的图形，而且把所有不在矩阵内的点也考虑进来，那么所有到 (r0, c0) 点的“距离”相等的整数坐标有明显的规律：
可以看到，它们的坐标都在一个正方形的边上（包括顶点），而且正方形的上下顶点 row 值为 r0，左右顶点 col 值为 c0。
这样，只要保证每次找到一个正方形的顶点，然后按照规律“画出”这个正方形即可，画图步骤如下:
保存 4 个向量标明画线的方向
出发点为 (r0 - 1, c0)
按照 1 中的向量指示方向画线，遇到一个正方形的顶点就更换为下一个向量（向左转 90°）
在上述的画线步骤中，不断检查线上的整数坐标，如果符合要求就进行记录。
注意：
顶点的判断方法有两组，分别对应和 r0 或 c0 是否相等
对每个距离 dist 都要画出正方形检查，检查的点数量是 8 * dist，而最大距离可能是 R + C，所以时间复杂度为 O((R+C)^2)
此解法代码中看似没有按照距离分层遍历，实际每个初始顶点的求解过程中已经包含了按照距离分层的想法，实际极其类似 BFS
此解法要检查的点理论上多于 BFS，尤其是 (r0, c0) 位于矩阵一角时会明显偏慢（最后要画很多很大的正方形）
class Solution {
public int[][] allCellsDistOrder(int R, int C, int r0, int c0) {
int[][] re = new int[R * C][2];
re[0][0] = r0;
re[0][1] = c0;
int[] dr = {1, 1, -1, -1};
int[] dc = {1, -1, -1, 1};
int row = r0;
int col = c0;
var cnt = 1;
while (cnt < R * C) {
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) {
re[cnt][0] = row;
re[cnt][1] = col;
cnt++;
}
row += dr[i];
col += dc[i];
}
}
}
return re;
}
}