Merge branch 'doocs:main' into main

Author: Nothing-avil

images/starcharts.svg

@@ -19,7 +19,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/lcci/08.01.Three%20Steps%2
 <p> <strong>示例1:</strong></p>
 
 <pre>
-<strong> 输入</strong>：n = 3 
+<strong> 输入</strong>：n = 3
 <strong> 输出</strong>：4
 <strong> 说明</strong>: 有四种走法
 </pre>
@@ -226,37 +226,6 @@ $$
 
 #### Python3
 
-```python
-class Solution:
-    def waysToStep(self, n: int) -> int:
-        mod = 10**9 + 7
-
-        def mul(a: List[List[int]], b: List[List[int]]) -> List[List[int]]:
-            m, n = len(a), len(b[0])
-            c = [[0] * n for _ in range(m)]
-            for i in range(m):
-                for j in range(n):
-                    for k in range(len(a[0])):
-                        c[i][j] = (c[i][j] + a[i][k] * b[k][j] % mod) % mod
-            return c
-
-        def pow(a: List[List[int]], n: int) -> List[List[int]]:
-            res = [[4, 2, 1]]
-            while n:
-                if n & 1:
-                    res = mul(res, a)
-                n >>= 1
-                a = mul(a, a)
-            return res
-
-        if n < 4:
-            return 2 ** (n - 1)
-        a = [[1, 1, 0], [1, 0, 1], [1, 0, 0]]
-        return sum(pow(a, n - 4)[0]) % mod
-```
-
-#### Python3
-
 ```python
 import numpy as np
 
@@ -266,8 +235,8 @@ class Solution:
         if n < 4:
             return 2 ** (n - 1)
         mod = 10**9 + 7
-        factor = np.mat([(1, 1, 0), (1, 0, 1), (1, 0, 0)], np.dtype("O"))
-        res = np.mat([(4, 2, 1)], np.dtype("O"))
+        factor = np.asmatrix([(1, 1, 0), (1, 0, 1), (1, 0, 0)], np.dtype("O"))
+        res = np.asmatrix([(4, 2, 1)], np.dtype("O"))
         n -= 4
         while n:
             if n & 1:

lcci/08.01.Three Steps Problem/README.md

@@ -20,7 +20,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/lcci/08.01.Three%20Steps%2
 
 <pre>
 
-<strong> Input</strong>: n = 3 
+<strong> Input</strong>: n = 3
 
 <strong> Output</strong>: 4
 
@@ -229,37 +229,6 @@ The time complexity is $O(\log n)$, and the space complexity is $O(1)$.
 
 #### Python3
 
-```python
-class Solution:
-    def waysToStep(self, n: int) -> int:
-        mod = 10**9 + 7
-
-        def mul(a: List[List[int]], b: List[List[int]]) -> List[List[int]]:
-            m, n = len(a), len(b[0])
-            c = [[0] * n for _ in range(m)]
-            for i in range(m):
-                for j in range(n):
-                    for k in range(len(a[0])):
-                        c[i][j] = (c[i][j] + a[i][k] * b[k][j] % mod) % mod
-            return c
-
-        def pow(a: List[List[int]], n: int) -> List[List[int]]:
-            res = [[4, 2, 1]]
-            while n:
-                if n & 1:
-                    res = mul(res, a)
-                n >>= 1
-                a = mul(a, a)
-            return res
-
-        if n < 4:
-            return 2 ** (n - 1)
-        a = [[1, 1, 0], [1, 0, 1], [1, 0, 0]]
-        return sum(pow(a, n - 4)[0]) % mod
-```
-
-#### Python3
-
 ```python
 import numpy as np
 
@@ -269,8 +238,8 @@ class Solution:
         if n < 4:
             return 2 ** (n - 1)
         mod = 10**9 + 7
-        factor = np.mat([(1, 1, 0), (1, 0, 1), (1, 0, 0)], np.dtype("O"))
-        res = np.mat([(4, 2, 1)], np.dtype("O"))
+        factor = np.asmatrix([(1, 1, 0), (1, 0, 1), (1, 0, 0)], np.dtype("O"))
+        res = np.asmatrix([(4, 2, 1)], np.dtype("O"))
         n -= 4
         while n:
             if n & 1:

lcci/08.01.Three Steps Problem/README_EN.md

@@ -1,26 +1,17 @@
-class Solution:
-    def waysToStep(self, n: int) -> int:
-        mod = 10**9 + 7
-
-        def mul(a: List[List[int]], b: List[List[int]]) -> List[List[int]]:
-            m, n = len(a), len(b[0])
-            c = [[0] * n for _ in range(m)]
-            for i in range(m):
-                for j in range(n):
-                    for k in range(len(a[0])):
-                        c[i][j] = (c[i][j] + a[i][k] * b[k][j] % mod) % mod
-            return c
+import numpy as np
 
-        def pow(a: List[List[int]], n: int) -> List[List[int]]:
-            res = [[4, 2, 1]]
-            while n:
-                if n & 1:
-                    res = mul(res, a)
-                n >>= 1
-                a = mul(a, a)
-            return res
 
+class Solution:
+    def waysToStep(self, n: int) -> int:
         if n < 4:
             return 2 ** (n - 1)
-        a = [[1, 1, 0], [1, 0, 1], [1, 0, 0]]
-        return sum(pow(a, n - 4)[0]) % mod
+        mod = 10**9 + 7
+        factor = np.asmatrix([(1, 1, 0), (1, 0, 1), (1, 0, 0)], np.dtype("O"))
+        res = np.asmatrix([(4, 2, 1)], np.dtype("O"))
+        n -= 4
+        while n:
+            if n & 1:
+                res = res * factor % mod
+            factor = factor * factor % mod
+            n >>= 1
+        return res.sum() % mod

lcci/08.01.Three Steps Problem/Solution2.py

@@ -247,6 +247,30 @@ var uniquePaths = function (m, n) {
 };
 ```
 
+#### Swift
+
+```swift
+class Solution {
+    func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        var dp = Array(repeating: Array(repeating: 0, count: n), count: m)
+        dp[0][0] = 1
+
+        for i in 0..<m {
+            for j in 0..<n {
+                if i > 0 {
+                    dp[i][j] += dp[i - 1][j]
+                }
+                if j > 0 {
+                    dp[i][j] += dp[i][j - 1]
+                }
+            }
+        }
+
+        return dp[m - 1][n - 1]
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
@@ -362,6 +386,24 @@ var uniquePaths = function (m, n) {
 };
 ```
 
+#### Swift
+
+```swift
+class Solution {
+    func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        var dp = Array(repeating: Array(repeating: 1, count: n), count: m)
+
+        for i in 1..<m {
+            for j in 1..<n {
+                dp[i][j] = dp[i-1][j] + dp[i][j-1]
+            }
+        }
+
+        return dp[m-1][n-1]
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

lcci/08.01.Three Steps Problem/Solution3.py

@@ -0,0 +1,19 @@
+class Solution {
+    func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        var dp = Array(repeating: Array(repeating: 0, count: n), count: m)
+        dp[0][0] = 1
+        
+        for i in 0..<m {
+            for j in 0..<n {
+                if i > 0 {
+                    dp[i][j] += dp[i - 1][j]
+                }
+                if j > 0 {
+                    dp[i][j] += dp[i][j - 1]
+                }
+            }
+        }
+        
+        return dp[m - 1][n - 1]
+    }
+}

lcof2/剑指 Offer II 098. 路径的数目/README.md

@@ -0,0 +1,13 @@
+class Solution {
+    func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        var dp = Array(repeating: Array(repeating: 1, count: n), count: m)
+
+        for i in 1..<m {
+            for j in 1..<n {
+                dp[i][j] = dp[i-1][j] + dp[i][j-1]
+            }
+        }
+
+        return dp[m-1][n-1]
+    }
+}

lcof2/剑指 Offer II 098. 路径的数目/Solution.swift

@@ -202,6 +202,34 @@ public class Solution {
 }
 ```
 
+#### Swift
+
+```swift
+class Solution {
+    func minPathSum(_ grid: [[Int]]) -> Int {
+        let m = grid.count
+        let n = grid[0].count
+        var dp = grid
+
+        for i in 1..<m {
+            dp[i][0] += dp[i-1][0]
+        }
+
+        for j in 1..<n {
+            dp[0][j] += dp[0][j-1]
+        }
+
+        for i in 1..<m {
+            for j in 1..<n {
+                dp[i][j] += min(dp[i-1][j], dp[i][j-1])
+            }
+        }
+
+        return dp[m-1][n-1]
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

lcof2/剑指 Offer II 098. 路径的数目/Solution2.swift

@@ -0,0 +1,23 @@
+class Solution {
+    func minPathSum(_ grid: [[Int]]) -> Int {
+        let m = grid.count
+        let n = grid[0].count
+        var dp = grid
+
+        for i in 1..<m {
+            dp[i][0] += dp[i-1][0]
+        }
+        
+        for j in 1..<n {
+            dp[0][j] += dp[0][j-1]
+        }
+        
+        for i in 1..<m {
+            for j in 1..<n {
+                dp[i][j] += min(dp[i-1][j], dp[i][j-1])
+            }
+        }
+        
+        return dp[m-1][n-1]
+    }
+}