Merge pull request soapyigu#347 from soapyigu/DP

Dp

Author: soapyigu

DP/MaximumNumberPointsCost.swift

@@ -0,0 +1,33 @@
+/**
+ * Question Link: https://leetcode.com/problems/maximum-number-of-points-with-cost/
+ * Primary idea: DP. dp[i][j] is the maximum number of points we can have if points[i][j] is the most recent cell we picked.
+ * Optimization: Keeps track the current row is enough. Update current row max by traversing from left and right.
+ * Time Complexity: O(mn), Space Complexity: O(1)
+ *
+ */
+
+class MaximumNumberPointsCost {
+    func maxPoints(_ points: [[Int]]) -> Int {
+        
+        let m = points.count, n = points[0].count
+        var rowMaxes = points[0]
+        
+        for i in 1..<m {
+            
+            var temp = rowMaxes
+            var leftMax = 0, rightMax = 0
+            
+            for j in 0..<n {
+                leftMax = max(leftMax - 1, temp[j])
+                temp[j] = points[i][j] + leftMax
+            }
+            
+            for j in (0..<n).reversed() {
+                rightMax = max(rightMax - 1, rowMaxes[j])
+                rowMaxes[j] = max(points[i][j] + rightMax, temp[j])
+            }
+        }
+        
+        return rowMaxes.max() ?? 0
+    }
+}

DP/UniquePathsII.swift

@@ -5,37 +5,29 @@
  */
 
 class UniquePathsII {
-    func uniquePathsWithObstacles(_ obstacleGrid: [[Int]]) -> Int {
-        let m = obstacleGrid.count
-        guard m > 0 else {
-            return 0
-        }
+     func uniquePathsWithObstacles(_ obstacleGrid: [[Int]]) -> Int {
+        let m = obstacleGrid.count, n = obstacleGrid[0].count
 
-        let n = obstacleGrid[0].count
-        guard n > 0 else {
-            return 0
-        }
-    
-        var dp = Array(repeating: Array(repeating: -1, count: n), count: m)
+        var dp = Array(repeating: Array(repeating: 0, count: n), count: m)
 
-        return help(m - 1, n - 1, &dp, obstacleGrid)
-    }
-    
-    fileprivate func help(_ m: Int, _ n: Int, _ dp: inout [[Int]], _ obstacleGrid: [[Int]]) -> Int {
-        if m < 0 || n < 0 {
-            return 0
-        }
-        if obstacleGrid[m][n] == 1 {
-            return 0
-        }
-        if m == 0 && n == 0 {
-            return 1
-        }
-        if dp[m][n] != -1 {
-            return dp[m][n]
+        for i in 0..<m {
+            for j in 0..<n {
+                if obstacleGrid[i][j] == 1 {
+                    dp[i][j] = 0
+                } else {
+                    if i == 0 && j == 0 {
+                        dp[i][j] = 1
+                    } else if i == 0 {
+                        dp[i][j] = dp[i][j - 1]
+                    } else if j == 0 {
+                        dp[i][j] = dp[i - 1][j]
+                    } else {
+                        dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+                    }
+                }
+            }
         }
 
-        dp[m][n] = help(m - 1, n, &dp, obstacleGrid) + help(m, n - 1, &dp, obstacleGrid)
-        return dp[m][n]
+        return dp[m - 1][n - 1]
     }
 }

DP/WordBreak.swift

@@ -0,0 +1,26 @@
+/**
+ * Question Link: https://leetcode.com/problems/word-break/
+ * Primary idea: DP. dp[i] = dp[j] && dict.contains(s[j..<i]). Break the operation if current index is already true.
+ * Time Complexity: O(n^3), Space Complexity: O(n)
+ */
+
+class WordBreak {
+    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
+        let dict = Set(wordDict), s = Array(s)
+        var dp = Array(repeating: false, count: s.count + 1)
+        dp[0] = true
+        
+        for i in 1...s.count {
+            for j in 0..<i {
+                let currentStr = String(s[j..<i])
+                
+                if dp[j] && wordDict.contains(currentStr) {
+                    dp[i] = true
+                    break
+                }   
+            }
+        }
+        
+        return dp[s.count]
+    }
+}