DP

Author: rchen102

Java/leetcode 1143.java

@@ -0,0 +1,29 @@
+// Solution: 基本 dp T: O(nm) S: O(nm)
+class Solution {
+    public int longestCommonSubsequence(String text1, String text2) {
+        if (text1 == null || text2 == null) return 0;
+        int len1 = text1.length();
+        int len2 = text2.length();
+        if (len1 == 0 || len2 == 0) return 0;
+        
+        int[][] dp = new int[len1+1][len2+1];
+        for (int i = 0; i <= len1; i++) {
+            dp[i][0] = 0;
+        }
+        for (int j = 0; j <= len2; j++) {
+            dp[0][j] = 0;
+        }
+        // 状态转移
+        for (int i = 1; i <= len1; i++) {
+            for (int j = 1; j <= len2; j++) {
+                if (text1.charAt(i-1) == text2.charAt(j-1)) {
+                    dp[i][j] = dp[i-1][j-1] + 1;
+                }
+                else {
+                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
+                }
+            }
+        }
+        return dp[len1][len2];
+    }
+}

Java/leetcode 169.java

@@ -1,4 +1,42 @@
-//Solution1: HashMap  Time: O(n) Space:0(n)
+//Solution: Boyer-Moore Majority Vote Algorithm Time:O(n) Space:O(1)
+class Solution {
+    public int majorityElement(int[] nums) {
+        if (nums == null || nums.length == 0) return 0;
+        int major = nums[0];
+        int times = 1;
+        for (int i = 1; i < nums.length; i++) {
+            int cur = nums[i];
+            if (cur == major) times++;
+            else {
+                times--;
+                if (times == 0) {
+                    times = 1;
+                    major = cur;
+                }
+            }
+        }
+        return major;
+    }
+}
+
+//Solution: Bit-Manipulation Time: O(n) Space: O(1)
+class Solution {
+    public int majorityElement(int[] nums) {
+        int res = 0, major = nums.length / 2;
+        for(int i = 31; i >= 0; i--) {
+            int pos = 0;
+            for(int num : nums) {
+                pos += (num >> i) & 1;
+            }
+            pos = pos > major ? 1 : 0;
+            res |= (pos << i);
+        }
+        return res;
+    }
+}
+
+
+//Solution: HashMap  Time: O(n) Space:0(n)
 class Solution {
     public int majorityElement(int[] nums) {
         Map<Integer, Integer> map = new HashMap<>();
@@ -16,7 +54,7 @@ public int majorityElement(int[] nums) {
     }
 }
 
-//Solution2: Divide and Conquer Time: O(nlogn) Space: O(logn)
+//Solution: Divide and Conquer Time: O(nlogn) Space: O(logn)
 class Solution {
     public int majorityElement(int[] nums) {
         return findMajorityHelper(nums, 0, nums.length - 1);
@@ -38,36 +76,4 @@ private int findMajorityHelper(int[] nums, int start, int end) {
     }
 }
 
-//Solution3: Boyer-Moore Majority Vote Algorithm Time:O(n) Space:O(1)
-class Solution {
-    public int majorityElement(int[] nums) {
-        int res = nums[0], count = 1;
-        for(int i = 1; i < nums.length; i++) {
-            if(count == 0) {
-                res = nums[i];
-                count++;
-            }
-            else if(res == nums[i])
-                count++;
-            else
-                count--;
-        }
-        return res;
-    }
-}
 
-//Solution4: Bit-Manipulation Time: O(n) Space: O(1)
-class Solution {
-    public int majorityElement(int[] nums) {
-        int res = 0, major = nums.length / 2;
-        for(int i = 31; i >= 0; i--) {
-            int pos = 0;
-            for(int num : nums) {
-                pos += (num >> i) & 1;
-            }
-            pos = pos > major ? 1 : 0;
-            res |= (pos << i);
-        }
-        return res;
-    }
-}

Java/leetcode 300.java

@@ -1,25 +1,4 @@
-// Solution1: binary search and dp T: O(nlogn) S: O(n)
-class Solution {
-    public int lengthOfLIS(int[] nums) {
-        int[] tails = new int[nums.length];
-        int size = 0;
-        for(int num : nums) {
-            int low = 0, high = size;
-            while(low != high) {
-                int mid = (low + high) / 2;
-                if(tails[mid] < num)
-                    low = mid + 1;
-                else
-                    high = mid;
-            }
-            tails[low] = num;
-            if(low == size) ++size;
-        }
-        return size;
-    }
-}
-
-//Solution more easy understand: T: O(n^2) S: O(n)
+// Solution1: Basic dp T: O(n^2) S: O(n)
 class Solution {
     public int lengthOfLIS(int[] nums) {
         if(nums == null || nums.length == 0) return 0;
@@ -36,4 +15,33 @@ public int lengthOfLIS(int[] nums) {
         }
         return res;
     }
+}
+
+// Solution2: 某扑克牌算法  T: O(nlogn) S: O(n)
+class Solution {
+    public int lengthOfLIS(int[] nums) {
+        if (nums == null || nums.length == 0) return 0;
+        int[] tops = new int[nums.length];
+        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;
+        }
+        return piles;
+    }
+    
+    public int binarySearchLeftBound(int[] nums, int len, int target) {
+        int lo = 0, hi = len - 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; 
+        }
+        return lo;
+    }
 }

Java/leetcode 416.java

@@ -0,0 +1,60 @@
+// Solution: 基本 dp  T: O(nk) S: O(nk) k = sum(nums)  
+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;
+        
+        // 初始化 Base case
+        boolean[][] dp = new boolean[len+1][sum+1];
+        for (int i = 0; i <= len; 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++) {
+            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]];
+                }
+            }
+        }
+        return dp[len][sum];
+    }
+}
+
+// 优化：状态压缩
+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;
+        
+        // 初始化 Base case
+        boolean[] dp = new boolean[sum+1];
+        dp[0] = true;
+      
+        // 状态转移
+        for (int i = 1; i <= len; i++) {
+            for (int j = sum; j >= 1; j--) {
+                if (j >= nums[i-1]) {
+                    dp[j] = dp[j] || dp[j-nums[i-1]];
+                }
+            }
+        }
+        return dp[sum];
+    }
+}

Java/leetcode 5.java

@@ -1,45 +1,61 @@
-// Solution1: T: O(n^2) S: O(1)
+// Solution1: 衍生法，少有的，暴力比 dp 更好 T: O(n^2) S: O(1)
 class Solution {
     public String longestPalindrome(String s) {
-        int len = s.length();
-        int max = 0;
-        int idx = 0;
-        for (int i = 0; i < len; i++) {
-            int len1 = extend(s, i, i); // assume odd length, try to extend palindrome as possible
-            int len2 = extend(s,i, i+1); // assume enven length
-            if (Math.max(len1, len2) > max) {
-                // Update 
-                max = Math.max(len1, len2);
-                idx = len1 > len2 ? (i - len1/2) : (i - len2/2 + 1);
-            }
+        if (s == null || s.length() == 0) return s;
+        int n = s.length();
+        String res = "";
+        for (int i = 0; i < n; i++) {
+            String r1 = findPalindrome(s, i, i);
+            String r2 = findPalindrome(s, i, i+1);
+            if (r1.length() > res.length()) res = r1;
+            if (r2.length() > res.length()) res = r2;
         }
-        return s.substring(idx, idx + max);
+        return res;
+       
     }
 
-    private int extend(String s, int i, int j) {
-        int len = s.length();
-        for (; i >= 0 && j < len; i--, j++) {
-            if (s.charAt(i) != s.charAt(j)) break;
+    public String findPalindrome(String str, int l, int r) {
+        while (l >= 0 && r < str.length()) {
+            if (str.charAt(l) == str.charAt(r)) {
+                l--;
+                r++;
+            }
+            else {
+                break;
+            }
         }
-        return j - i + 1 -2; // Current 2 unmatched chars
+        return str.substring(l+1, r);
     }
 }
 
-// Solution2: Dynamic Programming T: O(n^2) S: O(n^2)
+// Solution: dp T: O(n^2) S: O(n^2)
 class Solution {
     public String longestPalindrome(String s) {
-        int len = s.length();
-        boolean[][] dp = new boolean[len][len];
+        if (s == null || s.length() == 0) return s;
+        int n = s.length();
+        boolean[][] dp = new boolean[n][n];
+        // base case
+        for (int i = 0; i < n; i++) {
+            dp[i][i] = true;
+        }
+        // 推导
         String res = "";
-        for (int i = len - 1; i >= 0; i--) {
-            for(int j = i; j < len; j++) {
-                if (j - i <= 2) dp[i][j] = (s.charAt(i) == s.charAt(j));
-                else dp[i][j] = (s.charAt(i) == s.charAt(j)) && dp[i+1][j-1];
-                if (dp[i][j] && res.length() < j - i + 1) {
-                    res = s.substring(i, j + 1);
+        int maxLen = 0;
+        for (int i = n-1; i >= 0; i--) {
+            for (int j = i+1; j < n; j++) {
+                if (j - i == 1) {
+                    dp[i][j] = (s.charAt(i) == s.charAt(j));
+                }
+                else {
+                    dp[i][j] = (dp[i+1][j-1] && (s.charAt(i) == s.charAt(j)));
+                }
+                if (dp[i][j] && j - i + 1 > maxLen) {
+                    maxLen = j - i + 1;
+                    res = s.substring(i, j+1);
                 }
             }
         }
-        return res;
+        if (maxLen != 0) return res;
+        return String.valueOf(s.charAt(0));
     }
 }

Java/leetcode 516.java

@@ -0,0 +1,25 @@
+// Solution: 基本 dp T: O(n^2) S: O(n^2)
+class Solution {
+    public int longestPalindromeSubseq(String s) {
+        if (s == null || s.length() == 0) return 0;
+        int n = s.length();
+        
+        int[][] dp = new int[n][n];
+        // base case
+        for (int i = 0; i < n; i++) {
+            dp[i][i] = 1;
+        }
+        // 推导
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = i+1; j < n; j++) {
+                if (s.charAt(i) == s.charAt(j)) {
+                    dp[i][j] = dp[i+1][j-1] + 2;
+                }
+                else {
+                    dp[i][j] = Math.max(dp[i+1][j], dp[i][j-1]);
+                }
+            }
+        }
+        return dp[0][n-1];
+    }
+}