feat: add solutions to lc problem: No.0566

No.0566.Reshape the Matrix

Author: yanglbme

solution/0500-0599/0555.Split Concatenated Strings/README.md

@@ -54,7 +54,7 @@
 
 我们先遍历字符串数组 `strs`，对于每个字符串 $s$，如果 $s$ 的反转字符串 $t$ 比 $s$ 大，那么我们就将 $s$ 替换为 $t$。
 
-然后我们再枚举字符串数组 `strs` 的每个位置 $i$ 作为分割点，将字符串数组 `strs` 拆成两部分，分别为 $strs[i + 1:]$ 和 $strs[:i]$，然后将这两部分拼接起来，得到一个新的字符串 $t$。接下来，我们枚举当前字符串 $strs[i]$ 的每个位置 $j$，其后缀部分为 $a=strs[i][j:]$，前缀部分为 $b=strs[i][:j]$，那么我们可以将 $a$、$t$ 和 $b$ 拼接起来，得到一个新的字符串 $cur$，如果 $cur$ 比当前答案大，那么我们就更新答案。这是将 $strs[i]$ 翻转后的情况，我们还需要考虑 $strs[i]$ 不翻转的情况，即将 $a$、$t$ 和 $b$ 的顺序反过来拼接，得到一个新的字符串 $cur$，如果 $cur$ 比当前答案大，那么我们就更新答案。
+然后我们再枚举字符串数组 `strs` 的每个位置 $i$ 作为分割点，将字符串数组 `strs` 拆成两部分，分别为 $strs[i + 1:]$ 和 $strs[:i]$，然后将这两部分拼接起来，得到一个新的字符串 $t$。接下来，我们枚举当前字符串 $strs[i]$ 的每个位置 $j$，其后缀部分为 $a=strs[i][j:]$，前缀部分为 $b=strs[i][:j]$，那么我们可以将 $a$, $t$ 和 $b$ 拼接起来，得到一个新的字符串 $cur$，如果 $cur$ 比当前答案大，那么我们就更新答案。这是将 $strs[i]$ 翻转后的情况，我们还需要考虑 $strs[i]$ 不翻转的情况，即将 $a$, $t$ 和 $b$ 的顺序反过来拼接，得到一个新的字符串 $cur$，如果 $cur$ 比当前答案大，那么我们就更新答案。
 
 最后，我们返回答案即可。
 

solution/0500-0599/0566.Reshape the Matrix/README.md

@@ -46,6 +46,16 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：模拟**
+
+我们先获取原矩阵的行数和列数，分别记为 $m$ 和 $n$。如果 $m \times n \neq r \times c$，则无法重塑矩阵，直接返回原矩阵。
+
+否则，我们创建一个新矩阵，新矩阵的行数为 $r$，列数为 $c$。我们从原矩阵的第一个元素开始，按照行优先的顺序遍历原矩阵的所有元素，将遍历到的元素按顺序放入新矩阵中。
+
+遍历完原矩阵的所有元素后，我们即可得到答案。
+
+时间复杂度 $O(m \times n)$，其中 $m$ 和 $n$ 分别是原矩阵的行数和列数。忽略答案的空间消耗，空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -54,14 +64,14 @@
 
 ```python
 class Solution:
-    def matrixReshape(self, nums: List[List[int]], r: int, c: int) -> List[List[int]]:
-        m, n = len(nums), len(nums[0])
+    def matrixReshape(self, mat: List[List[int]], r: int, c: int) -> List[List[int]]:
+        m, n = len(mat), len(mat[0])
         if m * n != r * c:
-            return nums
-        res = [[0] * c for _ in range(r)]
-        for x in range(m * n):
-            res[x // c][x % c] = nums[x // n][x % n]
-        return res
+            return mat
+        ans = [[0] * c for _ in range(r)]
+        for i in range(m * n):
+            ans[i // c][i % c] = mat[i // n][i % n]
+        return ans
 ```
 
 ### **Java**
@@ -70,18 +80,58 @@ class Solution:
 
 ```java
 class Solution {
-    public int[][] matrixReshape(int[][] nums, int r, int c) {
-        int m = nums.length, n = nums[0].length;
-        if (m * n != r * c) return nums;
-        int[][] res = new int[r][c];
+    public int[][] matrixReshape(int[][] mat, int r, int c) {
+        int m = mat.length, n = mat[0].length;
+        if (m * n != r * c) {
+            return mat;
+        }
+        int[][] ans = new int[r][c];
         for (int i = 0; i < m * n; ++i) {
-            res[i / c][i % c] = nums[i / n][i % n];
+            ans[i / c][i % c] = mat[i / n][i % n];
         }
-        return res;
+        return ans;
     }
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
+        int m = mat.size(), n = mat[0].size();
+        if (m * n != r * c) {
+            return mat;
+        }
+        vector<vector<int>> ans(r, vector<int>(c));
+        for (int i = 0; i < m * n; ++i) {
+            ans[i / c][i % c] = mat[i / n][i % n];
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func matrixReshape(mat [][]int, r int, c int) [][]int {
+	m, n := len(mat), len(mat[0])
+	if m*n != r*c {
+		return mat
+	}
+	ans := make([][]int, r)
+	for i := range ans {
+		ans[i] = make([]int, c)
+	}
+	for i := 0; i < m*n; i++ {
+		ans[i/c][i%c] = mat[i/n][i%n]
+	}
+	return ans
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/0500-0599/0566.Reshape the Matrix/README_EN.md

@@ -46,29 +46,69 @@
 
 ```python
 class Solution:
-    def matrixReshape(self, nums: List[List[int]], r: int, c: int) -> List[List[int]]:
-        m, n = len(nums), len(nums[0])
+    def matrixReshape(self, mat: List[List[int]], r: int, c: int) -> List[List[int]]:
+        m, n = len(mat), len(mat[0])
         if m * n != r * c:
-            return nums
-        res = [[0] * c for _ in range(r)]
-        for x in range(m * n):
-            res[x // c][x % c] = nums[x // n][x % n]
-        return res
+            return mat
+        ans = [[0] * c for _ in range(r)]
+        for i in range(m * n):
+            ans[i // c][i % c] = mat[i // n][i % n]
+        return ans
 ```
 
 ### **Java**
 
 ```java
 class Solution {
-    public int[][] matrixReshape(int[][] nums, int r, int c) {
-        int m = nums.length, n = nums[0].length;
-        if (m * n != r * c) return nums;
-        int[][] res = new int[r][c];
+    public int[][] matrixReshape(int[][] mat, int r, int c) {
+        int m = mat.length, n = mat[0].length;
+        if (m * n != r * c) {
+            return mat;
+        }
+        int[][] ans = new int[r][c];
+        for (int i = 0; i < m * n; ++i) {
+            ans[i / c][i % c] = mat[i / n][i % n];
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
+        int m = mat.size(), n = mat[0].size();
+        if (m * n != r * c) {
+            return mat;
+        }
+        vector<vector<int>> ans(r, vector<int>(c));
         for (int i = 0; i < m * n; ++i) {
-            res[i / c][i % c] = nums[i / n][i % n];
+            ans[i / c][i % c] = mat[i / n][i % n];
         }
-        return res;
+        return ans;
     }
+};
+```
+
+### **Go**
+
+```go
+func matrixReshape(mat [][]int, r int, c int) [][]int {
+	m, n := len(mat), len(mat[0])
+	if m*n != r*c {
+		return mat
+	}
+	ans := make([][]int, r)
+	for i := range ans {
+		ans[i] = make([]int, c)
+	}
+	for i := 0; i < m*n; i++ {
+		ans[i/c][i%c] = mat[i/n][i%n]
+	}
+	return ans
 }
 ```
 

solution/0500-0599/0566.Reshape the Matrix/Solution.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
+        int m = mat.size(), n = mat[0].size();
+        if (m * n != r * c) {
+            return mat;
+        }
+        vector<vector<int>> ans(r, vector<int>(c));
+        for (int i = 0; i < m * n; ++i) {
+            ans[i / c][i % c] = mat[i / n][i % n];
+        }
+        return ans;
+    }
+};

solution/0500-0599/0566.Reshape the Matrix/Solution.go

@@ -0,0 +1,14 @@
+func matrixReshape(mat [][]int, r int, c int) [][]int {
+	m, n := len(mat), len(mat[0])
+	if m*n != r*c {
+		return mat
+	}
+	ans := make([][]int, r)
+	for i := range ans {
+		ans[i] = make([]int, c)
+	}
+	for i := 0; i < m*n; i++ {
+		ans[i/c][i%c] = mat[i/n][i%n]
+	}
+	return ans
+}

solution/0500-0599/0566.Reshape the Matrix/Solution.java

@@ -1,11 +1,13 @@
 class Solution {
-    public int[][] matrixReshape(int[][] nums, int r, int c) {
-        int m = nums.length, n = nums[0].length;
-        if (m * n != r * c) return nums;
-        int[][] res = new int[r][c];
+    public int[][] matrixReshape(int[][] mat, int r, int c) {
+        int m = mat.length, n = mat[0].length;
+        if (m * n != r * c) {
+            return mat;
+        }
+        int[][] ans = new int[r][c];
         for (int i = 0; i < m * n; ++i) {
-            res[i / c][i % c] = nums[i / n][i % n];
+            ans[i / c][i % c] = mat[i / n][i % n];
         }
-        return res;
+        return ans;
     }
 }

solution/0500-0599/0566.Reshape the Matrix/Solution.py

@@ -1,9 +1,9 @@
 class Solution:
-    def matrixReshape(self, nums: List[List[int]], r: int, c: int) -> List[List[int]]:
-        m, n = len(nums), len(nums[0])
+    def matrixReshape(self, mat: List[List[int]], r: int, c: int) -> List[List[int]]:
+        m, n = len(mat), len(mat[0])
         if m * n != r * c:
-            return nums
-        res = [[0] * c for _ in range(r)]
-        for x in range(m * n):
-            res[x // c][x % c] = nums[x // n][x % n]
-        return res
+            return mat
+        ans = [[0] * c for _ in range(r)]
+        for i in range(m * n):
+            ans[i // c][i % c] = mat[i // n][i % n]
+        return ans