[Function add]

1. Add leetcode questions with tag dp.

Author: Seanforfun

README.md

@@ -567,6 +567,19 @@
 * [282. Expression Add Operators](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/282.%20Expression%20Add%20Operators.md)
 * [842. Split Array into Fibonacci Sequence](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/842.%20Split%20Array%20into%20Fibonacci%20Sequence.md)
 
+#### Dynamic Programming
+* [70. Climbing Stairs](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/70.%20Climbing%20Stairs.md)
+* [746. Min Cost Climbing Stairs](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/746.%20Min%20Cost%20Climbing%20Stairs.md)
+* [303. Range Sum Query - Immutable](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/303.%20Range%20Sum%20Query%20-%20Immutable.md)
+* [53. Maximum Subarray](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/53.%20Maximum%20Subarray.md)
+* [121. Best Time to Buy and Sell Stock](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/121.%20Best%20Time%20to%20Buy%20and%20Sell%20Stock.md)
+* [198. House Robber](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/198.%20House%20Robber.md)
+* [213. House Robber II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/213.%20House%20Robber%20II.md)
+* [309. Best Time to Buy and Sell Stock with Cooldown](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/309.%20Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.md)
+* [740. Delete and Earn](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/740.%20Delete%20and%20Earn.md)
+* [790. Domino and Tromino Tiling](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/790.%20Domino%20and%20Tromino%20Tiling.md)
+* [801. Minimum Swaps To Make Sequences Increasing](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/801.%20Minimum%20Swaps%20To%20Make%20Sequences%20Increasing.md)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/139. Word Break.md

@@ -72,4 +72,35 @@ class Solution {
         return dp[len];
     }
 }
-```
+```
+
+
+### Third time
+* Method 1: dp 
+	* Initialization: dp[0] = true;
+	* State transfer function: dp[i] |= dp[i - wordLen];
+	```Java
+	class Solution {
+		public boolean wordBreak(String s, List<String> wordDict) {
+			Set<String> set = new HashSet<>(wordDict);
+			Set<Integer> lenSet = new HashSet<>();
+			int min = Integer.MAX_VALUE;
+			for(String ss: wordDict){
+				int temp = ss.length();
+				lenSet.add(temp);
+				min = Math.min(min, temp);
+			}
+			int len = s.length();
+			boolean[] dp = new boolean[len + 1];
+			dp[0] = true;
+			for(int i = min; i <= len; i ++){
+				for(int wordLen : lenSet){
+					if(i - wordLen >= 0){
+						if(set.contains(s.substring(i - wordLen, i)))   dp[i] |= dp[i - wordLen];
+					}
+				}
+			}
+			return dp[len];
+		}
+	}
+	```

leetcode/140. Word Break II.md

@@ -190,3 +190,30 @@ class Solution {
 ```
 
 
+### Third time
+* Method 1: reucrsion && dp
+	```Java
+	class Solution {
+		Map<String, List<String>> map = new HashMap<>();
+		public List<String> wordBreak(String s, List<String> wordDict) {
+			if(map.containsKey(s)) return map.get(s);
+			if(s.length() == 0){
+				List<String> temp = new ArrayList<>();
+				temp.add("");
+				map.put("", temp);
+			}else{
+				List<String> result = new ArrayList<>();
+				for(String word: wordDict){
+					if(s.startsWith(word)){
+						List<String> res = wordBreak(s.substring(word.length()), wordDict);
+						for(String ss : res){
+							result.add(word + (ss.length() == 0 ? ss: " " + ss));
+						}
+					}
+				}
+				map.put(s, result);
+			}
+			return map.get(s);
+		}
+	}
+	```

leetcode/801. Minimum Swaps To Make Sequences Increasing.md

@@ -0,0 +1,76 @@
+## 801. Minimum Swaps To Make Sequences Increasing
+
+### Question
+We have two integer sequences A and B of the same non-zero length.
+
+We are allowed to swap elements A[i] and B[i].  Note that both elements are in the same index position in their respective sequences.
+
+At the end of some number of swaps, A and B are both strictly increasing.  (A sequence is strictly increasing if and only if A[0] < A[1] < A[2] < ... < A[A.length - 1].)
+
+Given A and B, return the minimum number of swaps to make both sequences strictly increasing.  It is guaranteed that the given input always makes it possible.
+
+```
+Example:
+Input: A = [1,3,5,4], B = [1,2,3,7]
+Output: 1
+Explanation: 
+Swap A[3] and B[3].  Then the sequences are:
+A = [1, 3, 5, 7] and B = [1, 2, 3, 4]
+which are both strictly increasing.
+```
+
+Note:
+* A, B are arrays with the same length, and that length will be in the range [1, 1000].
+* A[i], B[i] are integer values in the range [0, 2000].
+
+### Solution
+* Method 1: dp
+    * we need to maintain 2 states: keep[i] and swap[i]. i means up to index i, two arrays are strictly increasing.
+        * keep[i] means index i is not swapped.
+        * swap[i] means index i is swapped.
+    * Emample:
+        * A: [x, x, x, 1 , 4]
+        * B: [x, x, x, 2 , 3]
+    * Two conditions:
+        1. A[i - 1] < A[i] && B[i - 1] < B[i] Up to current index, two arrays have already met the requirement.
+            * keep[i] = keep[i - 1]  Nothing changed
+            * swap[i] = swap[i - 1] + 1 both changed
+                * A: [x, x, x, 2, 3]
+                * B: [x, x, x, 1, 4]
+        2. A[i - 1] < B[i] && B[i - 1] < A[i]
+            * keep[i] = min(keep[i], swap[i - 1])   current i is not swapped, previous one swapped
+                * A: [x, x, x, 2, 4]
+                * B: [x, x, x, 1, 3]
+            * swap[i] = min(swap[i], keep[i - 1] + 1)   current is swapped, swap previous pair
+                * A: [x, x, x, 2, 4]
+                * B: [x, x, x, 1, 3]
+    * Initialization
+        * keep[0] = 0
+        * swap[0] = 1
+    ```Java
+    class Solution {
+        public int minSwap(int[] A, int[] B) {
+            int len = A.length;
+            if(len <= 1) return 0;
+            int[] keep = new int[len];
+            int[] swap = new int[len];
+            Arrays.fill(keep, Integer.MAX_VALUE);
+            Arrays.fill(swap, Integer.MAX_VALUE);
+            keep[0] = 0; swap[0] = 0;
+            for(int i = 1; i < len; i++){
+                if(A[i - 1] < A[i] && B[i - 1] < B[i]){
+                    keep[i] = keep[i - 1];
+                    swap[i] = swap[i - 1] + 1;
+                }
+                if(A[i] > B[i - 1] && B[i] > A[i - 1]){
+                    keep[i] = Math.min(keep[i], swap[i - 1]);
+                    swap[i] = Math.min(swap[i], keep[i - 1] + 1);
+                }
+            }
+            return Math.min(keep[len - 1], swap[len - 1]);
+        }
+    }
+    ```
+
+### Reference
+1. [花花酱 LeetCode 801. Minimum Swaps To Make Sequences Increasing - 刷题找工作 EP183](https://www.youtube.com/watch?v=__yxFFRQAl8)