https://labuladong.github.io/ebook/动态规划系列/
一、两种思路
1、第一种思路模板是一个一维的 dp 数组:
int n = array.length;
int[] dp = new int[n];
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
dp[i] = 最值(dp[i], dp[j] + ...)
}
}
举个我们写过的例子「最长递增子序列」,在这个思路中 dp 数组的定义是:
在子数组 array[0..i] 中,我们要求的子序列(最长递增子序列)的长度是 dp[i]。
为啥最长递增子序列需要这种思路呢?前文说得很清楚了,因为这样符合归纳法,可以找到状态转移的关系,这里就不具体展开了。
2、第二种思路模板是一个二维的 dp 数组:
int n = arr.length;
int[][] dp = new dp[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (arr[i] == arr[j])
dp[i][j] = dp[i][j] + ...
else
dp[i][j] = 最值(...)
}
}
这种思路运用相对更多一些,尤其是涉及两个字符串/数组的子序列,比如前文讲的「最长公共子序列」。本思路中 dp 数组含义又分为「只涉及一个字符串」和「涉及两个字符串」两种情况。
2.1 涉及两个字符串/数组时(比如最长公共子序列),dp 数组的含义如下:
在子数组 arr1[0..i] 和子数组 arr2[0..j] 中,我们要求的子序列(最长公共子序列)长度为 dp[i][j]。
2.2 只涉及一个字符串/数组时(比如本文要讲的最长回文子序列),dp 数组的含义如下:
在子数组 array[i..j] 中,我们要求的子序列(最长回文子序列)的长度为 dp[i][j]。
解决两个字符串的动态规划问题,一般都是用两个指针 i,j
分别指向两个字符串的最后,然后一步步往前走,缩小问题的规模。
int minDistance(String s1, String s2) {//动态规划 二维
int m = s1.length(), n = s2.length();
int[][] dp = new int[m + 1][n + 1];//空串算1个
// base case
for (int i = 1; i <= m; i++)
dp[i][0] = i;
for (int j = 1; j <= n; j++)
dp[0][j] = j;
// 自底向上求解
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
if (s1.charAt(i-1) == s2.charAt(j-1))
dp[i][j] = dp[i - 1][j - 1];
else
dp[i][j] = min(
dp[i - 1][j] + 1,//删除
dp[i][j - 1] + 1,//插入
dp[i-1][j-1] + 1//替换
);
// 储存着整个 s1 和 s2 的最小编辑距离
return dp[m][n];
}
int minDistance(String s1, String s2) {//动态规划 一维
int m = s1.length(), n = s2.length();
int[] dp = new int[n + 1];
// base case
for (int j = 0; j <= n; j++)
dp[j] = j;
// 自底向上求解
for (int i = 1; i <= m; i++)
for (int j = 1,temp; j <= n; j++){
temp=dp[j];
if(j==1) dp[j]=i;
else if (s1.charAt(i-1) == s2.charAt(j-1))
dp[j] = dpij;
else
dp[j] = min(
dp[j] + 1,//删除
dp[j - 1] + 1,//插入
dpij+ 1);//替换
dpij=temp;
}
// 储存着整个 s1 和 s2 的最小编辑距离
return dp[n];
}
最长公共子序列(Longest Common Subsequence,简称 LCS)是一道非常经典的面试题目,因为它的解法是典型的二维动态规划,大部分比较困难的字符串问题都和这个问题一个套路,比如说编辑距离。而且,这个算法稍加改造就可以用于解决其他问题,所以说 LCS 算法是值得掌握的。
题目就是让我们求两个字符串的 LCS 长度:
输入: str1 = "abcde", str2 = "ace"
输出: 3
解释: 最长公共子序列是 "ace",它的长度是 3
用两个指针 i
和 j
从后往前遍历 s1
和 s2
,如果 s1[i]==s2[j]
,那么这个字符一定在 lcs
中;否则的话,s1[i]
和 s2[j]
这两个字符至少有一个不在 lcs
中,需要丢弃一个。
对于第一种情况,找到一个 lcs
中的字符,同时将 i
j
向前移动一位,并给 lcs
的长度加一;对于后者,则尝试两种情况,取更大的结果。
def longestCommonSubsequence(str1, str2) -> int:
m, n = len(str1), len(str2)
# 构建 DP table 和 base case
dp = [[0] * (n + 1) for _ in range(m + 1)]
# 进行状态转移
for i in range(1, m + 1):
for j in range(1, n + 1):
if str1[i - 1] == str2[j - 1]:
# 找到一个 lcs 中的字符
dp[i][j] = 1 + dp[i-1][j-1]
else:
dp[i][j] = max(dp[i-1][j], dp[i][j-1])#dp[i-1][j-1]一定是最小,所以不用比较
return dp[-1][-1]
dp[i][j]和dp[i-1][j],dp[i][j-1],dp[i-1][j-1]有关的状态转移方程都可以最终优化成一维dp
int longestPalindromeSubseq(string s) {//动态规划 二维(可优化为一维)
int n = s.size();
// dp 数组全部初始化为 0
vector> dp(n, vector(n, 0));
// base case
for (int i = 0; i < n; i++)
dp[i][i] = 1;
// 反着遍历保证正确的状态转移
for (int i = n - 1; i >= 0; i--) {
for (int j = i + 1; j < n; j++) {
// 状态转移方程
if (s[i] == s[j])
dp[i][j] = dp[i + 1][j - 1] + 2;
else
dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
}
}
// 整个 s 的最长回文子串长度
return dp[0][n - 1];
}