1030. 距离顺序排列矩阵单元格

地址：

力扣https://leetcode-cn.com/problems/matrix-cells-in-distance-order/

题目：

给出 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
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

通过观察，给定坐标节点为距离 0 ，与之相邻的距离 1， 斜角距离 2

那么通过给定节点依序遍历，这种暴力方式太过于复杂，因为还要考虑查找到的元素是否存在

方法一、一维数组记录信息

以 R = 2, C = 3, r0 = 1, c0 = 2 为例：

    00 01 02

    10 11 12

一维数组的存放信息应该如下

        distance    idx_i       idx_j

        3           0           0

        2           0           1

        1           0           2

        2           1           0

        1           1           1

        0           1           2

   这样的好处是仅仅遍历一次就能知晓整个矩阵所偶元素的距离值，那么后续再拷贝回新矩阵时就很容易，从距离 0 开始拷贝

int **myMalloc(int r, int c, int *return_r, int **return_c)
{
	int **ret = (int **)malloc(sizeof(int *) * r);
	*return_r = r;
	
	*return_c =(int *)malloc(sizeof(int) * r); 
	for(int i=0; i<r; i++)
	{
		ret[i] = (int *)malloc(sizeof(int) * c);
		(*return_c)[i] = c;
	}

    return ret;
}

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** allCellsDistOrder(int rows, int cols, int rCenter, int cCenter, int* returnSize, int** returnColumnSizes){
	int r0 = rCenter;
	int c0 = cCenter;
	int r = rows * cols;
	int c = 2;
	int **ret = myMalloc(r, c, returnSize, returnColumnSizes);
	
	int i,j,k;
	
	/* 
	R = 2, C = 3, r0 = 1, c0 = 2
	00 01 02
	10 11 12
	
	array looks like:
		distance	idx_i		idx_j
		3			0			0
		2			0			1
		1			0			2
		2			1			0
		1			1			1
		0			1			2
	
	output to **ret, distance 0->1->2->3
	*/
	
	int array_len = (rows * cols) * 3;
	int *array = (int *)malloc(sizeof(int) * array_len);
	
	
	for(i=0, k=0; i<rows; i++)
	{
		for(j=0; j<cols; j++)
		{
			array[k++] = abs(i-r0) + abs(j-c0);
			array[k++] = i;
			array[k++] = j;
		}
	}
	
    i = 0;
	j = 0;
    int min = 0;
	int loopnum = rows * cols;
	while(loopnum)
	{
		//printf("loopnum=%d, min=%d\n", loopnum, min);
		for(k=0; k<array_len; k+=3)
		{
			//printf("array[%d][%d][%d]=[%d][%d][%d]\n", k, k+1, k+2, array[k], array[k+1], array[k+2]);
			if(array[k] == min)
			{
				//printf("------------>copy to ret..[%d][%d]\n", array[k+1], array[k+2]);
				if(i<r)
				{
					ret[i][j] = array[k+1];
					ret[i][j+1] = array[k+2];
					j += 2;
					if(j == c)
					{
						i++;
						j=0;
					}
				}
				
				loopnum--;
			}
		}
		
		min++;
	}
	
    free(array);

	return ret;
}

查看更多刷题笔记