[Function add]

1. Add leetcode solutions with tag dp.

Author: Seanforfun

README.md

@@ -593,6 +593,12 @@
 * [712. Minimum ASCII Delete Sum for Two Strings](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/712.%20Minimum%20ASCII%20Delete%20Sum%20for%20Two%20Strings.md)
 * [322. Coin Change](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/322.%20Coin%20Change.md)
 * [377. Combination Sum IV](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/377.%20Combination%20Sum%20IV.md)
+* [416. Partition Equal Subset Sum](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/416.%20Partition%20Equal%20Subset%20Sum.md)
+* [494. Target Sum](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/494.%20Target%20Sum.md)
+* [813. Largest Sum of Averages](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/813.%20Largest%20Sum%20of%20Averages.md)
+* [312. Burst Balloons](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/312.%20Burst%20Balloons.md)
+* [664. Strange Printer](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/664.%20Strange%20Printer.md)
+* [741. Cherry Pickup](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/741.%20Cherry%20Pickup.md)
 
 
 ## Algorithm(4th_Edition)

leetcode/120. Triangle.md

@@ -76,4 +76,28 @@ class Solution {
         return dp[0];
     }
 }
-```
+```
+
+### Third time
+* Method 1: dp + rotation array
+	```Java
+	class Solution {
+		public int minimumTotal(List<List<Integer>> triangle) {
+			int height = triangle.size(), width = triangle.get(height - 1).size();
+			int[] dp = new int[width];
+			int temp = 0, pre = 0;
+			for(int i = 0; i < width; i++){
+				dp[i] = triangle.get(height - 1).get(i);
+			}
+			for(int i = height - 2; i >= 0; i--){
+				temp = dp[i + 1];
+				for(int j = i; j >= 0; j--){
+					pre = dp[j];
+					dp[j] = triangle.get(i).get(j) + Math.min(dp[j], temp);
+					temp = pre;
+				}
+			}
+			return dp[0];
+		}
+	}
+	```

leetcode/546. Remove Boxes.md

@@ -0,0 +1,65 @@
+## 546. Remove Boxes
+
+### Question
+Given several boxes with different colors represented by different positive numbers.
+You may experience several rounds to remove boxes until there is no box left. Each time you can choose some continuous boxes with the same color (composed of k boxes, k >= 1), remove them and get k*k points.
+Find the maximum points you can get.
+
+```
+Example 1:
+Input:
+
+[1, 3, 2, 2, 2, 3, 4, 3, 1]
+
+Output:
+
+23
+
+Explanation:
+
+[1, 3, 2, 2, 2, 3, 4, 3, 1] 
+----> [1, 3, 3, 4, 3, 1] (3*3=9 points) 
+----> [1, 3, 3, 3, 1] (1*1=1 points) 
+----> [1, 1] (3*3=9 points) 
+----> [] (2*2=4 points)
+```
+
+Note: The number of boxes n would not exceed 100.
+
+
+### Solution:
+* Method 1: dp
+    ![Imgur](https://i.imgur.com/McRrZYK.png)
+    * dp[i][j][k]: represents the maximum score from index i to j and k means the number of boxes[j] appended after index j.
+    * Example [A, B, A, A, A] : dp[0][0][3] = 17 => (1 + 16)
+    * State transfer function:
+        * case 1: dp[i][j][k] = dp[i][j - 1][0] + (k + 1) ^ 2 -> This means we merge boxes[j] with the following boxes[j]
+        * case 2: dp[i][j][k] = dp[i][p][k + 1] + dp[p + 1][j - 1][0] where i <= p < j && boxes[p] == boxes[j]
+            * dp[i][p][k + 1]: since boxes[p] == boxes[j], so k + 1 means the previous k and the boxes[j].
+            * dp[p + 1][j - 1][0]: the max score between p + 1 and j - 1.
+    * Final result: dp[0][len - 1][0].
+    ```Java
+    class Solution {
+        private int[][][] dp;
+        public int removeBoxes(int[] boxes) {
+            int len = boxes.length;
+            dp = new int[len][len][len];
+            return dfs(boxes, 0, len - 1, 0);
+        }
+        private int dfs(int[] boxes, int i, int j, int k){
+            if(i > j) return 0;
+            if(dp[i][j][k] > 0) return dp[i][j][k];
+            dp[i][j][k] = dfs(boxes, i, j - 1, 0) + (k + 1) * (k + 1);
+            for(int p = i; p < j; p++){
+                if(boxes[p] == boxes[j]){
+                    dp[i][j][k] = Math.max(dp[i][j][k], dfs(boxes, i, p, k + 1) + dfs(boxes, p + 1, j - 1, 0));
+                }
+            }
+            return dp[i][j][k];
+        }
+    }
+    ```
+   
+
+### Reference
+1. [花花酱 LeetCode 546. Remove Boxes](https://zxi.mytechroad.com/blog/dynamic-programming/leetcode-546-remove-boxes/)

leetcode/62. Unique Paths.md

@@ -70,3 +70,22 @@ class Solution {
     }
 }
 ```
+
+### Third time
+* Method 1: dp[i][j]: the number of ways of reaching position (i, j);
+	```Java
+	class Solution {
+		public int uniquePaths(int m, int n) {
+			int[][] dp = new int[m][n];
+			dp[0][0] = 1;
+			for(int i = 1; i < m; i++)  dp[i][0] = 1;
+			for(int i = 1; i < n; i++)  dp[0][i] = 1;
+			for(int i = 1; i < m; i++){
+				for(int j = 1; j < n; j++){
+					dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+				}
+			}
+			return dp[m - 1][n - 1];
+		}
+	}
+	```

leetcode/63. Unique Paths II.md

@@ -90,3 +90,31 @@ class Solution {
     }
 }
 ```
+
+### Thrid time
+* Method 1:dp
+	```Java
+	class Solution {
+		public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+			int height = obstacleGrid.length, width = obstacleGrid[0].length;
+			int[][] dp = new int[height][width];
+			if(obstacleGrid[0][0] == 1) return 0;
+			dp[0][0] = 1;
+			for(int i = 1; i < height; i++){
+				if(obstacleGrid[i][0] == 1) break;
+				dp[i][0] = 1;
+			}
+			for(int i = 1; i < width; i++){
+				if(obstacleGrid[0][i] == 1) break;
+				dp[0][i] = 1;
+			}
+			for(int i = 1; i < height; i++){
+				for(int j = 1; j < width; j++){
+					if(obstacleGrid[i][j] == 1) continue;
+					dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+				}
+			}
+			return dp[height - 1][width - 1];
+		}
+	}
+	```

leetcode/64. Minimum Path Sum.md

@@ -66,3 +66,25 @@ class Solution {
     }
 }
 ```
+
+### Third time
+* Method 1: dp
+	```Java
+	class Solution {
+		public int minPathSum(int[][] grid) {
+			int height = grid.length, width = grid[0].length;
+			int[][] dp = new int[height][width];
+			dp[0][0] = grid[0][0];
+			for(int i = 1; i < height; i++)
+				dp[i][0] = dp[i - 1][0] + grid[i][0];
+			for(int i = 1; i < width; i++)
+				dp[0][i] = dp[0][i - 1] + grid[0][i];
+			for(int i = 1; i < height; i++){
+				for(int j = 1; j < width; j++){
+					dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
+				}
+			}
+			return dp[height - 1][width - 1];
+		}
+	}
+	```

leetcode/664. Strange Printer.md

@@ -0,0 +1,61 @@
+## 664. Strange Printer
+
+### Question
+We There is a strange printer with the following two special requirements:
+1. The printer can only print a sequence of the same character each time.
+2. At each turn, the printer can print new characters starting from and ending at any places, and will cover the original existing characters.
+
+Given a string consists of lower English letters only, your job is to count the minimum number of turns the printer needed in order to print it.
+
+```
+Example 1:
+
+Input: "aaabbb"
+Output: 2
+Explanation: Print "aaa" first and then print "bbb".
+
+Example 2:
+
+Input: "aba"
+Output: 2
+Explanation: Print "aaa" first and then print "b" from the second place of the string, which will cover the existing character 'a'.
+```
+
+Hint: Length of the given string will not exceed 100.
+
+### Solution:
+* Method 1: dp O(N^3)
+    ![Imgur](https://i.imgur.com/1ev7RAn.png)
+    * the hint of 100 means the O(N^3), 500 - 1000 always means O(N^2)
+    * how can we use the dp? We need to combine recursion and dp together.
+        * Recursion: turn(s, i, j) get the minimum step to print s from index i to j.
+        * fallback: turn(s, i, j) = turn(s, i, j - 1) + 1;
+        * Optimization: dp[i][j] = dp[i][k] + dp[k + 1][j - 1] where k >= i && k < j and we need char at k euqals char at j.
+            * since charAt(k) == charAt(j), we can print their value as that char duing the period of dp[i][k].
+    ```Java
+    class Solution {
+        private int[][] dp;
+        public int strangePrinter(String s) {
+            int len = s.length();
+            dp = new int[len + 1][len + 1];
+            return turn(s, 1, len);
+        }
+        private int turn(String s, int i, int j){
+            if(i > j) return 0; //empty string.
+            else if(dp[i][j] > 0) return dp[i][j]; //Cached
+            else{
+                //Give the fall back.
+                dp[i][j] = turn(s, i, j - 1) + 1;
+                for(int k = i; k < j; k++){
+                    if(s.charAt(j - 1) == s.charAt(k - 1))
+                        dp[i][j] = Math.min(turn(s, i, k) + turn(s, k + 1, j - 1), dp[i][j]);
+                }
+                return dp[i][j];
+            }
+        }
+    }
+    ```
+   
+
+### Reference
+1. [花花酱 LeetCode 664. Strange Printer](http://zxi.mytechroad.com/blog/dynamic-programming/leetcode-664-strange-printer/)

leetcode/741. Cherry Pickup.md

@@ -0,0 +1,81 @@
+## 741. Cherry Pickup
+
+### Question
+In a N x N grid representing a field of cherries, each cell is one of three possible integers.
+* 0 means the cell is empty, so you can pass through;
+* 1 means the cell contains a cherry, that you can pick up and pass through;
+* -1 means the cell contains a thorn that blocks your way.
+
+ 
+
+Your task is to collect maximum number of cherries possible by following the rules below:
+* Starting at the position (0, 0) and reaching (N-1, N-1) by moving right or down through valid path cells (cells with value 0 or 1);
+* After reaching (N-1, N-1), returning to (0, 0) by moving left or up through valid path cells;
+* When passing through a path cell containing a cherry, you pick it up and the cell becomes an empty cell (0);
+* If there is no valid path between (0, 0) and (N-1, N-1), then no cherries can be collected.
+
+```
+Example 1:
+
+Input: grid =
+[[0, 1, -1],
+ [1, 0, -1],
+ [1, 1,  1]]
+Output: 5
+Explanation: 
+The player started at (0, 0) and went down, down, right right to reach (2, 2).
+4 cherries were picked up during this single trip, and the matrix becomes [[0,1,-1],[0,0,-1],[0,0,0]].
+Then, the player went left, up, up, left to return home, picking up one more cherry.
+The total number of cherries picked up is 5, and this is the maximum possible.
+```
+
+Note:
+1. grid is an N by N 2D array, with 1 <= N <= 50.
+2. Each grid[i][j] is an integer in the set {-1, 0, 1}.
+3. It is guaranteed that grid[0][0] and grid[N-1][N-1] are not -1.
+
+### Solution:
+* Method 1: dp
+    ![Imgur](https://i.imgur.com/Qm9Ymed.png)
+    * dp[x1][y1][x2]: the max cherry can pick up to (x1, y1), (x2, y2) where y2 = x1 + y1 - x2. This dp means we have 2 people picking cherry from (0, 0) to (N - 1, N - 1).
+    * dp[x1][y1][x2] = max(dp(x1 - 1, y1, x2), dp(x1, y1 - 1, x2), dp(x1 - 1, y1, x2 - 1), dp(x1, y1 - 1, x2 - 1)) + grid[x1][y1] + grid[x2][y2].
+    * if both at same position, and current value is 1, only increase once.
+    ```Java
+    class Solution {
+        private int[][][] dp;
+        public int cherryPickup(int[][] grid) {
+            int height = grid.length, width = grid[0].length;
+            dp = new int[height][width][height];
+            for(int i = 0; i < height; i++)
+                for(int j = 0; j < width; j++)
+                    Arrays.fill(dp[i][j], Integer.MIN_VALUE);
+            return Math.max(dp(grid, height - 1, width - 1, height - 1), 0);
+        }
+        private int dp(int[][] grid, int x1, int y1, int x2){
+            int y2 = x1 + y1 - x2;
+            if(x1 < 0 || y1 < 0 || x2 < 0 || y2 < 0){
+                return -1;
+            }
+            if(x1 == 0 && y1 == 0 && x2 == 0){
+                dp[0][0][0] = grid[0][0];
+                return dp[0][0][0];
+            }
+            if(dp[x1][y1][x2] != Integer.MIN_VALUE) return dp[x1][y1][x2];
+            if(grid[x1][y1] == -1 || grid[x2][y2] == -1) return -1;
+            dp[x1][y1][x2] = Math.max(Math.max(dp(grid, x1 - 1, y1, x2), dp(grid, x1, y1 - 1, x2)), 
+                                       Math.max(dp(grid, x1, y1 - 1, x2 - 1), dp(grid, x1 - 1, y1, x2 - 1)));
+            if(dp[x1][y1][x2] >= 0){
+                int g1 = grid[x1][y1], g2 = grid[x2][y2];
+                if(g1 >= 0) dp[x1][y1][x2] += g1;
+                if(g2 >= 0) dp[x1][y1][x2] += g2;
+                if(g1 == g2 && g1 == 1 && x1 == x2 && y1 == y2)
+                    dp[x1][y1][x2]--;
+            }
+            return dp[x1][y1][x2];
+        }
+    }
+    ```
+   
+
+### Reference
+1. [花花酱 LeetCode 741. Cherry Pickup](http://zxi.mytechroad.com/blog/dynamic-programming/leetcode-741-cherry-pickup/)