2020/9/23

rchen102 · rchen102 · commit 45481bd32bc2 · 2020-09-23T22:03:15.000-04:00
diff --git a/Java/leetcode 10.java b/Java/leetcode 10.java
@@ -1,35 +1,42 @@
+// Solution: dp T： O(nm) S: O(nm)
 class Solution {
     public boolean isMatch(String s, String p) {
         if (s == null || p == null) return s == p;
-        // dp table
-        int len1 = s.length(), len2 = p.length();
-        boolean[][] dp = new boolean[len1+1][len2+1];
-        // base case
+        int n = s.length(), m = p.length();
+        
+        // dp tables
+        boolean[][] dp = new boolean[n+1][m+1];
+        
+        // base cases
+        // 1. p 是空串, dp[i][0] = false，默认初始化已经是 false 了       
+        // 2. 两个都为空串
         dp[0][0] = true;
-        for (int j = 0; j < len2; j++) {
-            if (p.charAt(j) == '*' && dp[0][j-1]) {
-                dp[0][j+1] = true;
+        // 3. s 是空串，p 是 #*#*#*#*...
+        for (int j = 2; j <= m; j = j+2) {
+            if (p.charAt(j-1) == '*' && dp[0][j-2]) {
+                dp[0][j] = true;
             }
         }
         
         // dp 推导
-        for (int i = 1; i <= len1; i++) {
-            for (int j = 1; j <= len2; j++) {
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                // 1. 正好相等，或者 p 是 . 匹配任意一个
                 if (s.charAt(i-1) == p.charAt(j-1) || p.charAt(j-1) == '.') {
                     dp[i][j] = dp[i-1][j-1];
                 }
                 if (p.charAt(j-1) == '*') {
-                    // 匹配 0 次
+                    // 2. 完全不匹配
                     if (s.charAt(i-1) != p.charAt(j-2) && p.charAt(j-2) != '.') {
                         dp[i][j] = dp[i][j-2];
                     }
                     else {
-                        // 匹配 0 或 n 次
-                        dp[i][j] = dp[i-1][j] || dp[i][j-2];
+                        // 3. 匹配 0 个 或者 N 个
+                        dp[i][j] = dp[i][j-2] || dp[i-1][j];
                     }
                 }
             }
         }
-        return dp[len1][len2];
+        return dp[n][m];
     }
 }
diff --git a/Java/leetcode 300.java b/Java/leetcode 300.java
@@ -25,22 +25,20 @@ public int lengthOfLIS(int[] nums) {
         int piles = 0;
         for (int i = 0; i < nums.length; i++) {
             int card = nums[i];
-            int find = binarySearchLeftBound(tops, piles, card);
-            if (find == piles) {
-                piles++;
-            }
-            tops[find] = card;
+            int position = binarySearch(card, tops, piles);
+            if (position > piles-1) piles++;
+            tops[position] = nums[i];
         }
         return piles;
     }
     
-    public int binarySearchLeftBound(int[] nums, int len, int target) {
-        int lo = 0, hi = len - 1;
+    // search range [0...piles-1]
+    int binarySearch(int card, int[] tops, int piles) {
+        int lo = 0, hi = piles - 1;
         while (lo <= hi) {
             int mid = lo + ((hi - lo) >> 1);
-            if (nums[mid] < target) lo = mid + 1;
-            else if (nums[mid] > target) hi = mid - 1;
-            else hi = mid - 1; 
+            if (card > tops[mid]) lo++;
+            else if (card <= tops[mid]) hi--;
         }
         return lo;
     }
diff --git a/Java/leetcode 416.java b/Java/leetcode 416.java
@@ -2,34 +2,35 @@
 class Solution {
     public boolean canPartition(int[] nums) {
         if (nums == null || nums.length == 0) return true;
-        int len = nums.length;
-        // 如果和为奇数，肯定分不了
         int sum = Arrays.stream(nums).sum();
         if (sum % 2 != 0) return false;
-        sum = sum/2;
+        sum = sum / 2;
         
-        // 初始化 Base case
-        boolean[][] dp = new boolean[len+1][sum+1];
-        for (int i = 0; i <= len; i++) {
+        int n = nums.length;
+        boolean dp[][] = new boolean[n+1][sum+1];
+        
+        // base cases
+        // 1. 可选物品为 0，背包也为 0
+        dp[0][0] = true;
+        // 2. 可选物品为 0，背包不为 0，默认 false        
+        // 3. 可选物品不为 0，背包为 0，都为 true
+        for (int i = 1; i <= n; i++) {
             dp[i][0] = true;
         }
-        // 物品为 0 时，无物品可装，注意 dp[0][0] = true
-        for (int j = 1; j <= sum; j++) {
-            dp[0][j] = false;
-        }
-        // 状态转移
-        for (int i = 1; i <= len; i++) {
+        
+        // dp 推导
+        for (int i = 1; i <= n; i++) {
             for (int j = 1; j <= sum; j++) {
-                // 背包容量不足
+                // 注意这里是小于，大于等于都可以
                 if (j < nums[i-1]) {
                     dp[i][j] = dp[i-1][j];
                 }
                 else {
-                    dp[i][j] = dp[i-1][j] || dp[i-1][j - nums[i-1]];
+                    dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i-1]];
                 }
             }
         }
-        return dp[len][sum];
+        return dp[n][sum];
     }
 }
 
diff --git a/Java/leetcode 72.java b/Java/leetcode 72.java
@@ -1,33 +1,41 @@
 // Solution: 基本 dp T: O(mn) S: O(mn)
 class Solution {
     public int minDistance(String word1, String word2) {
-        if (word1 == null && word2 != null) return word2.length();
-        if (word2 == null && word1 != null) return word1.length();
-        if (word1 == null && word2 == null) return 0;
+        String s = word1, t = word2;
+        if (s == null && t == null) return 0;
+        if (s == null && t != null) return t.length();
+        if (s != null && t == null) return s.length();
         
-        int n1 = word1.length();
-        int n2 = word2.length();
-        int[][] dp = new int[n1+1][n2+1];
-        // base case
-        for (int i = 0; i <= n1; i++) {
+        int n = s.length(), m = t.length();
+        int[][] dp = new int[n+1][m+1];
+        // base cases
+        for (int i = 0; i <= n; i++) {
             dp[i][0] = i;
         }
-        for (int j = 0; j <= n2; j++) {
+        for (int j = 0; j <= m; j++) {
             dp[0][j] = j;
         }
-        for (int i = 1; i <= n1; i++) {
-            for (int j = 1; j <= n2; j++) {
-                if (word1.charAt(i-1) == word2.charAt(j-1)) {
-                    // 跳过操作，什么也不做
+        dp[0][0] = 0;
+        // dp 推导
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                // 1. 相等，什么都不用做
+                if (s.charAt(i-1) == t.charAt(j-1)) {
                     dp[i][j] = dp[i-1][j-1];
                 }
                 else {
-                    dp[i][j] = Math.min(dp[i-1][j] + 1, dp[i][j-1] + 1); // 插入或者删除操作
-                    dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1] + 1);  // 替换操作
+                    // 2. s 插入字符
+                    dp[i][j] = dp[i][j-1] + 1;
+                    
+                    // 3. 删除 s 字符
+                    dp[i][j] = Math.min(dp[i][j], dp[i-1][j] + 1);
+                    
+                    // 4. 替换字符
+                    dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1] + 1);
                 }
             }
         }
-        return dp[n1][n2];
+        return dp[n][m];
         
     }
 }
