DP 解题步骤；
总结：https://docs.google.com/document/d/1tUYkzxQ1J6e_ruM0aaQG6LxqKwxYYbjJ7NlFzE7d930/edit
总共有：
坐标型DP
划分型DP
博弈型DP
双序列型DP
背包DP
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
坐标型DP
坐标性动态规划；开的数组跟输入大小一样，matrix[i,j] 跟 dp[i,j] 是对应的；
注意滚动数组的精髓是: 申请的数组f[]取模，而不是A数组取模，也不是循环减少，注意背后的思想；
class Solution {
public int minPathSum(int[][] grid) {
int n = grid.length;
int m = grid[0].length;
int[][] dp = new int[2][m];
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
if(i == 0 && j == 0) {
dp[i][j] = grid[0][0];
} else if(i == 0 && j >= 1) {
dp[i % 2][j] = dp[i % 2][j - 1] + grid[i][j];
} else if(j == 0 && i >= 1) {
dp[i % 2][j] = dp[(i - 1) % 2][j] + grid[i][j];
} else {
dp[i % 2][j] = Math.min(dp[i % 2][j - 1], dp[(i - 1) % 2][j]) + grid[i][j];
}
}
}
return dp[(n - 1) % 2][m - 1];
}
}划分型DP
划分型就是给定长度为N序列或者字符串，要求划分成若干段。每段满足一定性质；
划分性动态规划，就是看最后一段的位子，这题decode ways，就是只有两个位子；
class Solution {
public int numDecodings(String s) {
if(s == null || s.length() == 0) {
return 0;
}
int n = s.length();
int[] f = new int[n + 1];
f[0] = 1;
for(int i = 1; i < n + 1; i++) {
if(isvalid(s.substring(i-1, i))) {
f[i] += f[i-1];
}
if(i > 1 && isvalid(s.substring(i-2, i))){
f[i] += f[i-2];
}
}
return f[n];
}
private boolean isvalid(String s) {
if(s == null || s.charAt(0) == '0') {
return false;
}
int num = Integer.parseInt(s);
return 1 <= num && num <= 26;
}
}class Solution {
public int numDecodings(String s) {
if(s == null || s.length() == 0) {
return 0;
}
int MOD = 1000000007;
int n = s.length();
long[] dp = new long[n + 1];
char[] ss = s.toCharArray();
dp[0] = 1;
for(int i = 1; i <= n; i++) {
dp[i] += dp[i - 1] * count1(ss[i - 1]);
if(i - 2 >= 0) {
dp[i] += dp[i - 2] * count2(ss[i - 2], ss[i - 1]);
}
}
return (int)dp[n] % MOD;
}
// 个位；
private int count1(char c) {
if(c == '0') {
return 0;
}
if('1' <= c && c <= '9') {
return 1;
} else {
// c == '*';
return 9;
}
}
// 十位， 个位；
private int count2(char c2, char c1) {
if(c2 == '0') {
return 0;
} else if(c2 == '1') {
if('0' <= c1 && c1 <= '9') {
return 1;
} else {
// c1 == '*';
return 9;
}
} else if(c2 == '2') {
if('0' <= c1 && c1 <= '6') {
return 1;
} else if('6' < c1 && c1 <= '9') {
return 0;
} else if(c1 == '*') {
return 6;
}
} else if('3' <= c2 && c2 <= '9') {
return 0;
}
// (c2 == '*')
if('0' <= c1 && c1 <= '6') {
return 2;
} else if('7' <= c1 && c1 <= '9') {
return 1;
} else {
// c1 == '*';
// c2 = 1, c1 有9种
// c2 = 2, c1 有6种
return 15;
}
}
}博弈型DP
只要下面有一个必败，那么当前就是必胜，反之亦然
public class Solution {
/**
* @param n: An integer
* @return: A boolean which equals to true if the first player will win
*/
public boolean firstWillWin(int n) {
// write your code here
boolean[] dp = new boolean[2];
if(n == 0) return false;
if(n <= 2) return true;
dp[0 % 2] = false;
dp[1 % 2] = dp[2 % 2] = true;
for(int i = 3; i <= n; i++) {
dp[i % 2] = dp[(i - 1) % 2] == false || dp[(i - 2) % 2] == false;
}
return dp[n % 2];
}
}Coins in a line II [i] 表示的是面对[i...n-1] 的数字的时候，我能够取得的最大值，这里可以取一个，或者取两个；
f[i] = Math.max(a[i] - f[i+1], a[i] + a[i+1] - f[i+2]) ;
public class Solution {
/**
* @param values: a vector of integers
* @return: a boolean which equals to true if the first player will win
*/
public boolean firstWillWin(int[] values) {
if(values == null || values.length == 0) {
return false;
}
int n = values.length;
int[] dp = new int[n + 1];
dp[n] = 0;
// dp[i] 表示面对i ~ n-1 的coin，能拿的最大value；
for(int i = n - 1; i >= 0; i--) {
dp[i] = values[i] - dp[i + 1];
if(i + 2 <= n) {
dp[i] = Math.max(dp[i], values[i] + values[i + 1] - dp[i + 2]);
}
}
return dp[0] >= 0;
}
}双序列性动态规划；
Interleaving String 首先看尾巴，s1[i],s2[j] 能否表达s3[k], 但是我们发现k = i + j，所以省去一维空间，做dp的题的时候，开数组的时候，首先看看有没有数学公式联系，如果有，降维，有几个降几维；
f[i][j] 表示X前i + j 个字符是否由A的前i个字符和B前j个字符组成；
f[i][j] = (f[i-1][j] AND A[i-1] == X[i+j-1]) OR (f[i][j-1] AND X[i+j-1] == B[j-1]) ;
class Solution {
public boolean isInterleave(String s1, String s2, String s3) {
if(s1 == null && s2 == null && s3 == null) return true;
int n = s1.length();
int m = s2.length();
boolean[][] dp = new boolean[n + 1][m + 1];
if(n + m != s3.length()) {
return false;
}
dp[0][0] = true;
// initial 1st row;
for(int j = 1; j <= m; j++) {
if(s3.charAt(j - 1) == s2.charAt(j - 1)) {
dp[0][j] = dp[0][j - 1];
} else {
dp[0][j] = false;
}
}
// initial 1st col;
for(int i = 1; i <= n; i++) {
if(s3.charAt(i - 1) == s1.charAt(i - 1)) {
dp[i][0] = dp[i - 1][0];
} else {
dp[i][0] = false;
}
}
// calculate matrix;
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= m; j++) {
dp[i][j] = (s3.charAt(i + j - 1) == s1.charAt(i - 1) && dp[i - 1][j])
|| (s3.charAt(i + j - 1) == s2.charAt(j - 1) && dp[i][j - 1]);
}
}
return dp[n][m];
}
}Longest Common Subsequence 看最后一步，f[i][j] 表示下标为Ai, Bj的数，能够表示的longest common subsequence是多少；
状态转移方程：f[i][j] = Max{f[i][j-1], f[i-1][j], f[i-1][j-1] | A[i] = B[j]}; 注意如果Ai == Bj, 要+1，因为好不容易匹配上一个，需要长度+1；
注意：因为要用到f[n][m]所以申请f[n+1][m+1]大小的数组； Time O(n*m) Space(n*m); 打印路径，也就是打印出最长子序列代码：
思路：用pi数组记录当时f[i][j]是怎么来的，是砍掉A的尾巴，还是B的尾巴，还是A和B的尾巴match；然后反向输出得到的；
class Solution {
public int longestCommonSubsequence(String text1, String text2) {
if(text1 == null || text2 == null) {
return 0;
}
int n = text1.length();
int m = text2.length();
int[][] dp = new int[n + 1][m + 1];
int[][] pie = new int[n + 1][m + 1];
for(int i = 0; i <= n; i++) {
for(int j = 0; j <= m; j++) {
if(i == 0 || j == 0) {
dp[i][j] = 0;
} else {
// i >= 1 && j >= 1;
if(text1.charAt(i - 1) == text2.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1] + 1;
pie[i][j] = 2; // coming from diagonal;
} else {
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
if(dp[i][j] == dp[i - 1][j]) { // coming from up;
pie[i][j] = 0;
}
if(dp[i][j] == dp[i][j - 1]) { // coming from left;
pie[i][j] = 1;
}
}
}
}
}
StringBuilder sb = new StringBuilder();
int row = n; int col = m; int pos = dp[n][m];
while(row >= 0 && col >= 0) {
if(pie[row][col] == 2) {
sb.insert(0, text1.charAt(row - 1));
pos--;
row--;
col--;
} else if(pie[row][col] == 0) {
row--;
} else {
// pie[row][col] = 1;
col--;
}
}
System.out.println("common subsequence is:" + sb.toString());
return dp[n][m];
}
}class Solution {
public int minDistance(String word1, String word2) {
if(word1 == null || word1.length() == 0) {
return word2.length();
}
if(word2 == null || word2.length() == 0) {
return word1.length();
}
int n = word1.length();
int m = word2.length();
int[][] dp = new int[n + 1][m + 1];
for(int i = 0; i <= n; i++) {
for(int j= 0; j <= m; j++) {
if(i == 0 && j == 0) {
dp[i][j] = 0;
} else if(i == 0 && j != 0) {
dp[i][j] = j;
} else if(i != 0 && j == 0) {
dp[i][j] = i;
} else {
if(word1.charAt(i - 1) == word2.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1];
} else {
dp[i][j] = Math.min(dp[i - 1][j] + 1,
Math.min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1));
}
}
}
}
return dp[n][m];
}
}区间型DP (消去型DP)
Burst Bollons 思路：f[i][j]代表：i个气球和j个气球不能被扎破的情况下，中间扎破能够得到的最大值。
记住首尾先要加入一个1，然后区间型动态规划，一定是先计算小区间然后计算大区间，所以for循环用len来写，然后枚举起点，最后得到整个区间的最大值；
class Solution {
public int maxCoins(int[] nums) {
int n = nums.length;
int[] A = new int[n + 2];
// 最左边和最右边放值1；
A[0] = 1; A[A.length - 1] = 1;
for(int i = 1; i < A.length - 1; i++) {
A[i] = nums[i - 1];
}
n += 2;
int[][] dp = new int[n][n];
// [1] A[0]....A[n - 2] [1]
// 枚举length，区间型动态规划，都是从length从小到大计算的；
for(int len = 2; len <= n; len++) {
for(int i = 0; i + len - 1 < n; i++) {
int j = i + len - 1;
for(int k = i + 1; k < j; k++) {
dp[i][j] = Math.max(dp[i][j], dp[i][k] + dp[k][j] + A[i]* A[k]* A[j]);
}
}
}
return dp[0][n - 1];
}
}思路2：这题可以用Stone Game的记忆化递归来做，score(start, end, fullNums, cache); O(N^2); top down的解法；也就是算每个一点，最后扎破，看计算出来谁最大，谁就是答案；扎破中间的气球的时候，假设左右两边全部爆掉了；也就是看最后一步；O(N^2);
class Solution {
public int maxCoins(int[] nums) {
if(nums == null || nums.length == 0) {
return 0;
}
int n = nums.length;
int[] A = new int[n + 2];
A[0] = 1; A[A.length - 1] = 1;
for(int i = 1; i < A.length -1; i++) {
A[i] = nums[i - 1];
}
n += 2;
int[][] cache = new int[n][n];
return dfs(A, 0, n - 1, cache);
}
private int dfs(int[] A, int start, int end, int[][] cache) {
if(start >= end) {
return 0;
}
if(cache[start][end] != 0) {
return cache[start][end];
}
int value = 0;
for(int k = start + 1; k < end; k++) {
value = Math.max(value, A[start] * A[k] * A[end]
+ dfs(A, start, k, cache) + dfs(A, k, end, cache));
}
cache[start][end] = value;
return cache[start][end];
}
}双序列型DP
public class Solution {
/**
* @param A: A string
* @param B: A string
* @return: The length of longest common subsequence of A and B
*/
public int longestCommonSubsequence(String AA, String BB) {
if(AA == null || AA.length() == 0 || BB == null || BB.length() == 0) return 0;
int n = AA.length();
int m = BB.length();
char[] A = AA.toCharArray();
char[] B = BB.toCharArray();
int[][] f = new int[n+1][m+1];
int[][] pi = new int[n+1][m+1];
for(int i = 0; i <= n; i++) {
for(int j = 0; j <= m; j++) {
if(i == 0 || j == 0) {
f[i][j] = 0;
continue;
}
f[i][j] = Math.max(f[i-1][j], f[i][j-1]);
if(f[i][j] == f[i-1][j]) {
pi[i][j] = 0; // 记录砍掉A的尾巴；
}
if(f[i][j] == f[i][j-1]) {
pi[i][j] = 1; // 记录砍掉B的尾巴；
}
if(A[i-1] == B[j-1]) {
f[i][j] = Math.max(f[i][j], f[i-1][j-1] + 1);
if(f[i][j] == f[i-1][j-1] + 1) { // 记录A和B的尾巴match；
pi[i][j] = 2;
}
}
}
}
//输出LCS；反向根据pi数组indicator找方向，然后输出；
int size = f[n][m];
int i = n;
int j = m;
char[] res = new char[size];
int p = size - 1;
while(i > 0 && j > 0) {
if(pi[i][j] == 0) {
--i;
}else if(pi[i][j] == 1) {
--j;
} else {
//pi[i][j] = 2;
res[p] = A[i-1]; // B[j-1]也是可以的;
--i;
--j;
--p;
}
}
System.out.println("longest common subsequence is:" + new String(res));
return f[n][m];
}
}背包DP
背包问题中，数组大小和总承重有关，总有一维是M
用f[i][j] 表示用前i个物品能否装满容量为j的情况，能true，不能false；最后再从右往左扫描一次，第一个true就是最大的容量能够装的；
public class Solution {
/**
* @param m: An integer m denotes the size of a backpack
* @param A: Given n items with size A[i]
* @return: The maximum size
*/
public int backPack(int m, int[] A) {
int n = A.length;
boolean[][] dp = new boolean[n + 1][m + 1];
dp[0][0] = true;
for(int j = 1; j <= m; j++) {
dp[0][j] = false;
}
for(int i = 1; i <= n; i++) {
for(int j = 0; j <= m; j++) {
dp[i][j] = dp[i - 1][j];
if(j - A[i - 1] >= 0) {
dp[i][j] |= dp[i - 1][j - A[i - 1]];
}
}
}
int max = 0;
for(int j = m; j >= 0; j--) {
if(dp[n][j]) {
max = j;
break;
}
}
return max;
}
}BackPack II 跟背包I类似，f[i][j]表示前i个物品组成重量为j的pack的总value是多少；我们还是从A[i-1] 能否进入pack来考虑
f[i][j] = Max( f[i-1][j] (不进去）, (进去）f[i-1][j - A[i-1]] + V[i-1] ,前提条件是: j -A[i-1] >=0 && f[i-1][j- A[i-1]] != -1;
这里我们巧妙的运用了所有物品是大于0，这个属性去掉了一个数组，这个数组用来表示能够组成j的package，跟背包I里面的数组是一个数组。我们这里用-1来表示，能否组成j； O(N*M) 空间由于状态转移方程只能i-1有关，可以优化成O(M);
public class Solution {
/**
* @param m: An integer m denotes the size of a backpack
* @param A: Given n items with size A[i]
* @param V: Given n items with value V[i]
* @return: The maximum value
*/
public int backPackII(int m, int[] A, int[] V) {
int n = A.length;
int[][] dp = new int[n + 1][m + 1];
for(int i = 0; i <= n; i++) {
Arrays.fill(dp[i], -1);
}
for(int i = 0; i <= n; i++) {
for(int j = 0; j <= m; j++) {
if(i == 0 || j == 0) {
dp[i][j] = 0;
} else {
dp[i][j] = dp[i - 1][j];
if(j - A[i - 1] >= 0 && dp[i - 1][j - A[i - 1]] != -1) {
dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - A[i - 1]] + V[i - 1]);
}
}
}
}
return dp[n][m];
}
}Stone Game V 思路：DFS + Cache. 比赛写出来很开心；
class Solution {
public int stoneGameV(int[] A) {
int n = A.length;
int[] prefix = new int[n + 1];
prefix[0] = 0;
for(int i = 1; i <= n; i++) {
prefix[i] = prefix[i - 1] + A[i - 1];
}
int[][] cache = new int[n][n];
return dfs(A, 0, n - 1, cache, prefix);
}
private int dfs(int[] A, int start, int end, int[][] cache, int[] prefix) {
if(start >= end) {
return 0;
}
if(cache[start][end] != 0) {
return cache[start][end];
}
int localmax = 0;
for(int k = start; k < end; k++) {
int localvalue = 0;
int leftsum = getSum(prefix, start, k);
int rightsum = getSum(prefix, k + 1, end);
if(leftsum > rightsum) {
localvalue = rightsum + dfs(A, k + 1, end, cache, prefix);
} else if(leftsum < rightsum) {
localvalue = leftsum + dfs(A, start, k, cache, prefix);;
} else {
// leftsum == rightsum;
localvalue = leftsum + Math.max(dfs(A, start, k, cache, prefix), dfs(A, k + 1, end, cache, prefix));
}
localmax = Math.max(localmax, localvalue);
}
cache[start][end] = localmax;
return cache[start][end];
}
private int getSum(int[] prefix, int i, int j) {
return prefix[j + 1] - prefix[i];
}
}这题，其实也可以正着写：
class Solution {
public int stoneGameV(int[] A) {
int n = A.length;
int[] prefix = new int[n + 1];
prefix[0] = 0;
for(int i = 1; i < prefix.length; i++) {
prefix[i] = prefix[i - 1] + A[i - 1];
}
int[][] dp = new int[n][n];
for(int len = 1; len <= n; len++) {
for(int i = 0; i + len - 1 < n; i++) {
int j = i + len - 1;
// i..k...j
int localmax = 0;
for(int k = i; k < j; k++) {
int localscore = 0;
int leftsum = getSum(prefix, i, k);
int rightsum = getSum(prefix, k + 1, j);
if(leftsum > rightsum) {
localscore = rightsum + dp[k + 1][j];
} else if(leftsum < rightsum) {
localscore = leftsum + dp[i][k];
} else {
// leftsum == rightsum;
localscore = leftsum + Math.max(dp[i][k], dp[k + 1][j]);
}
localmax = Math.max(localmax, localscore);
}
dp[i][j] = localmax;
}
}
return dp[0][n - 1];
}
private int getSum(int[] prefix, int i, int j) {
return prefix[j + 1] - prefix[i];
}
}
1996
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
