动态规划：子序列系列
300. 最长递增子序列
思路
最长上升子序列是动规的经典题目。
-
dp[i]的定义
dp[i]表示i之前包括i的最长上升子序列。 -
状态转移方程
位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。
所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1); -
dp[i]的初始化
dp[i]（即最长上升子序列）起始大小至少都是是1。 -
确定遍历顺序
dp[i] 是有0到i-1各个位置的最长升序子序列推导而来，那么遍历i一定是从前向后遍历。 -
举例推导dp数组
代码
class Solution {
public int lengthOfLIS(int[] nums) {
int n = nums.length,ans = 0;
if(n <=1) return n;
int[] dp = new int[n];
for(int i=0;i<n;i++){
dp[i] = 1;
}
for(int i=1;i<n;i++){
for(int j=0;j<i;j++){
if(nums[i]>nums[j]) dp[i] = Math.max(dp[i], dp[j] + 1);
}
if(dp[i] > ans ) ans = dp[i];
}
return ans;
}
}
674. 最长连续递增序列
思路
dp[i]：以下标i为结尾的数组的连续递增的子序列长度为dp[i]。
递推公式：如果 nums[i + 1] > nums[i]，那么dp[i + 1] = dp[i] + 1。
代码
class Solution {
public int findLengthOfLCIS(int[] nums) {
int n = nums.length,ans = 1;
int[] dp = new int[n];
for(int i=0;i<n;i++) dp[i] = 1;
for(int i=1;i<n;i++){
if(nums[i] > nums[i-1]) dp[i] = dp[i-1]+1;// 连续记录
if(dp[i] > ans) ans = dp[i];
}
return ans;
}
}
718. 最长重复子数组
思路
注意题目中说的子数组，其实就是连续子序列。
-
确定dp数组（dp table）以及下标的含义
dp[i][j] ：以下标i - 1为结尾的A和以下标j - 1为结尾的B的最长重复子数组长度。
可以定义dp[i][j]为以下标i为结尾的A和以下标j 为结尾的B的最长重复子数组长度，但实现起来就麻烦了一些。 -
确定递推公式
根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1; -
dp数组如何初始化
根据dp[i][j]的定义，dp[i][0] 和dp[0][j]其实都是没有意义的，但方便递归公式dp[i][0] 和dp[0][j]要初始值，所以初始化为0。 -
确定遍历顺序
外层for循环遍历A，内层for循环遍历B，或者外层for循环遍历B，内层for循环遍历A。
在遍历的时候顺便把dp[i][j]的最大值记录下来。 -
举例推导dp数组
代码
class Solution {
public int findLength(int[] nums1, int[] nums2) {
int[][] dp = new int[nums1.length+1][nums2.length+1];
int ans = 0;
for(int i=1;i<=nums1.length;i++){
for(int j=1;j<=nums2.length;j++){
if(nums1[i-1] == nums2[j-1]) dp[i][j] = dp[i-1][j-1]+1;
if(dp[i][j] > ans) ans = dp[i][j];
}
}
return ans;
}
}
滚动数组：
- dp[i][j]都是由dp[i - 1][j - 1]推出。那么压缩为一维数组，也就是dp[j]都是由dp[j - 1]推出
class Solution {
public int findLength(int[] nums1, int[] nums2) {
int[] dp = new int[nums2.length+1];
int ans = 0;
for(int i=1;i<=nums1.length;i++){
for(int j=nums2.length;j>0;j--){
if(nums1[i-1] == nums2[j-1]) dp[j] = dp[j-1]+1;
else dp[j] = 0;//不相等的时候要有赋0的操作
if(dp[j] > ans) ans = dp[j];
}
}
return ans;
}
}
1143. 最长公共子序列
思路
本题和 718. 最长重复子数组 区别在于不要求是连续的了，但要有相对顺序，即："ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。
-
确定dp数组（dp table）以及下标的含义
dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]
也可以定义为长度为[0, i]的字符串text1，但实现起来就麻烦了一些。 -
确定递推公式
两大情况：text1[i - 1] 与 text2[j - 1]相同，text1[i - 1] 与 text2[j - 1]不相同
- 如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;
- 如果text1[i - 1] 与 text2[j - 1]不相同，那就看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。
即：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
-
dp数组如何初始化
test1[0, i-1]和空串的最长公共子序列自然是0，所以dp[i][0] = 0;
同理dp[0][j]也是0。 -
确定遍历顺序
从递推公式，可以看出，有三个方向可以推出dp[i][j]，如图：
这三个方向都是经过计算的数值，所以要从前向后，从上到下来遍历这个矩阵。 -
举例推导dp数组
代码
class Solution {
public int longestCommonSubsequence(String text1, String text2) {
int[][] dp = new int[text1.length()+1][text2.length()+1];
for(int i=1;i<=text1.length();i++){
for(int j=1;j<=text2.length();j++){
if(text1.charAt(i-1) == text2.charAt(j-1)) dp[i][j] = dp[i-1][j-1]+1;
else dp[i][j] = Math.max(dp[i][j-1],dp[i-1][j]);
}
}
return dp[text1.length()][text2.length()];
}
}
1035. 不相交的线
思路
本题说是求绘制的最大连线数，其实就是求两个字符串的最长公共子序列的长度，和 1143. 最长公共子序列 是一模一样的。
只需要把字符串名字改一下，其他代码都不用改，直接copy过来就行了。
代码
class Solution {
public int maxUncrossedLines(int[] nums1, int[] nums2) {
int m = nums1.length, n = nums2.length;
int[][] dp = new int[m+1][n+1];
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++){
if(nums1[i-1] == nums2[j-1]) dp[i][j] = dp[i-1][j-1]+1;
else dp[i][j] = Math.max(dp[i][j-1],dp[i-1][j]);
}
}
return dp[m][n];
}
}
53. 最大子序和
思路
dp[i]：包括下标i之前的最大连续子序列和为dp[i]。
dp[i]只有两个方向可以推出来：
- dp[i - 1] + nums[i]，即：nums[i]加入当前连续子序列和
- nums[i]，即：从头开始计算当前连续子序列和
一定是取最大的，所以dp[i] = max(dp[i - 1] + nums[i], nums[i]);
代码
class Solution {
public int maxSubArray(int[] nums) {
if(nums.length == 0) return 0;
int ans=nums[0];
int[] dp = new int[nums.length];
dp[0] = nums[0];
for(int i=1;i<nums.length;i++){
dp[i] = Math.max(nums[i],dp[i-1] + nums[i]);// 状态转移公式
if(dp[i] > ans) ans = dp[i];
}
return ans;
}
}
392. 判断子序列
思路
dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。
确定递推公式，考虑如下两种操作：
- if (s[i - 1] == t[j - 1])
t中找到了一个字符在s中也出现了，那么dp[i][j] = dp[i - 1][j - 1] + 1; - if (s[i - 1] != t[j - 1])
相当于t要删除元素，继续匹配。
t把当前元素t[j - 1]删除，那么dp[i][j] 的数值就是看s[i - 1]与 t[j - 2]的比较结果了，即：dp[i][j] = dp[i][j - 1];
代码
class Solution {
public boolean isSubsequence(String s, String t) {
int m = s.length(), n = t.length();
int[][] dp = new int[m+1][n+1];
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++){
if(s.charAt(i-1) == t.charAt(j-1)) dp[i][j] = dp[i-1][j-1]+1;
else dp[i][j] = dp[i][j-1];//相当于t要删除元素
}
}
return dp[m][n] == m;
}
}
