图解LeetCode——1260. 二维网格迁移（难度：简单）

一、题目

给你一个 m 行 n 列的二维网格 grid 和一个整数 k。你需要将 grid 迁移 k 次。

每次「迁移」操作将会引发下述活动：

• 位于 grid[i][j] 的元素将会移动到 grid[i][j + 1]。
• 位于 grid[i][n - 1] 的元素将会移动到 grid[i + 1][0]。
• 位于 grid[m - 1][n - 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]]

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m <= 50
• 1 <= n <= 50
• -1000 <= grid[i][j] <= 1000
• 0 <= k <= 100

三、解题思路

3.1> 思路一：按题目给出的规则逐一迁移元素

根据题目的规则，我们可以知道，每次数据迁移的时候，都需要执行3个步骤。那么，最容易想到的解题思路就是，我们根据题目的描述，针对每1次迁移（总共迁移k次）执行3个步骤去迁移元素。这种方式会比较直观，但是执行效率会比较低。具体逻辑如下所示：

3.2> 思路二：根据转换规律一次性转换数据

其实在转换过程中，其实存在一定的规律的。为了清楚看到其中的规律，我们可以将二维数组转换为一维数组。那么对比转换前后的两个一维数组，我们可以非常清晰的看到其中的规律，也就是，在每次迁移过程中，数组中每个元素都会向后移动1位。如果一共要移动6次的话（即：k=6），那么一维数组中每个元素都会向后移动6位，当然，对于越界的元素，都会再次插入到数组的头部。根据如下规律，我们可以找出从旧二维数组转换为新一维数组的规律公式，这样k就会作为转换公式的参数，一次性的就可以获得最终转换后的二维数组。具体逻辑如下所示：

四、代码实现

4.1> 实现1：按题目给出的规则逐一迁移元素

public List<List<Integer>> shiftGrid(int[][] grid, int k) {
    int[][] result;
    while (k > 0) {
        result = new int[grid.length][grid[0].length];
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[i].length; j++) {
                if (i == grid.length - 1 && j == grid[i].length - 1) {
                    result[0][0] = grid[i][j];
                } else if (j == grid[i].length - 1) {
                    result[i + 1][0] = grid[i][j];
                } else {
                    result[i][j + 1] = grid[i][j];
                }
            }
        }
        grid = result;
        k--;
    }

    List<List<Integer>> gridLists = new ArrayList();
    for (int[] item: grid) {
        List<Integer> gridList = new ArrayList();
        for (int i : item) {
            gridList.add(i);
        }
        gridLists.add(gridList);
    }
    return gridLists;
}

4.2> 实现2：根据转换规律一次性转换数据

public List<List<Integer>> shiftGrid(int[][] grid, int k) {
    int m = grid.length; // 行数
    int n = grid[0].length; // 列数

    int[][] result = new int[m][n];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            result[((j + k) / n + i) % m][(j + k) % n] = grid[i][j];
        }
    }

    // 转换输出结果
    List<List<Integer>> gridLists = new ArrayList();
    for (int[] item: result) {
        List<Integer> gridList = new ArrayList();
        for (int i : item) {
            gridList.add(i);
        }
        gridLists.add(gridList);
    }
    return gridLists;
}

今天的文章内容就这些了：

写作不易，笔者几个小时甚至数天完成的一篇文章，只愿换来您几秒钟的点赞&分享。

更多技术干货，欢迎大家关注公众号@爪哇缪斯「干货分享，每周更新」

往期推荐

图解LeetCode——731. 我的日程安排表 II（难度：中等）https://mp.csdn.net/mp_blog/creation/editor/125884328图解LeetCode——3. 无重复字符的最长子串（难度：中等）https://mp.csdn.net/mp_blog/creation/editor/125857066LeetCode精讲——21. 合并两个有序链表（难度：简单）https://mp.csdn.net/mp_blog/creation/editor/125840103LeetCode精讲——565. 数组嵌套（难度：中等）https://mp.csdn.net/mp_blog/creation/editor/125831251

题目来源：力扣（LeetCode）