二维网格迁移

题目描述

给你一个 n 行 m 列的二维网格 grid 和一个整数 k。你需要将 grid 迁移 k 次。
每次「迁移」操作将会引发下述活动：

• 位于 grid[i][j] 的元素将会移动到 grid[i][j + 1]。
• 位于 grid[i][m - 1] 的元素将会移动到 grid[i + 1][0]。
• 位于 grid[n - 1][m - 1] 的元素将会移动到 grid[0][0]。
• 请你返回 k 次迁移操作后最终得到的 二维网格。

示例 1：

输入：grid = [[1,2,3],[4,5,6],[7,8,9]], k = 1
输出：[[9,1,2],[3,4,5],[6,7,8]]

示例 2：

输入：grid = [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]], k = 4
输出：[[12,0,21,13],[3,8,1,9],[19,7,2,5],[4,6,11,10]]

示例 3：

输入：grid = [[1,2,3],[4,5,6],[7,8,9]], k = 9
输出：[[1,2,3],[4,5,6],[7,8,9]]

解析一

当移动次数等于二维数组的大小及其整数倍时, 数组的状态不发生改变

• 因此首先求移动次数对二维数组长度的模:
  // times是实际移动的次数, grid.length 和 grid[0].length 是二维数组的大小
  int times = k % (grid.length * grid[0].length);

• 用for循环来限制移动次数
  for (int i = 0; i < times; i++)

• 具体的一次移动很简单, 我的思路是先保存grid[0][0], 从后往前遍历, 将本次遍历位置的下一个数组元素放入当前位置

• 这样可以避免移动时覆盖下一次将要移动的元素

• 要注意的点是: 当遍历当前行时到达行首(倒序遍历)时, 前一个元素应该为上一行的末尾元素,

• 在循环之前, 我们需要保存数组的最后一个元素值: int temp = grid[grid.length -
  1][grid[0].length - 1];

• 当遍历到第一个数组元素时, 我们就将temp赋值给它

  for (int j = row - 1; j >= 0; j--) {
            for (int h = col - 1; h >= 0; h--) {
                if (j == 0 && h == 0) {
                    grid[j][h] = temp;
                } else {
                    if (h == 0) {
                        grid[j][h] = grid[j - 1][col - 1];
                    } else {
                        grid[j][h] = grid[j][h - 1];
                    }
                }
            }
        }

• 最后, 要求的返回值类型为嵌套列表, 我们需要将结果转化一下, 这里为了避免麻烦可以使用嵌套foreach

for (int[] griditem : grid) {
			ArrayList<Integer> p = new ArrayList<>();
			for (int item : griditem) {
				p.add(item);
			}
			result.add(p);
		}

下面是完整源码

public static List<List<Integer>> shiftGrid(int[][] grid, int k) {
		int times = k % (grid.length * grid[0].length);
		List<List<Integer>> result = new ArrayList<List<Integer>>();

		int temp, col = grid[0].length, row = grid.length;

		for (int i = 0; i < times; i++) {
			temp = grid[row - 1][col - 1];
			for (int j = row - 1; j >= 0; j--) {
				for (int h = col - 1; h >= 0; h--) {
					if (j == 0 && h == 0) {
						grid[j][h] = temp;
					} else {
						if (h == 0) {
							grid[j][h] = grid[j - 1][col - 1];
						} else {
							grid[j][h] = grid[j][h - 1];
						}
					}
				}
			}
		}

		for (int[] griditem : grid) {
			ArrayList<Integer> p = new ArrayList<>();
			for (int item : griditem) {
				p.add(item);
			}
			result.add(p);
		}
		return result;
	}

解析二

思路简单，二维数组展开，然后拆分，组合数组，集合就好了

代码

class Solution {
    public List<List<Integer>> shiftGrid(int[][] grid, int k) {
       int coordinate = grid.length;
        int vertical = grid[0].length;
        int newLen = vertical == 0 ? coordinate : coordinate * vertical;

        int arr[] = new int[newLen];
        int t = 0;
        /*二维数组转一维*/
        for (int i = 0; i < coordinate; i++) {
            for (int j = 0; j < vertical; j++) {
                arr[t] = grid[i][j];
                t++;
            }
        }
        int mobile = k % newLen;
        int newArr[] = new int[newLen];
        /*数组移动*/
        if (mobile != 0) {
            System.arraycopy(arr, 0, newArr, mobile, newLen - mobile);
            System.arraycopy(arr, newLen - mobile, newArr, 0, mobile);
            return arrayToList(newArr, vertical);
        } else {
            return arrayToList(arr, vertical);
        }

    }
    /*数组转集合*/
    private  List<List<Integer>> arrayToList(int[] newArr, int vertical) {
        List<List<Integer>> list = new ArrayList<>();
        List<Integer> mark = new ArrayList<>();
        for (int i = 0; i < newArr.length; i++) {
            if ((i + 1) % (vertical) == 0) {
                mark.add(newArr[i]);
                list.add(mark);
                mark = new ArrayList<>();
            } else {
                mark.add(newArr[i]);
            }
        }
        return list;
    }
}

解析三

代码

  public List<List<Integer>> shiftGrid(int[][] grid, int k) {
        int[] nums = new int[grid.length * grid[0].length];
        for(int i = 0, iMax = grid.length;i < iMax;i++) {
            for(int j = 0, jMax = grid[0].length;j < jMax;j++) {
                k %= nums.length;
                nums[k++] = grid[i][j];
            }
        }
        k = 0;
        List<List<Integer>> lists = new ArrayList<>(grid.length);
        for(int i = 0, iMax = grid.length;i < iMax;i++) {
            List<Integer> tempList = new ArrayList<>(grid[0].length);
            for(int j = 0, jMax = grid[0].length;j < jMax;j++) {
                tempList.add(nums[k++]);
            }
            lists.add(tempList);
        }
        return lists;
    }