update 235

Author: selfboot

BreadthFirstSearch/322_CoinChange.py

@@ -5,19 +5,20 @@
 # Refer to:
 # https://leetcode.com/discuss/79289/fast-python-branch-bound-solution-beaten-python-submissions
 
+
 class Solution(object):
     def coinChange(self, coins, amount):
         """
         Very classic dynamic programming problem, like 0-1 Knapsack problem.
         dp[i] is the fewest number of coins making up amount i,
         then for every coin in coins, dp[i] = min(dp[i - coin] + 1).
         """
-        dp = [amount + 1] * (amount+1)
+        dp = [amount + 1] * (amount + 1)
         dp[0] = 0
-        for i in xrange(amount+1):
+        for i in xrange(amount + 1):
             for coin in coins:
                 if coin <= i:
-                    dp[i] = min(dp[i], dp[i-coin]+1)
+                    dp[i] = min(dp[i], dp[i - coin] + 1)
         return -1 if dp[amount] > amount else dp[amount]
 
 
@@ -31,7 +32,7 @@ def coinChange(self, coins, amount):
         count = 0
 
         # upper bound on number of coins (+1 to represent the impossible case)
-        coins.sort(reverse = True)
+        coins.sort(reverse=True)
         upperBound = amount / coins[-1] + 1
 
         # Use upperBound to pruning.

DynamicProgramming/115_DistinctSubsequences.cpp

@@ -0,0 +1,51 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-10-09 12:06:21
+ */
+
+class Solution {
+public:
+    /*
+    dp[i][j] is the number of ways to remove some characters
+    from S[0,i] to get T[0,j], we have the recursive formula:
+    dp [i][j] = dp[i-1][j] if S[i] != T[j] ,
+    or dp [i][j] = dp[i-1][j] + dp[i-1][j-1] if S[i] ==T[j]
+    */
+    int numDistinct(string s, string t) {
+        if(s=="" || t==""){
+            return 0;
+        }
+
+        int s_len = s.size();
+        int t_len = t.size();
+        if(s_len == t_len && s != t || (s_len < t_len)){
+            return 0;
+        }
+
+        /*
+        dp[i][j] refer to only dp[i-1][j] and dp[i-1][j-1].
+        This gives us the idea that we can reduce the space to O(n).
+        Since we need to make use of dp[i-1][j-1], we run backward!!!
+        */
+        std::vector<int> dp(t_len+1, 0);
+        dp[0]=1;
+        for(int i=1; i<s_len+1; i++){
+            for(int j=t_len; j>0; j--){
+                if(s[i-1] == t[j-1]){
+                    dp[j] += dp[j-1];
+                }
+            }
+        }
+
+        return dp[t_len];
+    }
+};
+
+/*
+""
+"a"
+"ababcc"
+"abc"
+"rabbbit"
+"rabbit"
+*/

DynamicProgramming/115_DistinctSubsequences.py

@@ -10,27 +10,23 @@ def numDistinct(self, s, t):
         dp [i][j] = dp[i-1][j] if S[i] != T[j] ,
         or dp [i][j] = dp[i-1][j] + dp[i-1][j-1] if S[i] ==T[j]
         """
-        s_l = len(s)
-        t_l = len(t)
-        if s_l < t_l:
+        if not s or not t:
             return 0
-        if s_l == t_l and s != t:
-            return 0
-        if not s and t:
+
+        s_l, t_l = len(s), len(t)
+        if s_l < t_l or (s_l == t_l and s != t):
             return 0
-        if not t:
-            return 1
 
-        dp = [0 for i in range(t_l+1)]
+        dp = [0 for i in range(t_l + 1)]
         dp[0] = 1
 
-        for i in xrange(1, s_l+1):
+        for i in xrange(1, s_l + 1):
             # dp[i][j] refer to only dp[i-1][j] and dp[i-1][j-1].
             # This gives us the idea that we can reduce the space to O(n).
             # Since we need to make use of dp[i-1][j-1], we run backward!!!
             for j in xrange(t_l, 0, -1):
-                if s[i-1] == t[j-1]:
-                    dp[j] += dp[j-1]
+                if s[i - 1] == t[j - 1]:
+                    dp[j] += dp[j - 1]
         return dp[t_l]
 
         """Readable, but take O(m*n) space
@@ -47,9 +43,12 @@ def numDistinct(self, s, t):
         return dp[s_l][t_l]
         """
 
+
 """
 ""
 "a"
 "ababcc"
 "abc"
+"rabbbit"
+"rabbit"
 """

DynamicProgramming/README.md

@@ -84,8 +84,6 @@
 1. 需要设计数据结构来完成自底向上的计算过程。逻辑上相对不那么直观。 
 2. 常常可以进行空间复杂度的优化。
 
-
-
 # 例子：更好的理解
 
 ## [44. Wildcard Matching](https://leetcode.com/problems/wildcard-matching/)
@@ -102,6 +100,11 @@
 121, 122, 123, 188, 309	
 
 
+# 优化
+
+115.Distinct Subsequences  
+
+
 # 更多阅读
 [fibonacci数列为什么那么重要](https://www.zhihu.com/question/28062458)   
 [Dynamic Programming：From Novice to Advanced](https://www.topcoder.com/community/data-science/data-science-tutorials/dynamic-programming-from-novice-to-advanced/)  

Greedy/README.md

@@ -0,0 +1,34 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-09-20 19:37:23
+ */
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    // Easy to understand
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+        int min = p->val < q->val ? p->val : q->val;
+        int max = p->val < q->val ? q->val : p->val;
+        while(root){
+            if(root->val < min){
+                root = root->right;
+            }
+            else if(root->val > max){
+                root = root->left;
+            }
+            else{
+                return root;
+            }
+        }
+        return nullptr;
+    }
+};