前往闪闪の小窝以获得更好的阅读和评论体验

一、前景提要

距离我尽量维持一天一题已经过去了一个月，整个6月份都在忙期末作业、期末复习和期末实训，放暑假后一直在打电动，在装修博客，导致我一天一题是鸽了又鸽，状态全无。

这让本就是菜鸡的我，又彻底变回纯飞舞，还是连题目都读不太懂的那种。

所以我决心恢复往日的状态。

二、题目

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
2
3
4
5
6

示例1：

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

示例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]]
1
2

示例3：

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

提示：

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

三、解答

简单题我重拳出击！……？
题目我就读了好久，看半天才理解题意
而且因为我状态全无，二维数组的列数行数一直在混淆，边界处理一直在写，一直在犯低级错误
即使最后写好了，因为是暴力解法也没有太大参考意义，即使是这样都花费了我数个小时，我真是服了，状态真的太差了……

1，暴力解法

class Solution {
    public List<List<Integer>> shiftGrid(int[][] grid, int k) {
        System.out.println(grid[0].length);

        //grid.length是行数，也就是行号，也是一列有几个元素
        //grid[0].length是列数，也就是列号，也是一行有几个元素
        int[] origin = new int[grid.length];
        
        for(int count = 0; count < k; count++){
            System.out.println(grid[0][0]);
            //把最后一列的存起来
            for(int i = 0; i < grid.length; i++){//行号变
                
                origin[i] = grid[i][grid[0].length-1];//列号保持不变
                System.out.print(origin[i]+"|");
            }
            System.out.println("");
            
            if(grid[0].length > 1)
                stepOne(origin,grid);
            stepTwo(origin,grid);
            stepThree(origin,grid);
        }
        
        List<List<Integer>> ress = new ArrayList<List<Integer>>();
        for(int i = 0; i < grid.length; i++){  
            List<Integer> res = new ArrayList<Integer>();
            for(int j = 0; j < grid[0].length; j++){  
                res.add(grid[i][j]);
            }
            ress.add(res);
        }
        return ress;
    }

    public void stepOne(int[] origin, int[][] grid){
        for(int i = grid[0].length-1; i > 0; i--){  //列号先保持不变
            for(int j = 0; j < grid.length; j++){  //行号变，第一行开始往下递增
                grid[j][i] = grid[j][i-1];
            }
        }
        //除了最后一列的都已经右移完毕
        //把最后一列的复制到第一列即可
        for(int i = 0; i < grid.length; i++){
            grid[i][0] = origin[i];
        }
    }

    // 看题看示例看半天才发现，迁移过程的三个步骤不是说按照上一个步骤迁移变更后的数组迁移，而是按照最原始的数组的位置来迁移，真的吐了
    public void stepTwo(int[] origin, int[][] grid){
        for(int i = 0; i < grid.length; i++){  //行号变，第一行开始往下递增
            if(i == grid.length-1){
                grid[0][0] = origin[i];
                System.out.println(grid[0][0]);
                System.out.println("==============");
                break;
            }
            grid[i+1][0] = origin[i];
        }
    }

    public void stepThree(int[] origin, int[][] grid){
        grid[0][0] = origin[grid.length-1];
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

2，官方解法

还是看看远处的官方题解吧家人们

拍扁

转换成一维数组，迁移操作前每个元素的下标为：index = i * n + j

然后循环右移

k次迁移后下标变成：index1 = (index + k) % (m * n)

最后是还原

一维数组再变回二维，行号就是⌊index1 / n⌋，列号是index1 % n

⌊x⌋：地板函数，或取整函数，表示小于 x 的最大整数；⌈x⌉：天花板函数，表示大于 x 的最小整数。
1

我好像完全理解了……？😤后天再来做做看。