update

Author: tiationg-kho

[M]dynamic-programming/[M]dynamic-programming/10-regular-expression-matching.py

@@ -2,31 +2,36 @@ class Solution:
     def isMatch(self, s: str, p: str) -> bool:
         m, n = len(s), len(p)
         dp = [[False for _ in range(n + 1)] for _ in range(m + 1)]
-        dp[0][0] = True
 
-        for j in range(1, n + 1):
-            if p[j - 1] == '*':
-                dp[0][j] = dp[0][j - 2]
+        dp[0][0] = True
+        for i in range(1, n + 1):
+            if p[i - 1] == '*' and dp[0][i - 2]:
+                dp[0][i] = True
+        for j in range(1, m + 1):
+            dp[j][0] = False
 
         for i in range(1, m + 1):
             for j in range(1, n + 1):
-                if p[j - 1] == '*':
-                    if p[j - 2] == '.':
-                        dp[i][j] = dp[i][j - 2] or dp[i - 1][j - 2] or dp[i - 1][j]
-                    else:
-                        if s[i - 1] == p[j - 2]:
-                            dp[i][j] = dp[i][j - 2] or dp[i - 1][j - 2] or dp[i - 1][j]
-                        else:
-                            dp[i][j] = dp[i][j - 2]
-                elif p[j - 1] == '.':
+                if s[i - 1] == p[j - 1]:
                     dp[i][j] = dp[i - 1][j - 1]
-                elif s[i - 1] == p[j - 1]:
+                elif p[j - 1] == '.':
                     dp[i][j] = dp[i - 1][j - 1]
+                elif p[j - 1] == '*':
+                    if p[j - 2] == '.':
+                        dp[i][j] |= dp[i][j - 2]
+                        dp[i][j] |= dp[i - 1][j - 2]
+                        dp[i][j] |= dp[i - 1][j]
+                    elif s[i - 1] == p[j - 2]:
+                        dp[i][j] |= dp[i][j - 2]
+                        dp[i][j] |= dp[i - 1][j - 2]
+                        dp[i][j] |= dp[i - 1][j]
+                    else:
+                        dp[i][j] = dp[i][j - 2]
                 else:
-                    pass
-        
+                    dp[i][j] = False
+
         return dp[m][n]
-    
+        
 # time O(mn)
 # space O(mn)
 # using dynamic programming and double sequence

[M]dynamic-programming/[M]dynamic-programming/221-maximal-square.py

@@ -1,23 +1,20 @@
 class Solution:
     def maximalSquare(self, matrix: List[List[str]]) -> int:
+        
         rows, cols = len(matrix), len(matrix[0])
         dp = [[0 for _ in range(cols)] for _ in range(rows)]
+
         res = 0
-        for r in range(rows):
-            for c in range(cols):
-                if r == 0:
-                    if matrix[r][c] == '1':
-                        dp[r][c] = 1
-                elif c == 0:
-                    if matrix[r][c] == '1':
-                        dp[r][c] = 1
+        for i in range(rows):
+            for j in range(cols):
+                if matrix[i][j] == "0":
+                    continue
+                if i == 0 or j == 0:
+                    dp[i][j] = 1
                 else:
-                    if matrix[r][c] == '1':
-                        dp[r][c] = min(dp[r - 1][c], dp[r][c - 1], dp[r - 1][c - 1]) + 1
-
-                res = max(res, dp[r][c])
-        
-        return res ** 2
+                    dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1
+                res = max(res, dp[i][j] ** 2)
+        return res
 
 # time O(nm), due to matrix' size
 # space O(nm), due to list

[M]dynamic-programming/[M]dynamic-programming/63-unique-paths-ii.py

@@ -2,28 +2,22 @@ class Solution:
     def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
         g = obstacleGrid
         rows, cols = len(g), len(g[0])
-        res = [[0 for _ in range(cols)] for _ in range(rows)]
-        if g[0][0] == 0:
-            res[0][0] = 1
-        for i in range(1, rows):
-            if g[i][0] == 1:
-                res[i][0] = 0
-            else:
-                res[i][0] = res[i - 1][0]
-        for i in range(1, cols):
-            if g[0][i] == 1:
-                res[0][i] = 0
-            else:
-                res[0][i] = res[0][i - 1]
-        
-        for i in range(1, rows):
-            for j in range(1, cols):
+        dp = [[0 for _ in range(cols)] for _ in range(rows)]
+
+        for i in range(rows):
+            for j in range(cols):
                 if g[i][j] == 1:
-                    res[i][j] = 0
+                    continue
+                if i == 0 and j == 0:
+                    dp[i][j] = 1
+                elif i == 0:
+                    dp[i][j] = dp[i][j - 1]
+                elif j == 0:
+                    dp[i][j] = dp[i - 1][j]
                 else:
-                    res[i][j] = res[i - 1][j] + res[i][j - 1]
-        
-        return res[rows - 1][cols - 1]
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+
+        return dp[rows-  1][cols - 1]
 
 # time O(RC)
 # space O(RC)

[M]dynamic-programming/[M]dynamic-programming/64-minimum-path-sum.py

@@ -1,18 +1,18 @@
 class Solution:
     def minPathSum(self, grid: List[List[int]]) -> int:
         rows, cols = len(grid), len(grid[0])
-        dp = [[0 for _ in range(cols)] for _ in range(rows)]
+        dp = [[float('inf') for _ in range(cols)] for _ in range(rows)]
 
-        for r in range(rows):
-            for c in range(cols):
-                if r == 0 and c == 0:
-                    dp[r][c] = grid[r][c]
-                elif r == 0:
-                    dp[r][c] = dp[r][c - 1] + grid[r][c]
-                elif c == 0:
-                    dp[r][c] = dp[r - 1][c] + grid[r][c]
+        for i in range(rows):
+            for j in range(cols):
+                if i == 0 and j == 0:
+                    dp[i][j] = grid[i][j]
+                elif i == 0:
+                    dp[i][j] = dp[i][j - 1] + grid[i][j]
+                elif j == 0:
+                    dp[i][j] = dp[i - 1][j] + grid[i][j]
                 else:
-                    dp[r][c] = min(dp[r][c - 1], dp[r - 1][c]) + grid[r][c]
+                    dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]
 
         return dp[rows - 1][cols - 1]