feat: add solutions to lc problem: No.1914 (#1372)

No.1914.Cyclically Rotating a Grid

Author: yanglbme

solution/1900-1999/1914.Cyclically Rotating a Grid/README.md

@@ -49,6 +49,14 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：逐层模拟**
+
+我们先计算得到矩阵的层数 $p$，然后从外到内逐层模拟循环轮转的过程。
+
+对于每一层，我们按照顺时针方向，将上、右、下、左四条边的元素依次放入数组 $nums$ 中。记数组 $nums$ 的长度为 $l$。接下来，我们将 $k$ 模 $l$。然后从数组的第 $k$ 个位置开始，将数组中的元素依次放回矩阵的上、右、下、左四条边。
+
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m + n)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -58,41 +66,37 @@
 ```python
 class Solution:
     def rotateGrid(self, grid: List[List[int]], k: int) -> List[List[int]]:
-        def rotate(grid, s1, e1, s2, e2, k):
-            t = []
-            for j in range(e2, e1, -1):
-                t.append(grid[s1][j])
-            for i in range(s1, s2):
-                t.append(grid[i][e1])
-            for j in range(e1, e2):
-                t.append(grid[s2][j])
-            for i in range(s2, s1, -1):
-                t.append(grid[i][e2])
-            k %= len(t)
-            t = t[-k:] + t[:-k]
+        def rotate(p: int, k: int):
+            nums = []
+            for j in range(p, n - p - 1):
+                nums.append(grid[p][j])
+            for i in range(p, m - p - 1):
+                nums.append(grid[i][n - p - 1])
+            for j in range(n - p - 1, p, -1):
+                nums.append(grid[m - p - 1][j])
+            for i in range(m - p - 1, p, -1):
+                nums.append(grid[i][p])
+            k %= len(nums)
+            if k == 0:
+                return
+            nums = nums[k:] + nums[:k]
             k = 0
-            for j in range(e2, e1, -1):
-                grid[s1][j] = t[k]
+            for j in range(p, n - p - 1):
+                grid[p][j] = nums[k]
                 k += 1
-            for i in range(s1, s2):
-                grid[i][e1] = t[k]
+            for i in range(p, m - p - 1):
+                grid[i][n - p - 1] = nums[k]
                 k += 1
-            for j in range(e1, e2):
-                grid[s2][j] = t[k]
+            for j in range(n - p - 1, p, -1):
+                grid[m - p - 1][j] = nums[k]
                 k += 1
-            for i in range(s2, s1, -1):
-                grid[i][e2] = t[k]
+            for i in range(m - p - 1, p, -1):
+                grid[i][p] = nums[k]
                 k += 1
 
         m, n = len(grid), len(grid[0])
-        s1 = e1 = 0
-        s2, e2 = m - 1, n - 1
-        while s1 <= s2 and e1 <= e2:
-            rotate(grid, s1, e1, s2, e2, k)
-            s1 += 1
-            e1 += 1
-            s2 -= 1
-            e2 -= 1
+        for p in range(min(m, n) >> 1):
+            rotate(p, k)
         return grid
 ```
 
@@ -102,53 +106,194 @@ class Solution:
 
 ```java
 class Solution {
+    private int m;
+    private int n;
+    private int[][] grid;
+
     public int[][] rotateGrid(int[][] grid, int k) {
-        int m = grid.length, n = grid[0].length;
-        int s1 = 0, e1 = 0;
-        int s2 = m - 1, e2 = n - 1;
-        while (s1 <= s2 && e1 <= e2) {
-            rotate(grid, s1++, e1++, s2--, e2--, k);
+        m = grid.length;
+        n = grid[0].length;
+        this.grid = grid;
+        for (int p = 0; p < Math.min(m, n) / 2; ++p) {
+            rotate(p, k);
         }
         return grid;
     }
 
-    private void rotate(int[][] grid, int s1, int e1, int s2, int e2, int k) {
-        List<Integer> t = new ArrayList<>();
-        for (int j = e2; j > e1; --j) {
-            t.add(grid[s1][j]);
+    private void rotate(int p, int k) {
+        List<Integer> nums = new ArrayList<>();
+        for (int j = p; j < n - p - 1; ++j) {
+            nums.add(grid[p][j]);
         }
-        for (int i = s1; i < s2; ++i) {
-            t.add(grid[i][e1]);
+        for (int i = p; i < m - p - 1; ++i) {
+            nums.add(grid[i][n - p - 1]);
         }
-        for (int j = e1; j < e2; ++j) {
-            t.add(grid[s2][j]);
+        for (int j = n - p - 1; j > p; --j) {
+            nums.add(grid[m - p - 1][j]);
         }
-        for (int i = s2; i > s1; --i) {
-            t.add(grid[i][e2]);
+        for (int i = m - p - 1; i > p; --i) {
+            nums.add(grid[i][p]);
         }
-        int n = t.size();
-        k %= n;
+        int l = nums.size();
+        k %= l;
         if (k == 0) {
             return;
         }
-        k = n - k;
-        for (int j = e2; j > e1; --j) {
-            grid[s1][j] = t.get(k);
-            k = (k + 1) % n;
+        for (int j = p; j < n - p - 1; ++j) {
+            grid[p][j] = nums.get(k++ % l);
+        }
+        for (int i = p; i < m - p - 1; ++i) {
+            grid[i][n - p - 1] = nums.get(k++ % l);
+        }
+        for (int j = n - p - 1; j > p; --j) {
+            grid[m - p - 1][j] = nums.get(k++ % l);
+        }
+        for (int i = m - p - 1; i > p; --i) {
+            grid[i][p] = nums.get(k++ % l);
+        }
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> rotateGrid(vector<vector<int>>& grid, int k) {
+        int m = grid.size(), n = grid[0].size();
+        auto rotate = [&](int p, int k) {
+            vector<int> nums;
+            for (int j = p; j < n - p - 1; ++j) {
+                nums.push_back(grid[p][j]);
+            }
+            for (int i = p; i < m - p - 1; ++i) {
+                nums.push_back(grid[i][n - p - 1]);
+            }
+            for (int j = n - p - 1; j > p; --j) {
+                nums.push_back(grid[m - p - 1][j]);
+            }
+            for (int i = m - p - 1; i > p; --i) {
+                nums.push_back(grid[i][p]);
+            }
+            int l = nums.size();
+            k %= l;
+            if (k == 0) {
+                return;
+            }
+            for (int j = p; j < n - p - 1; ++j) {
+                grid[p][j] = nums[k++ % l];
+            }
+            for (int i = p; i < m - p - 1; ++i) {
+                grid[i][n - p - 1] = nums[k++ % l];
+            }
+            for (int j = n - p - 1; j > p; --j) {
+                grid[m - p - 1][j] = nums[k++ % l];
+            }
+            for (int i = m - p - 1; i > p; --i) {
+                grid[i][p] = nums[k++ % l];
+            }
+        };
+        for (int p = 0; p < min(m, n) / 2; ++p) {
+            rotate(p, k);
+        }
+        return grid;
+    }
+};
+```
+
+### **Go**
+
+```go
+func rotateGrid(grid [][]int, k int) [][]int {
+	m, n := len(grid), len(grid[0])
+
+	rotate := func(p, k int) {
+		nums := []int{}
+		for j := p; j < n-p-1; j++ {
+			nums = append(nums, grid[p][j])
+		}
+		for i := p; i < m-p-1; i++ {
+			nums = append(nums, grid[i][n-p-1])
+		}
+		for j := n - p - 1; j > p; j-- {
+			nums = append(nums, grid[m-p-1][j])
+		}
+		for i := m - p - 1; i > p; i-- {
+			nums = append(nums, grid[i][p])
+		}
+		l := len(nums)
+		k %= l
+		if k == 0 {
+			return
+		}
+		for j := p; j < n-p-1; j++ {
+			grid[p][j] = nums[k]
+			k = (k + 1) % l
+		}
+		for i := p; i < m-p-1; i++ {
+			grid[i][n-p-1] = nums[k]
+			k = (k + 1) % l
+		}
+		for j := n - p - 1; j > p; j-- {
+			grid[m-p-1][j] = nums[k]
+			k = (k + 1) % l
+		}
+		for i := m - p - 1; i > p; i-- {
+			grid[i][p] = nums[k]
+			k = (k + 1) % l
+		}
+	}
+
+	for i := 0; i < m/2 && i < n/2; i++ {
+		rotate(i, k)
+	}
+	return grid
+}
+```
+
+### **TypeScript**
+
+```ts
+function rotateGrid(grid: number[][], k: number): number[][] {
+    const m = grid.length;
+    const n = grid[0].length;
+    const rotate = (p: number, k: number) => {
+        const nums: number[] = [];
+        for (let j = p; j < n - p - 1; ++j) {
+            nums.push(grid[p][j]);
+        }
+        for (let i = p; i < m - p - 1; ++i) {
+            nums.push(grid[i][n - p - 1]);
+        }
+        for (let j = n - p - 1; j > p; --j) {
+            nums.push(grid[m - p - 1][j]);
+        }
+        for (let i = m - p - 1; i > p; --i) {
+            nums.push(grid[i][p]);
+        }
+        const l = nums.length;
+        k %= l;
+        if (k === 0) {
+            return;
+        }
+        for (let j = p; j < n - p - 1; ++j) {
+            grid[p][j] = nums[k++ % l];
         }
-        for (int i = s1; i < s2; ++i) {
-            grid[i][e1] = t.get(k);
-            k = (k + 1) % n;
+        for (let i = p; i < m - p - 1; ++i) {
+            grid[i][n - p - 1] = nums[k++ % l];
         }
-        for (int j = e1; j < e2; ++j) {
-            grid[s2][j] = t.get(k);
-            k = (k + 1) % n;
+        for (let j = n - p - 1; j > p; --j) {
+            grid[m - p - 1][j] = nums[k++ % l];
         }
-        for (int i = s2; i > s1; --i) {
-            grid[i][e2] = t.get(k);
-            k = (k + 1) % n;
+        for (let i = m - p - 1; i > p; --i) {
+            grid[i][p] = nums[k++ % l];
         }
+    };
+    for (let p = 0; p < Math.min(m, n) >> 1; ++p) {
+        rotate(p, k);
     }
+    return grid;
 }
 ```