feat: add solutions to lc problems: No.0078,1886

YangFong · YangFong · commit 3bd9bd79c4ab · 2022-04-28T10:18:49.000+08:00
- No.0078.Subsets
- No.1886.Determine Whether Matrix Can Be Obtained By Rotation
diff --git a/solution/0000-0099/0078.Subsets/README.md b/solution/0000-0099/0078.Subsets/README.md
@@ -140,6 +140,32 @@ func subsets(nums []int) [][]int {
 }
 ```
 
+### **Rust1**
+
+```rust
+impl Solution {
+    fn dfs(nums: &Vec<i32>, res: &mut Vec<Vec<i32>>, i: usize, base: &mut Vec<i32>) {
+        let n = nums.len();
+        if i == n {
+            return;
+        }
+        for j in i..n {
+            base.push(nums[j]);
+            res.push(base.clone());
+            Self::dfs(nums, res, j + 1, base);
+            base.pop();
+        }
+    }
+
+    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut base = vec![];
+        let mut res = vec![vec![]];
+        Self::dfs(&nums, &mut res, 0, &mut base);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/0000-0099/0078.Subsets/README_EN.md b/solution/0000-0099/0078.Subsets/README_EN.md
@@ -132,6 +132,32 @@ func subsets(nums []int) [][]int {
 }
 ```
 
+### **Rust1**
+
+```rust
+impl Solution {
+    fn dfs(nums: &Vec<i32>, res: &mut Vec<Vec<i32>>, i: usize, base: &mut Vec<i32>) {
+        let n = nums.len();
+        if i == n {
+            return;
+        }
+        for j in i..n {
+            base.push(nums[j]);
+            res.push(base.clone());
+            Self::dfs(nums, res, j + 1, base);
+            base.pop();
+        }
+    }
+
+    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut base = vec![];
+        let mut res = vec![vec![]];
+        Self::dfs(&nums, &mut res, 0, &mut base);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/0000-0099/0078.Subsets/Solution.rs b/solution/0000-0099/0078.Subsets/Solution.rs
@@ -0,0 +1,21 @@
+impl Solution {
+    fn dfs(nums: &Vec<i32>, res: &mut Vec<Vec<i32>>, i: usize, base: &mut Vec<i32>) {
+        let n = nums.len();
+        if i == n {
+            return;
+        }
+        for j in i..n {
+            base.push(nums[j]);
+            res.push(base.clone());
+            Self::dfs(nums, res, j + 1, base);
+            base.pop();
+        }
+    }
+
+    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut base = vec![];
+        let mut res = vec![vec![]];
+        Self::dfs(&nums, &mut res, 0, &mut base);
+        res
+    }
+}
diff --git a/solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/README.md b/solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/README.md
@@ -49,7 +49,22 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-旋转矩阵，判断矩阵是否一致。
+方法一：模拟旋转
+
+旋转矩阵，判断矩阵是否一致，旋转方式同 [48. 旋转图像](https://leetcode-cn.com/problems/rotate-image/)。
+
+方法二：原地比较
+
+此题不同于 [48. 旋转图像](https://leetcode-cn.com/problems/rotate-image/)，并不要求改动原数组，因此，只要比较对应的位置即可。
+
+| 旋转度数 | A      | B              |
+| -------- | ------ | -------------- |
+| 0        | `i, j` | `i, j`         |
+| 90       | `i, j` | `j, n - i`     |
+| 180      | `i, j` | `n - i, n - j` |
+| 270      | `i, j` | `n - j, i`     |
+
+> `n = A.length - 1 = B.length - 1`
 
 <!-- tabs:start -->
 
@@ -120,6 +135,79 @@ class Solution {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findRotation(mat: number[][], target: number[][]): boolean {
+    for (let k = 0; k < 4; k++) {
+        rotate(mat);
+        if (isEqual(mat, target)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function isEqual(A: number[][], B: number[][]) {
+    const n = A.length;
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            if (A[i][j] !== B[i][j]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+function rotate(matrix: number[][]): void {
+    const n = matrix.length;
+    for (let i = 0; i < n >> 1; i++) {
+        for (let j = 0; j < (n + 1) >> 1; j++) {
+            [
+                matrix[i][j],
+                matrix[n - 1 - j][i],
+                matrix[n - 1 - i][n - 1 - j],
+                matrix[j][n - 1 - i],
+            ] = [
+                matrix[n - 1 - j][i],
+                matrix[n - 1 - i][n - 1 - j],
+                matrix[j][n - 1 - i],
+                matrix[i][j],
+            ];
+        }
+    }
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn find_rotation(mat: Vec<Vec<i32>>, target: Vec<Vec<i32>>) -> bool {
+        let n = mat.len();
+        let mut is_equal = [true; 4];
+        for i in 0..n {
+            for j in 0..n {
+                if is_equal[0] && mat[i][j] != target[i][j] {
+                    is_equal[0] = false;
+                }
+                if is_equal[1] && mat[i][j] != target[j][n - 1 - i] {
+                    is_equal[1] = false;
+                }
+                if is_equal[2] && mat[i][j] != target[n - 1 - i][n - 1 - j] {
+                    is_equal[2] = false;
+                }
+                if is_equal[3] && mat[i][j] != target[n - 1 - j][i] {
+                    is_equal[3] = false;
+                }
+            }
+        }
+        is_equal.into_iter().any(|&v| v)
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/README_EN.md b/solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/README_EN.md
@@ -108,6 +108,80 @@ class Solution {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findRotation(mat: number[][], target: number[][]): boolean {
+    for (let k = 0; k < 4; k++) {
+        rotate(mat);
+        if (isEqual(mat, target)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function isEqual(A: number[][], B: number[][]) {
+    const n = A.length;
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            if (A[i][j] !== B[i][j]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+function rotate(matrix: number[][]): void {
+    const n = matrix.length;
+    for (let i = 0; i < n >> 1; i++) {
+        for (let j = 0; j < (n + 1) >> 1; j++) {
+            [
+                matrix[i][j],
+                matrix[n - 1 - j][i],
+                matrix[n - 1 - i][n - 1 - j],
+                matrix[j][n - 1 - i],
+            ] = [
+                matrix[n - 1 - j][i],
+                matrix[n - 1 - i][n - 1 - j],
+                matrix[j][n - 1 - i],
+                matrix[i][j],
+            ];
+        }
+    }
+}
+
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn find_rotation(mat: Vec<Vec<i32>>, target: Vec<Vec<i32>>) -> bool {
+        let n = mat.len();
+        let mut is_equal = [true; 4];
+        for i in 0..n {
+            for j in 0..n {
+                if is_equal[0] && mat[i][j] != target[i][j] {
+                    is_equal[0] = false;
+                }
+                if is_equal[1] && mat[i][j] != target[j][n - 1 - i] {
+                    is_equal[1] = false;
+                }
+                if is_equal[2] && mat[i][j] != target[n - 1 - i][n - 1 - j] {
+                    is_equal[2] = false;
+                }
+                if is_equal[3] && mat[i][j] != target[n - 1 - j][i] {
+                    is_equal[3] = false;
+                }
+            }
+        }
+        is_equal.into_iter().any(|&v| v)
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/Solution.rs b/solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/Solution.rs
@@ -0,0 +1,23 @@
+impl Solution {
+    pub fn find_rotation(mat: Vec<Vec<i32>>, target: Vec<Vec<i32>>) -> bool {
+        let n = mat.len();
+        let mut is_equal = [true; 4];
+        for i in 0..n {
+            for j in 0..n {
+                if is_equal[0] && mat[i][j] != target[i][j] {
+                    is_equal[0] = false;
+                }
+                if is_equal[1] && mat[i][j] != target[j][n - 1 - i] {
+                    is_equal[1] = false;
+                }
+                if is_equal[2] && mat[i][j] != target[n - 1 - i][n - 1 - j] {
+                    is_equal[2] = false;
+                }
+                if is_equal[3] && mat[i][j] != target[n - 1 - j][i] {
+                    is_equal[3] = false;
+                }
+            }
+        }
+        is_equal.into_iter().any(|&v| v)
+    }
+}
diff --git a/solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/Solution.ts b/solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/Solution.ts
@@ -0,0 +1,40 @@
+function findRotation(mat: number[][], target: number[][]): boolean {
+    for (let k = 0; k < 4; k++) {
+        rotate(mat);
+        if (isEqual(mat, target)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function isEqual(A: number[][], B: number[][]) {
+    const n = A.length;
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            if (A[i][j] !== B[i][j]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+function rotate(matrix: number[][]): void {
+    const n = matrix.length;
+    for (let i = 0; i < n >> 1; i++) {
+        for (let j = 0; j < (n + 1) >> 1; j++) {
+            [
+                matrix[i][j],
+                matrix[n - 1 - j][i],
+                matrix[n - 1 - i][n - 1 - j],
+                matrix[j][n - 1 - i],
+            ] = [
+                matrix[n - 1 - j][i],
+                matrix[n - 1 - i][n - 1 - j],
+                matrix[j][n - 1 - i],
+                matrix[i][j],
+            ];
+        }
+    }
+}
