update 42, 43, 44, 45

Author: selfboot

DynamicProgramming/44_WildcardMatching.cpp

@@ -0,0 +1,75 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-07-26 11:48:04
+ */
+
+class Solution {
+public:
+    /*
+    Dynamic Programming
+
+    dp[i][j] represents isMatch(p[0...i-1], s[0...j-1]), default is False;
+    dp[i][0]: isMatch(p[0...i], ""), dp[0][j]: isMatch("", s[0...j])
+    dp[0][0] represents
+
+    If p[i] is "*", dp[i+1][j+1] =
+        1. dp[i][j+1]        # * matches 0 element in s;
+        2. dp[i][j]          # * matches 1 element in s;
+        3. dp[i+1][j]        # * matches more than one in s.
+    */
+    bool isMatch(string s, string p) {
+        int s_size = s.size();
+        int p_size = p.size();
+        if(s_size == 0){
+            if(p.find_first_not_of('*') == string::npos){
+                return true;
+            }
+            return false;
+        }
+
+        int not_star_cnt = 0;
+        for(int i=0; i<p_size; i++){
+            if(p[i] != '*'){
+                not_star_cnt += 1;
+            }
+        }
+        if(not_star_cnt > s_size){
+            return false;
+        }
+
+        vector<vector<bool>> dp(p_size+1, vector<bool>(s_size+1, false));
+        dp[0][0] = true;
+        for(int i=0; i<p_size; i++){
+            dp[i+1][0] = dp[i][0] && p[i] == '*';
+        }
+
+        for(int i=0; i<p_size; i++){
+            for(int j=0; j<s_size; j++){
+                if(p[i] == '*'){
+                    dp[i+1][j+1] = dp[i][j] || dp[i][j+1] || dp[i+1][j];
+                }
+                else{
+                    dp[i+1][j+1] = dp[i][j] && (p[i] == s[j] || p[i] == '?');
+                }
+            }
+        }
+        return dp[p_size][s_size];
+    }
+};
+
+/*
+"aa"
+"a"
+"aa"
+"aa"
+"aaa"
+"aa"
+"aa"
+"*"
+"aa"
+"a*"
+"ab"
+"?*"
+"aab"
+"c*a*b"
+*/

DynamicProgramming/44_WildcardMatching.py

@@ -0,0 +1,57 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def isMatch(self, s, p):
+        """ Dynamic Programming
+
+        dp[i][j] represents isMatch(p[0...i-1], s[0...j-1]), default is False;
+        dp[i][0]: isMatch(p[0...i], ""), dp[0][j]: isMatch("", s[0...j])
+        dp[0][0] represents
+
+        If p[i] is "*", dp[i+1][j+1] =
+            1. dp[i][j+1]        # * matches 0 element in s;
+            2. dp[i][j]          # * matches 1 element in s;
+            3. dp[i+1][j]        # * matches more than one in s.
+        """
+        if not s:
+            if p.count('*') != len(p):
+                return False
+            return True
+
+        # Optimized for the big data.
+        if len(p) - p.count('*') > len(s):
+            return False
+
+        # Initinal process
+        dp = [[False for col in range(len(s) + 1)] for row in range(len(p) + 1)]
+        dp[0][0] = True     # isMatch("", "") = True
+        for i in range(len(p)):
+            dp[i + 1][0] = dp[i][0] and p[i] == '*'
+
+        for i in range(len(p)):
+            for j in range(len(s)):
+                if p[i] == "*":
+                    dp[i + 1][j + 1] = dp[i][j + 1] or dp[i][j] or dp[i + 1][j]
+                else:
+                    dp[i + 1][j + 1] = dp[i][j] and (p[i] == s[j] or p[i] == "?")
+
+        return dp[len(p)][len(s)]
+
+"""
+"aa"
+"a"
+"aa"
+"aa"
+"aaa"
+"aa"
+"aa"
+"*"
+"aa"
+"a*"
+"ab"
+"?*"
+"aab"
+"c*a*b"
+"""

DynamicProgramming/README.md

@@ -88,6 +88,8 @@
 
 # 例子：更好的理解
 
+## [44. Wildcard Matching](https://leetcode.com/problems/wildcard-matching/)
+
 ## [264 Ugly Number II](https://leetcode.com/problems/ugly-number-ii/)
 
 > 把只含有因子 2、3和5的数称作丑数（Ugly Number），求按照从小到大的顺序第 1500 个丑数。例如6、8都是丑数，但14不是。习惯上把1当作是第一个丑数。

Greedy/45_JumpGameII.cpp

@@ -0,0 +1,43 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-07-26 09:32:27
+ */
+
+class Solution {
+public:
+    /*
+    When you can reach position i, find the next longest distance you can reach.
+
+    Once we can reach position i, we can find the next longest distance by iterate all
+    the position before position i.
+
+    Of course, you can think it as a BFS problem.
+    Where nodes in level i are all the nodes that can be reached in i-1th jump.
+    For more explnation, goto:
+    https://discuss.leetcode.com/topic/3191/o-n-bfs-solution
+    */
+    int jump(vector<int>& nums) {
+        if(nums.size() == 1)    return 0;
+        int step = 1, longest = nums[0];
+        int index = 1;
+        while(longest < nums.size()-1){
+            int max_instance = 0;
+            while(index <= longest){
+                if(index + nums[index] > max_instance){
+                    max_instance = index + nums[index];
+                }
+                index += 1;
+            }
+            step += 1;
+            longest = max_instance;
+        }
+        return step;
+    }
+};
+
+/*
+[0]
+[2,5,0,3]
+[2,3,1,1,4]
+[3,1,8,1,1,1,1,1,5]
+*/

Week06/45.py renamed to Greedy/45_JumpGameII.py

@@ -4,11 +4,16 @@
 
 class Solution(object):
     def jump(self, nums):
-        """
-        :type nums: List[int]
-        :rtype: int
-        """
+        """ When you can reach position i, find the next longest distance you can reach.
+
+        Once we can reach position i, we can find the next longest distance by iterate all
+        the position before position i.
 
+        Of course, you can think it as a BFS problem.
+        Where nodes in level i are all the nodes that can be reached in i-1th jump.
+        For more explnation, goto:
+        https://discuss.leetcode.com/topic/3191/o-n-bfs-solution
+        """
         if len(nums) == 1:
             return 0
 
@@ -26,3 +31,10 @@ def jump(self, nums):
             step += 1
 
         return step
+
+"""
+[0]
+[2,5,0,3]
+[2,3,1,1,4]
+[3,1,8,1,1,1,1,1,5]
+"""

Math/43_MultiplyStrings.cpp

@@ -0,0 +1,47 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-07-25 20:13:40
+ */
+
+class Solution {
+public:
+    /*
+    Simulation the manual way we do multiplication.
+
+    Start from right to left, perform multiplication on every pair of digits.
+    And add them together.
+
+    There is a good graph explanation.  Refer to:
+    https://discuss.leetcode.com/topic/30508/easiest-java-solution-with-graph-explanation
+    */
+    string multiply(string num1, string num2) {
+        int m=num1.size(), n=num2.size();
+        vector<int> pos(m+n, 0);
+        for(int i=m-1; i>=0; i--){
+            for(int j=n-1; j>=0; j--){
+                int multi_sum = (num1[i] - '0') * (num2[j] - '0');
+                int pos_sum = pos[i+j+1] + multi_sum;
+
+                // Update pos[i+j] and pos[i+j+1]
+                pos[i+j] += pos_sum / 10;
+                pos[i+j+1] = pos_sum % 10;
+            }
+        }
+        string product = "";
+        int i=0;
+        for(; i<m+n && pos[i]==0; i++){};
+        for(; i<m+n; i++){
+            product += to_string(pos[i]);
+        }
+        return product == "" ? "0" : product;
+    }
+};
+
+/*
+"0"
+"1"
+"123"
+"123"
+"12121212121212125"
+"121232323499999252"
+*/

Math/43_MultiplyStrings.py

@@ -0,0 +1,39 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def multiply(self, num1, num2):
+        """ Simulation the manual way we do multiplication.
+
+        Start from right to left, perform multiplication on every pair of digits.
+        And add them together.
+
+        There is a good graph explanation.  Refer to:
+        https://discuss.leetcode.com/topic/30508/easiest-java-solution-with-graph-explanation
+        """
+        m, n = len(num1), len(num2)
+        pos = [0] * (m + n)
+        for i in range(m - 1, -1, -1):
+            for j in range(n - 1, -1, -1):
+                multi = int(num1[i]) * int(num2[j])
+                pos_sum = pos[i + j + 1] + multi
+
+                # Update pos[i+j], pos[i+j+1]
+                pos[i + j] += pos_sum / 10
+                pos[i + j + 1] = pos_sum % 10
+
+        first_not_0 = 0
+        while first_not_0 < m + n and pos[first_not_0] == 0:
+            first_not_0 += 1
+
+        return "".join(map(str, pos[first_not_0:] or [0]))
+
+"""
+"0"
+"1"
+"123"
+"123"
+"12121212121212125"
+"121232323499999252"
+"""

README.md

@@ -178,6 +178,7 @@
 
 * 010. [Regular Expression Matching](DynamicProgramming/10_RegularExpressionMatching.py)
 * 032. [Longest Valid Parentheses](DynamicProgramming/32_LongestValidParentheses.py)
+* 044. [Wildcard Matching](DynamicProgramming/44_WildcardMatching.py)
 * 053. [Maximum Subarray](DynamicProgramming/53_MaximumSubarray.py)
 * 062. [Unique Paths](DynamicProgramming/62_UniquePaths.py)
 * 063. [Unique Paths II](DynamicProgramming/63_UniquePathsII.py)
@@ -212,6 +213,7 @@
 
 # [Greedy](Greedy/)
 
+* 045. [Jump Game II](Greedy/45_JumpGameII.py)
 * 055. [Jump Game](Greedy/55_JumpGame.py)
 * 122. [Best Time to Buy and Sell Stock II](Greedy/122_BestTimeToBuyAndSellStockII.py)
 * 134. [Gas Station](Greedy/134_GasStation.py)
@@ -242,6 +244,7 @@
 * 016. [3Sum Closest](TwoPointers/16_3SumClosest.py)
 * 018. [4Sum](TwoPointers/18_4Sum.py)
 * 019. [Remove Nth Node From End of List](TwoPointers/19_RemoveNthNodeFromEndOfList.py)
+* 042. [Trapping Rain Water](TwoPointers/42_TrappingRainWater.py)
 * 075. [Sort Colors](TwoPointers/75_SortColors.py)
 * 080. [Remove Duplicates from Sorted Array II](TwoPointers/80_RemoveDuplicatesArrayII.py)
 * 088. [Merge Sorted Array](TwoPointers/88_MergeSortedArray.py)
@@ -261,6 +264,7 @@
 * 012. [Integer to Roman](Math/12_IntegertoRoman.py)
 * 013. [Roman to Integer](Math/13_RomantoInteger.py)
 * 048. [Rotate Image](Math/48_RotateImage.py)
+* 043. [Multiply Strings](Math/43_MultiplyStrings.py)
 * 050. [Pow(x, n)](Math/50_Pow.py)
 * 060. [Permutation Sequence](Math/60_PermutationSequence.py)
 * 066. [Plus One](Math/66_PlusOne.py)

TwoPointers/42_TrappingRainWater.cpp

@@ -0,0 +1,52 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-07-25 18:31:59
+ */
+
+class Solution {
+public:
+    /*
+    Search from left to right and maintain a max height of left and right separately,
+    which is like a one-side wall of partial container.
+    Fix the higher one and flow water from the lower part.
+    For example, if current height of left is lower,
+    we fill water in the left bin.
+    Until left meets right, we filled the whole container.
+
+    Brilliant solution proposed by @mcrystal
+    Refer to: https://discuss.leetcode.com/topic/5125/sharing-my-simple-c-code-o-n-time-o-1-space
+    */
+    int trap(vector<int>& height) {
+        int max_left=0, max_right = 0;
+        int left = 0, right = height.size()-1;
+        int ans = 0;
+        while(left <= right){
+            if(height[left] <= height[right]){
+                if(height[left] >= max_left){
+                    max_left = height[left];
+                }
+                else{
+                    ans += max_left - height[left];
+                }
+                left ++;
+            }
+            else{
+                if(height[right] >= max_right){
+                    max_right = height[right];
+                }
+                else{
+                    ans += max_right - height[right];
+                }
+                right --;
+            }
+        }
+        return ans;
+    }
+};
+
+/*
+[]
+[3,0,0,3]
+[1,1,1,2,2,1,1]
+[0,1,0,2,1,0,1,3,2,1,2,1]
+*/