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(in,(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

"""

重在参与，两版答案，一版简单一版快：```
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 ，有点难受