Leetcode每日一题 —— 1260. 二维网格迁移

比较有规律，是可以推出最终网格每个位置对应原网格中的位置的。

就是要注意，k 可能较大，推断时一定要在合适的地方取余。

class Solution {

public:

    vector<vector<int>> shiftGrid(vector<vector<int>>& grid, int k) {

        // 整体右移

        // 但是最后一列会下移

        int m=grid.size(),n=grid[0].size();

        int offsetJ=k%n; // 计算横向实际的移动偏移

        vector<vector<int>> res(m,vector<int>(n));

        // 横向每移动一次，实际上都有一列会纵向移动

        for(int j=0;j<n;j++){

            for(int i=0;i<m;i++){

                // 首先找到移动后对应原始的哪一列

                int oj=(j+n-offsetJ)%n;

                // 还要找到这一列的纵向移动次数，找到 i 对应原本的 i

                // 每一列回到最左侧时才会纵向移动，具体移动多少次要根据 oj 来算

                if(k<n-oj){

                    // 移动次数不足以把这列移出右侧

                    // 这一列没有纵向移动过

                    res[i][j]=grid[i][oj];

                }else{

                    // 计算移动次数

                    // +1 是因为这个分支里至少会移动越过一次最右侧，我们把初始移动减去了

                    int di=((k-(n-oj))/n)+1;

                    int oi=(i+m-di%m)%m; // di 可能很大，记得对 m 求余

                    res[i][j]=grid[oi][oj];

                }

            }

        }

        return res;

    }

};

算术评级3 第 163 场周赛 Q1 难度分 1337

直接一通乱做

class Solution:

    def shiftGrid(self, grid: List[List[int]], k: int) -> List[List[int]]:

        m, n = len(grid), len(grid[0])

        all_count = m * n

        ans = [0]*all_count

        count = 0

        k = k % all_count

        

        for i in range(m):

            for j in range(n):

                ans[(count+k)%all_count]=grid[i][j]

                count+=1

        

        ret = []

        for i in range(m):

            tmp = []

            for j in range(i*n,(i+1)*n):

                tmp.append(ans[j])

            ret.append(tmp)

        return ret

impl Solution {

    pub fn shift_grid(grid: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {

        let (m, n) = (grid.len(), grid[0].len());

        let k = k as usize;

        let (mk, nk) = ((k / n) % m, k % n);

        let mut ans: Vec<Vec<i32>> = vec![vec![0; n]; m];

        for i in 0..m {

            for j in 0..n {

                ans[i][j] = grid[(i + m - mk - if j < nk { 1 } else { 0 }) % m][(j + n - nk) % n];

            }

        }

        ans

    }

}

轮转数组,二维转一维

class Solution:

    def shiftGrid(self, grid: List[List[int]], k: int) -> List[List[int]]:

        m, n = len(grid), len(grid[0])

        mn = m * n

        k %= mn



        def rev(l, r):

            while l < r:

                grid[l//n][l%n], grid[r//n][r%n] = grid[r//n][r%n], grid[l//n][l%n]

                l += 1

                r -= 1

        rev(0, mn-1)

        rev(0, k-1)

        rev(k, mn-1)

        return grid



"""

1 2 3 4 7 6 5

5 6 7 4 3 2 1

6 5 1 2 3 4 7



"""

Kotlin每日打卡（降维一维后移动，再升维为二维）：

class Solution {

    fun shiftGrid(grid: Array<IntArray>, k: Int): List<List<Int>> {

        val m = grid.size

        val n = grid[0].size

        val size = m * n



        val ans = MutableList(m) { MutableList(n) { 0 } }

        for (i in 0..<m) {

            for (j in 0..<n) {

                val r = (i * n + j + k) % size

                val ni = r / n

                val nj = r % n

                ans[ni][nj] = grid[i][j]

            }

        }

        return ans

    }

}

重在参与，两版答案，一版简单一版快：

void print2DArray(int** grid, int gridSize, int* gridColSize);



/**

 * 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** shiftGrid(int** grid, int gridSize, int* gridColSize, int k, int* returnSize, int** returnColumnSizes) {

    int** returnGrid = malloc(gridSize * sizeof(int*));

    for(int i = 0; i < gridSize; i++) returnGrid[i] = malloc(*gridColSize * sizeof(int));

    

    int rotateLen = k % (gridSize * *gridColSize);

    

    // printf("gridColSize: %d\n", *gridColSize);



    if(rotateLen != 0){

        int pivot = gridSize * *gridColSize - rotateLen;



        // printf("rotatelen: %d; pivot: %d; \n", rotateLen, pivot);



        // two parts: left part and right part;

        for(int i = 0; i < gridSize * *gridColSize; i++){

            if(i + pivot < gridSize * *gridColSize){

                // starting, now copy from the pivot point to i

                int pos = pivot + i;

                // int temp = grid[pos / *gridColSize][pos % *gridColSize];

                returnGrid[i / *gridColSize][i % *gridColSize] = grid[pos / *gridColSize][pos % *gridColSize];

                // grid[i / *gridColSize][i % *gridColSize] = temp;

                // printf("Once\n");

            }else{

                int pos = i - rotateLen;

                // printf("Pos:%d\n", pos);

                // int temp = grid[pos / *gridColSize][pos % *gridColSize];

                returnGrid[i / *gridColSize][i % *gridColSize] = grid[ pos/ *gridColSize][pos % *gridColSize];

                // grid[i / *gridColSize][i % *gridColSize] = temp;

            }



            // print2DArray(returnGrid, gridSize, gridColSize);

        }

    }else{

        for(int i = 0; i < gridSize; i++) memcpy(returnGrid[i], grid[i], *gridColSize * sizeof(int));

    }

    // for(int i = 0; i < mvTimes; i++){

    //     for(int j = gridSize * *gridColSize - 1; j > 0; j--){

    //         int prev = (j - 1);

    //         // if (prev == -1) prev = (gridSize * *gridColSize - 1);



    //         int thisV = grid[prev / *gridColSize][prev % *gridColSize];

    //         grid[prev / *gridColSize][prev % *gridColSize] = grid[j / *gridColSize][j % *gridColSize];

    //         grid[j / *gridColSize][j % *gridColSize] = thisV;

    //     }

    // }



    // for(int i = 0; i < gridSize; i++)  memcpy(returnGrid[i], grid[i], *gridColSize * sizeof(int));



    *returnSize = gridSize;

    *returnColumnSizes = gridColSize;



    return returnGrid;

}



// Print a 2D int array where each row can have a different length

void print2DArray(int** grid, int gridSize, int* gridColSize) {

    printf("[");

    for (int i = 0; i < gridSize; i++) {

        printf("[");

        for (int j = 0; j < gridColSize[i]; j++) {

            printf("%d", grid[i][j]);

            if (j != gridColSize[i] - 1) printf(",");

        }

        printf("]");

        if (i != gridSize - 1) printf(",");

    }

    printf("]\n");

}

不得不说 AI 写代码写多了之后做这种蚊子题都吃力，感觉非常悲催

佬的高亮怎么弄的来着，为啥我怎么也弄不出来

``` 后面跟代码的类型，比如java、c、c++

void print2DArray(int** grid, int gridSize, int* gridColSize);

佬友是说这意思吗？

我现在md会自动visualization ，有点难受