[Function add]:1. Add leetcode questions with tag dp.

Author: Botao Xiao

leetcode/121. Best Time to Buy and Sell Stock.md

@@ -115,4 +115,27 @@ class Solution {
         return profit;
     }
 }
-```
+```
+
+### Fourth time
+* Method 1: dp
+  * change original price to diff: [7,1,5,3,6,4] => [-6, 4, -2, 3, -2]
+  * change this question to maximum subarray.
+  ```Java
+  class Solution {
+      public int maxProfit(int[] prices) {
+          if(prices.length <= 1) return 0;
+          int[] diff = new int[prices.length - 1];
+          for(int i = 1; i < prices.length; i++)
+              diff[i - 1] = prices[i] - prices[i - 1];
+          int max = diff[0];
+          int[] dp = new int[diff.length];
+          dp[0] = diff[0];
+          for(int i = 1; i < diff.length; i++){
+              dp[i] = dp[i - 1] > 0 ? dp[i - 1] + diff[i]: diff[i];
+              max = Math.max(max, dp[i]);
+          }
+          return Math.max(max, 0);
+      }
+  }
+  ```

leetcode/126. Word Ladder II.md

@@ -57,3 +57,20 @@ class Solution {
     }
 }
 ```
+
+### Third time
+* Method 1: dp: dp[i] max money can steal up to now.
+  * Initialization dp[0] = 0
+  * dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
+  ```Java
+  class Solution {
+      public int rob(int[] nums) {
+          int len = nums.length;
+          int[] dp = new int[len + 1];
+          for(int i = 1; i <= len; i++){
+              dp[i] = Math.max(dp[i - 1], (i > 1 ? dp[i - 2]: 0) + nums[i - 1]);
+          }
+          return dp[len];
+      }
+  }
+  ```

leetcode/198. House Robber.md

@@ -73,4 +73,30 @@ class Solution {
         return Math.max(dp[len - 1], dp1[len]);
     }
 }
-```
+```
+
+### Third time
+* Method 1: dp
+  ```Java
+  class Solution {
+      public int rob(int[] nums) {
+          int len = nums.length;
+          if(len == 0)  return 0;
+          else if(len == 1) return nums[0];
+          else if(len == 2) return Math.max(nums[0], nums[1]);
+          int[] dp = new int[len + 1];
+          //steal the first house but not steal the last one
+          dp[1] = nums[0];
+          dp[2] = nums[0];
+          for(int i = 3; i < len; i++){
+              dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]);
+          }
+          int temp = dp[len - 1];
+          dp[0] = dp[1] = 0;
+          for(int i = 2; i <= len; i++){
+              dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]);
+          }
+          return Math.max(dp[len], temp);
+      }
+  }
+  ```

leetcode/213. House Robber II.md

@@ -62,5 +62,56 @@ class Solution {
 }
 ```
 
+### Third time
+* Method 1: dp
+	* we have three states sold, hold and rest
+	* Example: [1, 2, 3, 0, 2]
+	* 0		price					hold 				sold 					rest
+	* 1			1				 -1				-inf + 1				0
+	* 2			2				 -1				1					0
+	* 3			3				 -1				2					1
+	* 4			0				  1				-1					2
+	* 5			2				　1				3					2
+	* Version 1:
+		```Java
+		class Solution {
+		    public int maxProfit(int[] prices) {
+		        int len = prices.length;
+		        if(len <= 1) return 0;
+		        int[] hold = new int[len + 1];
+		        int[] sold = new int[len + 1];
+		        int[] rest = new int[len + 1];
+		        hold[1] = -prices[0];
+		        for(int i = 2; i <= len; i++){
+		            hold[i] = Math.max(hold[i - 1], rest[i - 1] - prices[i - 1]);
+		            sold[i] = hold[i - 1] + prices[i - 1];
+		            rest[i] = Math.max(rest[i - 1], sold[i - 1]);
+		        }
+		        return Math.max(rest[len], sold[len]);
+		    }
+		}
+		```
+
+	* Version 2: state compress
+		```Java
+		class Solution {
+		    public int maxProfit(int[] prices) {
+		        int len = prices.length;
+		        if(len <= 1) return 0;
+		        int hold = 0, sold = 0, rest = 0;
+		        int preHold = -prices[0];
+		        for(int i = 2; i <= len; i++){
+		            hold = Math.max(preHold, rest - prices[i - 1]);            
+		            rest = Math.max(rest, sold);
+		            sold = preHold + prices[i - 1];
+		            preHold = hold;
+		        }
+		        return Math.max(rest, sold);
+		    }
+		}
+		```
+
+
 ### Reference
-1. [【LeetCode】309. Best Time to Buy and Sell Stock with Cooldown](https://www.cnblogs.com/jdneo/p/5228004.html)
+1. [【LeetCode】309. Best Time to Buy and Sell Stock with Cooldown](https://www.cnblogs.com/jdneo/p/5228004.html)
+2. [花花酱 LeetCode 309. Best Time to Buy and Sell Stock with Cooldown - 刷题找工作 EP150](https://www.youtube.com/watch?v=oL6mRyTn56M)

leetcode/309. Best Time to Buy and Sell Stock with Cooldown.md

@@ -13,7 +13,7 @@ Note:
 Example:
 
 Input: [3,1,5,8]
-Output: 167 
+Output: 167
 Explanation: nums = [3,1,5,8] --> [3,5,8] -->   [3,8]   -->  [8]  --> []
              coins =  3*1*5      +  3*5*8    +  1*3*8      + 1*8*1   = 167
 ```
@@ -64,7 +64,7 @@ class Solution {
         * dp[i][mid - 1]: the sub result of left side of last burst ballon(mid)
         * arr[i - 1] * arr[mid] * arr[j + 1]: last one * remained left * remained right.
         * dp[mid + 1][j]: the sub result of right side of last burst ballon(mid)
-    3. How to traversal the array:
+    4. How to traversal the array:
         * dist: the distance from left index.
         * left: the left position.[1, len - dist + 1]
         * right: [left, left + dist - 1]

leetcode/312. Burst Balloons.md

@@ -0,0 +1,66 @@
+## 494. Target Sum
+
+### Question
+You are given a list of non-negative integers, a1, a2, ..., an, and a target, S. Now you have 2 symbols + and -. For each integer, you should choose one from + and - as its new symbol.
+
+Find out how many ways to assign symbols to make sum of integers equal to target S.
+
+```
+Example 1:
+
+Input: nums is [1, 1, 1, 1, 1], S is 3.
+Output: 5
+Explanation:
+
+-1+1+1+1+1 = 3
++1-1+1+1+1 = 3
++1+1-1+1+1 = 3
++1+1+1-1+1 = 3
++1+1+1+1-1 = 3
+
+There are 5 ways to assign symbols to make the sum of nums be target 3.
+```
+
+Note:
+* The length of the given array is positive and will not exceed 20.
+* The sum of elements in the given array will not exceed 1000.
+* Your output answer is guaranteed to be fitted in a 32-bit integer.
+
+### Solution
+* Method 1: dfs
+  ```Java
+  class Solution {
+      public int findTargetSumWays(int[] nums, int S) {
+          if(nums == null || nums.length == 0) return 0;
+          return dfs(nums, S, 0, 0, 0);
+      }
+      private int dfs(int[] nums, int S, int index, int cur, int start){
+          if(index == nums.length){
+              return cur == S ? 1 : 0;
+          }else{
+              return dfs(nums, S, start + 1, cur + nums[start], start + 1)
+                      + dfs(nums, S, start + 1, cur - nums[start], start + 1);
+          }
+      }
+  }
+  ```
+
+* Method 2: dp
+  ```Java
+  class Solution {
+      public int findTargetSumWays(int[] nums, int S) {
+          int sum = 0;
+          for(int num : nums) sum += num;
+          if(sum < S) return 0;
+          int offset = sum;
+          int[][] dp = new int[1 + nums.length][sum + offset + 1];
+          dp[0][offset] = 1;
+          for(int i = 1; i <= nums.length; i++){
+              for(int j = 0; j < sum * 2 + 1; j++){
+                  dp[i][j] += (j - nums[i - 1] >= 0 ? dp[i - 1][j - nums[i - 1]]: 0) + (j + nums[i - 1] < 2 * sum + 1 ? dp[i - 1][j + nums[i - 1]]: 0);
+              }
+          }
+          return dp[nums.length][S + offset];
+      }
+  }
+  ```

leetcode/494. Target Sum.md

@@ -73,3 +73,37 @@ class Solution {
     }
 }
 ```
+
+### Third TIme
+* Method 1:
+  ```Java
+  class Solution {
+      public int maxSubArray(int[] nums) {
+          int sum = nums[0], max = nums[0];
+          for(int i = 1; i < nums.length; ++i){
+              sum = Math.max(nums[i], sum + nums[i]);
+              max = Math.max(sum, max);
+          }
+          return max;
+      }
+  }
+  ```
+
+* Method 2: dp
+  * dp[i] the max value if using including current number.
+  * dp[i] = dp[i - 1] > 0 ? dp[i - 1] + nums[i]: nums[i]
+  * Need to use a variable to hold the global max value;
+  ```Java
+  class Solution {
+      public int maxSubArray(int[] nums) {
+          int[] dp = new int[nums.length];
+          dp[0] = nums[0];
+          int max = nums[0];
+          for(int i = 1; i < nums.length; i++){
+              dp[i] = dp[i - 1] > 0 ? nums[i] + dp[i - 1] : nums[i];
+              max = Math.max(max, dp[i]);
+          }
+          return max;
+      }
+  }
+  ```

leetcode/53. Maximum Subarray.md

@@ -0,0 +1,58 @@
+## 740. Delete and Earn
+
+### Question
+Given an array nums of integers, you can perform operations on the array.
+
+In each operation, you pick any nums[i] and delete it to earn nums[i] points. After, you must delete every element equal to nums[i] - 1 or nums[i] + 1.
+
+You start with 0 points. Return the maximum number of points you can earn by applying such operations.
+
+```
+Example 1:
+
+Input: nums = [3, 4, 2]
+Output: 6
+Explanation:
+Delete 4 to earn 4 points, consequently 3 is also deleted.
+Then, delete 2 to earn 2 points. 6 total points are earned.
+
+
+
+Example 2:
+
+Input: nums = [2, 2, 3, 3, 3, 4]
+Output: 9
+Explanation:
+Delete 3 to earn 3 points, deleting both 2's and the 4.
+Then, delete 3 again to earn 3 points, and 3 again to earn 3 points.
+9 total points are earned.
+```
+
+Note:
+* The length of nums is at most 20000.
+* Each element nums[i] is an integer in the range [1, 10000].
+
+### Solution
+* Method 1: dp
+  * This question is related to [198. House Robber](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/198.%20House%20Robber.md)
+  * When we take a value, we will take all of this value.
+  ```Java
+  class Solution {
+      public int deleteAndEarn(int[] nums) {
+          int len = nums.length;
+          if(len == 0) return 0;
+          int max = 0;
+          for(int num : nums){            
+              max = Math.max(max, num);
+          }
+          int[] val = new int[max + 1];
+          for(int num : nums)
+              val[num]++;
+          int[] dp = new int[max + 1];
+          for(int i = 1; i < dp.length; i++){
+              dp[i] = Math.max(dp[i - 1], (i > 1 ? dp[i - 2]: 0) + i * val[i]);
+          }
+          return dp[max];
+      }
+  }
+  ```

leetcode/542. 01 Matrix.md

@@ -0,0 +1,74 @@
+## 790. Domino and Tromino Tiling
+
+### Question
+We have two types of tiles: a 2x1 domino shape, and an "L" tromino shape. These shapes may be rotated.
+
+XX  <- domino
+
+XX  <- "L" tromino
+X
+Given N, how many ways are there to tile a 2 x N board? Return your answer modulo 10^9 + 7.
+
+(In a tiling, every square must be covered by a tile. Two tilings are different if and only if there are two 4-directionally adjacent cells on the board such that exactly one of the tilings has both squares occupied by a tile.)
+
+```
+Example:
+Input: 3
+Output: 5
+Explanation:
+The five different ways are listed below, different letters indicates different tiles:
+XYZ XXZ XYY XXY XYY
+XYZ YYZ XZZ XYY XXY
+```
+
+Note:
+* N  will be in range [1, 1000].
+
+### Solution:
+* Method 1: dp
+  * Let's go to a simpler question, how many ways to implement 2 * N blocks only using domino?
+    * 2 * 1
+      ```
+      1
+      1
+      ```
+    * 2 * 2
+      ```
+      11        12
+      22        12
+      ```
+    * 2 * i: dp[i] = dp[i - 1] + dp[i - 2]
+      ```
+      dp[i-1]1    +     dp[i-2]１１
+      dp[i-1]1    +     dp[i-2]２２
+      ```
+  * Come back to this question, we use dp[i][0-2]
+    * dp[i][0]: Fill up to col i and both rows fills.
+    * dp[i][1]: Fill up to col i and upper row fills.
+    * dp[i][2]: Fill up to col i and bottom row fills.
+    * State transfer function
+      * dp[i][0] = dp[i - 1][0] + dp[i - 2][0] + dp[i - 1][1] + dp[i - 2][2]
+      * dp[i][1] = dp[i - 2][0] + dp[i - 1][2]
+      * dp[i][2] = dp[i - 2][0] + dp[i - 1][1]
+    ```Java
+    class Solution {
+        public int numTilings(int N) {
+            if(N == 1) return 1;
+            if(N == 2) return 2;
+            long[][] dp = new long[N + 1][3];
+            dp[1][0] = 1; dp[2][0] = 2;
+            dp[2][1] = 1;
+            dp[2][2] = 1;
+            int kmod = (int)1e9 + 7;
+            for(int i = 3; i <= N; i++){
+                dp[i][0] = (dp[i - 1][0] + dp[i - 2][0] + dp[i - 1][1] + dp[i - 1][2]) % kmod;
+                dp[i][1] = (dp[i - 2][0] + dp[i - 1][2]) % kmod;
+                dp[i][2] = (dp[i - 2][0] + dp[i - 1][1]) % kmod;
+            }
+            return (int)dp[N][0];
+        }
+    }
+    ```
+
+### Reference:
+1. [花花酱 LeetCode 790. Domino and Tromino Tiling - 刷题找工作 EP171](https://www.youtube.com/watch?v=S-fUTfqrdq8)