[Function add]

1. Add leetcode solutions with tag dp.

Author: Seanforfun

leetcode/174. Dungeon Game.md

@@ -0,0 +1,49 @@
+## 174. Dungeon Game
+
+### Question:
+The demons had captured the princess (P) and imprisoned her in the bottom-right corner of a dungeon. The dungeon consists of M x N rooms laid out in a 2D grid. Our valiant knight (K) was initially positioned in the top-left room and must fight his way through the dungeon to rescue the princess.
+
+The knight has an initial health point represented by a positive integer. If at any point his health point drops to 0 or below, he dies immediately.
+
+Some of the rooms are guarded by demons, so the knight loses health (negative integers) upon entering these rooms; other rooms are either empty (0's) or contain magic orbs that increase the knight's health (positive integers).
+
+In order to reach the princess as quickly as possible, the knight decides to move only rightward or downward in each step.
+
+Write a function to determine the knight's minimum initial health so that he is able to rescue the princess.
+
+For example, given the dungeon below, the initial health of the knight must be at least 7 if he follows the optimal path RIGHT-> RIGHT -> DOWN -> DOWN.
+```
+-2 (K) 	-3 	3
+-5 	-10 	1
+10 	30 	-5 (P)
+```
+ 
+Note:
+* The knight's health has no upper bound.
+* Any room can contain threats or power-ups, even the first room the knight enters and the bottom-right room where the princess is imprisoned.
+
+### Solution:
+* Method 1: DP O(MN) AC 96.21%
+    ```Java
+    class Solution {
+        public int calculateMinimumHP(int[][] dungeon) {
+            int height = dungeon.length, width = dungeon[0].length;
+            int[][] dp = new int[height][width];
+            dp[height - 1][width - 1] = Math.max(1, -dungeon[height - 1][width - 1] + 1);
+            for(int i = height - 2; i >= 0; i--)
+                dp[i][width - 1] = Math.max(-dungeon[i][width - 1] + dp[i + 1][width - 1], 1);
+            for(int i = width - 2; i >= 0; i--)
+                dp[height - 1][i] = Math.max(1, -dungeon[height - 1][i] + dp[height - 1][i + 1]);
+            for(int i = height - 2; i >= 0; i--){
+                for(int j = width - 2; j >= 0; j--){
+                    dp[i][j] = Math.max(Math.min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j], 1);
+                }
+            }
+            return dp[0][0];
+        }
+    }
+    ```
+
+### Reference
+1. [花花酱 LeetCode 174. Dungeon Game](https://zxi.mytechroad.com/blog/dynamic-programming/leetcode-174-dungeon-game/)
+

leetcode/221. Maximal Square.md

@@ -112,4 +112,32 @@ class Solution {
         return max * max;
     }
 }
-```
+```
+
+### Fourth Time
+* Method 1: dp
+	```Java
+	class Solution {
+		public int maximalSquare(char[][] matrix) {
+			if(matrix == null || matrix.length == 0 || matrix[0].length == 0) return 0;
+			int height = matrix.length, width = matrix[0].length;
+			int[][] dp = new int[height][width];
+			int side = 0;
+			for(int i = 0; i < height; i++){
+				for(int j = 0; j < width; j++){
+					if(matrix[i][j] == '0') continue;
+					else{
+						dp[i][j] = 1;
+						if(i > 0 && j > 0){
+							if(dp[i - 1][j] > 0 && dp[i][j - 1] > 0 && dp[i - 1][j - 1] > 0){
+								dp[i][j] = Math.min(dp[i - 1][j], Math.min(dp[i][j - 1], dp[i - 1][j - 1])) + 1;
+							}
+						}
+						side = Math.max(side, dp[i][j]);
+					}
+				}
+			}
+			return side * side;
+		}
+	}
+	```

leetcode/304. Range Sum Query 2D - Immutable.md

@@ -135,4 +135,36 @@ class NumMatrix {
  * NumMatrix obj = new NumMatrix(matrix);
  * int param_1 = obj.sumRegion(row1,col1,row2,col2);
  */
-```
+```
+
+### Thrid Time
+* Method 1: dp
+	```Java
+	class NumMatrix {
+		private int[][] dp;
+		public NumMatrix(int[][] matrix) {
+			if(matrix == null || matrix.length == 0 || matrix[0].length == 0) return;
+			int height = matrix.length, width = matrix[0].length;
+			dp = new int[height][width];
+			dp[0][0] = matrix[0][0];
+			for(int i = 1; i < width; i++) dp[0][i] += dp[0][i - 1] + matrix[0][i];
+			for(int i = 1; i < height; i++) dp[i][0] += dp[i - 1][0] +matrix[i][0];
+			for(int i = 1; i < height; i++){
+				for(int j = 1; j < width; j++){
+					dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + matrix[i][j];
+				}
+			}
+		}
+		public int sumRegion(int row1, int col1, int row2, int col2) {
+			return dp[row2][col2]
+				- (col1 > 0 ? dp[row2][col1 - 1]: 0)
+				- (row1 > 0 ? dp[row1 - 1][col2]: 0)
+				+ (row1 > 0 && col1 > 0 ? dp[row1 - 1][col1 - 1]: 0);
+		}
+	}
+	/**
+	 * Your NumMatrix object will be instantiated and called as such:
+	 * NumMatrix obj = new NumMatrix(matrix);
+	 * int param_1 = obj.sumRegion(row1,col1,row2,col2);
+	 */
+	```

leetcode/688. Knight Probability in Chessboard.md

@@ -0,0 +1,68 @@
+## 688. Knight Probability in Chessboard
+
+### Question:
+On an NxN chessboard, a knight starts at the r-th row and c-th column and attempts to make exactly K moves. The rows and columns are 0 indexed, so the top-left square is (0, 0), and the bottom-right square is (N-1, N-1).
+
+A chess knight has 8 possible moves it can make, as illustrated below. Each move is two squares in a cardinal direction, then one square in an orthogonal direction.
+
+![Imgur](https://i.imgur.com/qkALNuc.png)
+
+Each time the knight is to move, it chooses one of eight possible moves uniformly at random (even if the piece would go off the chessboard) and moves there.
+
+The knight continues moving until it has made exactly K moves or has moved off the chessboard. Return the probability that the knight remains on the board after it has stopped moving.
+
+ 
+```
+Example:
+
+Input: 3, 2, 0, 0
+Output: 0.0625
+Explanation: There are two moves (to (1,2), (2,1)) that will keep the knight on the board.
+From each of those positions, there are also two moves that will keep the knight on the board.
+The total probability the knight stays on the board is 0.0625.
+```
+ 
+Note:
+* N will be between 1 and 25.
+* K will be between 0 and 100.
+* The knight always initially starts on the board.
+
+
+ 
+Note:
+* 1 <= A.length == A[0].length <= 100
+* -100 <= A[i][j] <= 100
+
+
+### Solution:
+* Method 1: DP O(MN) AC
+    ```Java
+    class Solution {
+        public double knightProbability(int N, int K, int r, int c) {
+            double[][] pre = new double[N][N];
+            pre[r][c] = 1D;
+            for(int k = 1; k <= K; k++){
+                double[][] dp = new double[N][N];
+                for(int i = 0; i < N; i++){
+                    for(int j = 0; j < N; j++){
+                        dp[i][j] = ((i - 1 >= 0 && j - 2 >= 0) ? pre[i - 1][j - 2]: 0)
+                            + ((i - 2 >= 0 && j - 1 >= 0) ? pre[i - 2][j - 1]: 0)
+                            + ((i + 1 < N && j - 2 >= 0) ? pre[i + 1][j - 2]: 0)
+                            + ((i + 2 < N && j - 1 >= 0) ? pre[i + 2][j - 1]: 0)
+                            + ((i - 2 >= 0 && j + 1 < N) ? pre[i - 2][j + 1]: 0)
+                            + ((i - 1 >= 0 && j + 2 < N) ? pre[i - 1][j + 2]: 0)
+                            + ((i + 1 < N && j + 2 < N) ? pre[i + 1][j + 2]: 0)
+                            + ((i + 2 < N && j + 1 < N) ? pre[i + 2][j + 1]: 0);
+                    }
+                }
+                pre = dp;
+            }
+            double sum = 0;
+            for(int i = 0; i < N; i++)
+                for(int j = 0; j < N; j++)
+                    sum += pre[i][j];
+            return sum / Math.pow(8, K);
+        }
+    }
+    ```
+

leetcode/85. Maximal Rectangle.md

@@ -118,6 +118,77 @@ class Solution {
     }
 }
 ```
+
+### Second Time
+* Method 1: Stack
+	```Java
+	class Solution {
+		public int maximalRectangle(char[][] matrix) {
+			if(matrix.length == 0 || matrix[0].length == 0) return 0;
+			int height = matrix.length, width = matrix[0].length;
+			int[] dp = new int[width];
+			int res = 0;
+			for(int i = 0; i < height; i++){
+				for(int j = 0; j < width; j++){
+					if(matrix[i][j] == '1') dp[j]++;
+					else dp[j] = 0;
+				}
+				Stack<Integer> stack = new Stack<>();
+				for(int c = 0; c <= width; c++){
+					int hh = c == width ? 0: dp[c];
+					while(!stack.isEmpty() && hh < dp[stack.peek()]){
+						int h = dp[stack.pop()];
+						int index = stack.isEmpty() ? -1: stack.peek();
+						int area = h * (c - index - 1);
+						res = Math.max(res, area);
+					}
+					stack.push(c);
+				}
+			}
+			return res;
+		}
+	}
+	```
+
+* Method 2: dp
+	```Java
+	class Solution {
+		public int maximalRectangle(char[][] matrix) {
+			if(matrix == null || matrix.length == 0 || matrix[0].length == 0) return 0;
+			int h = matrix.length, width = matrix[0].length;
+			int[] height = new int[width];
+			int[] left = new int[width];
+			int[] right = new int[width];
+			Arrays.fill(right, width);
+			int res = 0;
+			for(int i = 0; i < h; i++){
+				int curLeft = 0, curRight = width;
+				for(int j = 0; j < width; j++){ // Calculate the height array
+					if(matrix[i][j] == '1') height[j]++;
+					else   height[j] = 0;
+				}
+				for(int j = 0; j < width; j++){
+					if(matrix[i][j] == '1') left[j] = Math.max(curLeft, left[j]);
+					else{
+						left[j] = 0;
+						curLeft = j + 1;
+					}
+				}
+				for(int j = width - 1; j >= 0; j--){
+					if(matrix[i][j] == '1') right[j] = Math.min(curRight, right[j]);
+					else{
+						right[j] = width;
+						curRight = j;
+					}
+				}
+				for(int j = 0; j < width; j++){
+					res = Math.max(res, height[j] * (right[j] - left[j]));
+				}
+			}
+			return res;
+		}
+	}
+	```
 
 
 ### Reference

leetcode/931. Minimum Falling Path Sum.md

@@ -0,0 +1,50 @@
+## 931. Minimum Falling Path Sum
+
+### Question:
+Given a square array of integers A, we want the minimum sum of a falling path through A.
+
+A falling path starts at any element in the first row, and chooses one element from each row.  The next row's choice must be in a column that is different from the previous row's column by at most one.
+
+```
+Example 1:
+
+Input: [[1,2,3],[4,5,6],[7,8,9]]
+Output: 12
+Explanation: 
+The possible falling paths are:
+* [1,4,7], [1,4,8], [1,5,7], [1,5,8], [1,5,9]
+* [2,4,7], [2,4,8], [2,5,7], [2,5,8], [2,5,9], [2,6,8], [2,6,9]
+* [3,5,7], [3,5,8], [3,5,9], [3,6,8], [3,6,9]
+
+The falling path with the smallest sum is [1,4,7], so the answer is 12.
+```
+ 
+Note:
+* 1 <= A.length == A[0].length <= 100
+* -100 <= A[i][j] <= 100
+
+
+### Solution:
+* Method 1: DP O(MN) AC 96.21%
+    ```Java
+    class Solution {
+        public int minFallingPathSum(int[][] A) {
+            int len = A.length;
+            if(len == 0) return 0;
+            int[][] dp = new int[len][len];
+            for(int i = 0; i < len; i++){
+                dp[0][i] = A[0][i];
+            }
+            for(int i = 1; i < len; i++){
+                for(int j = 0; j < len; j++){
+                    dp[i][j] = Math.min(Math.min(j > 0 ? dp[i - 1][j - 1]: Integer.MAX_VALUE, j + 1 < len ? dp[i - 1][j + 1]: Integer.MAX_VALUE), dp[i - 1][j]) + A[i][j];
+                }
+            }
+            int res = Integer.MAX_VALUE;
+            for(int i = 0; i < len; i++)
+                res = Math.min(res, dp[len - 1][i]);
+            return res;
+        }
+    }
+    ```
+