动态规划——最长(连续)子序列问题
1. 概述
其实本问题有两大类,一类是要求连续的(子串),一类是要求不连续的(子序列)。可能有些同学对子串和子序列的定义还不太清晰,那我们就先来巩固下基础概念:
已知原数组为
[1, 2, 4, 3, 7, 6, 5]
,则:
[1, 2, 4]
为原数组的子串,三个元素收尾相连,中间没有别的元素;[1, 3, 5]
为子序列,各个元素之间可能隔着别的元素。
在动态规划中,一般 dp 数组的定义如下:
- 一维数组,动规数组定义为
dp[i]
- 如果是子系列,表示子系列在 [0, i] 范围内如何如何;
- 如果是子串/子数组,则表示为以 i 结尾的字串或子数组如何如何。
- 二维数组,动规数组定义为
dp[i][j]
- 如果是求子序列,
dp[i][j]
含义为 [0, i-1]、[0, j - 1] 范围内如何如何; - 如果是求子串,
dp[i][j]
含义为 以 i - 1 结尾、以 j - 1 结尾的子串或者子数组如何如何。
- 如果是求子序列,
2. 子序列问题(不要求连续)
2.1 最长递增子序列
题目链接:300 最长递增子序列
给你一个整数数组 nums ,找到其中最长严格递增子序列的长度。
子序列是由数组派生而来的序列,删除(或不删除)数组中的元素而不改变其余元素的顺序。例如,[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。
示例 1:
输入:nums = [10,9,2,5,3,7,101,18]
输出:4
解释:最长递增子序列是 [2,3,7,101],因此长度为 4 。
示例 2:
输入:nums = [0,1,0,3,2,3]
输出:4
示例 3:
输入:nums = [7,7,7,7,7,7,7]
输出:1
提示:
1 <= nums.length <= 2500
-104 <= nums[i] <= 104
进阶:
你可以设计时间复杂度为 O(n2) 的解决方案吗?
你能将算法的时间复杂度降低到 O(n log(n)) 吗?
public int lengthOfLIS(int[] nums) {
if (nums == null || nums.length == 0) return 0;
int length = nums.length;
// dp[i] 以i结尾的最长递增子序列的长度为dp[i]
int[] dp = new int[length];
int res = 1;
Arrays.fill(dp, 1);
for (int i = 1; i < length; i++) {
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) {
dp[i] = Math.max( dp[i], dp[j] + 1);
res = Math.max(res, dp[i]);
}
}
}
return res;
}
2.2 最长公共子序列
题目链接:1143. 最长公共子序列
给定两个字符串 text1 和 text2,返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ,返回 0 。
一个字符串的 子序列 是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符)后组成的新字符串。
例如,“ace” 是 “abcde” 的子序列,但 “aec” 不是 “abcde” 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。
示例 1:
输入:text1 = “abcde”, text2 = “ace”
输出:3
解释:最长公共子序列是 “ace” ,它的长度为 3 。
示例 2:
输入:text1 = “abc”, text2 = “abc”
输出:3
解释:最长公共子序列是 “abc” ,它的长度为 3 。
示例 3:
输入:text1 = “abc”, text2 = “def”
输出:0
解释:两个字符串没有公共子序列,返回 0 。
提示:
1 <= text1.length, text2.length <= 1000
text1 和 text2 仅由小写英文字符组成。
public int longestCommonSubsequence(String text1, String text2) {
if (text1 == null || text2 == null || text1.length() == 0 || text2.length() == 0) return 0;
int length1 = text1.length();
int length2 = text2.length();
char[] char1 = text1.toCharArray();
char[] char2 = text2.toCharArray();
// dp[i][j] text1[0, i - 1] 与 text2[0, j - 1]所形成的最长公共子序列的长度为dp[i][j]
int[][] dp = new int[length1 + 1][length2 + 1];
// 初始化 dp[0][j] text1的子串为空,dp[i][0] text2的子串为空 所以 dp[0][j] = 0, dp[i][0] = 0
for (int i = 1; i <= length1; i++) {
for (int j = 1; j <= length2; j++) {
if (char1[i - 1] == char2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
return dp[length1][length2];
}
2.3 不相交的线
在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。
现在,可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线,这些直线需要同时满足满足:
- nums1[i] == nums2[j]
- 且绘制的直线不与任何其他连线(非水平线)相交。
请注意,连线即使在端点也不能相交:每个数字只能属于一条连线。
以这种方法绘制线条,并返回可以绘制的最大连线数。
示例 1:
输入:nums1 = [1,4,2], nums2 = [1,2,4]
输出:2
解释:可以画出两条不交叉的线,如上图所示。
但无法画出第三条不相交的直线,因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从 nums1[2]=2 到 nums2[1]=2 的直线相交。
示例 2:
输入:nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]
输出:3
示例 3:
输入:nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
输出:2
提示:
1 <= nums1.length <= 500
1 <= nums2.length <= 500
1 <= nums1[i], nums2[i] <= 2000
public int maxUncrossedLines(int[] nums1, int[] nums2) {
if (nums1 == null || nums2 == null || nums1.length == 0 || nums2.length == 0) return 0;
int length1 = nums1.length;
int length2 = nums2.length;
// dp[i][j] nums1[0, i - 1] 与 nums2[0, j - 1] 所形成的最长公共子序列的长度
int[][] dp = new int[length1 + 1][length2 + 1];
// 初始化 dp[0][j] = 0, dp[i][0] = 0
for (int i = 1; i <= length1; i++) {
for (int j = 1; j <= length2; 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 - 1][j], dp[i][j - 1]);
}
}
}
return dp[length1][length2];
}
3. 子串/子数组问题
子串/子数组只能从 dp[i - 1]
或者 dp[i - 1][j - 1]
推到而来!!!
3.1 最长连续递增序列
题目链接:674. 最长连续递增序列
给定一个未经排序的整数数组,找到最长且连续递增的子序列,并返回该序列的长度。
连续递增的子序列 可以由两个下标 l 和 r(l < r)确定,如果对于每个 l <= i < r,都有 nums[i] < nums[i + 1] ,那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。
示例 1:
输入:nums = [1,3,5,4,7]
输出:3
解释:最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的,因为 5 和 7 在原数组里被 4 隔开。
示例 2:
输入:nums = [2,2,2,2,2]
输出:1
解释:最长连续递增序列是 [2], 长度为1。
提示:
1 <= nums.length <= 104
-109 <= nums[i] <= 109
public int findLengthOfLCIS(int[] nums) {
if (nums == null || nums.length == 0) return 0;
int length = nums.length;
// dp[i] 表示以i结尾的连续递增子序列的长度
int[] dp = new int[length];
Arrays.fill(dp, 1);
// 虽然我们定义为以i结尾,但是最终的结果不一定是以数组的最后一位结尾,而是需要在遍历的过程中找寻最大值
int res = 1;
for (int i = 1; i < length; i++) {
if (nums[i] > nums[i - 1]) {
dp[i] = dp[i - 1] + 1;
res = Math.max(res, dp[i]);
}
}
return res;
}
3.2 最长重复子数组
给两个整数数组 A 和 B ,返回两个数组中公共的、长度最长的子数组的长度。
示例:
输入:
A: [1,2,3,2,1]
B: [3,2,1,4,7]
输出:3
解释:
长度最长的公共子数组是 [3, 2, 1] 。
提示:
1 <= len(A), len(B) <= 1000
0 <= A[i], B[i] < 100
public int findLength(int[] nums1, int[] nums2) {
if (nums1 == null || nums2 == null || nums1.length == 0 || nums2.length == 0) return 0;
int length1 = nums1.length;
int length2 = nums2.length;
// dp[i][j] 以 nums1[i - 1] 结尾的 nums1 与 以 nums2[j - 1] 结尾的 nums2 形成的最长重复子数组的长度为 dp[i][j]
int[][] dp = new int[length1 + 1][length2 + 1];
// 初始化 根据定义 dp[0][j] 表示 nums1 的空串与 nums2[0, j - 1] 形成的最长重复子串,可知 dp[0][j] = 0;同理,dp[i][0] = 0
int res = 0;
for (int i = 1; i <= length1; i++) {
for (int j = 1; j <= length2; j++) {
if (nums1[i - 1] == nums2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
res = Math.max(res, dp[i][j]);
}
}
}
return res;
}
3.3 最大子序和
给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
示例 1:
输入:nums = [-2,1,-3,4,-1,2,1,-5,4]
输出:6
解释:连续子数组 [4,-1,2,1] 的和最大,为 6 。
示例 2:
输入:nums = [1]
输出:1
示例 3:
输入:nums = [0]
输出:0
示例 4:
输入:nums = [-1]
输出:-1
示例 5:
输入:nums = [-100000]
输出:-100000
提示:
1 <= nums.length <= 105
-104 <= nums[i] <= 104
进阶: 如果你已经实现复杂度为 O(n) 的解法,尝试使用更为精妙的 分治法 求解。
public int maxSubArray(int[] nums) {
int length = nums.length;
if (length == 1) return nums[0];
// dp[i] 表示以第i-1结尾的数组的最大子序和
int[] dp = new int[length + 1];
dp[0] = 0;
int res = Integer.MIN_VALUE;
for (int i = 1; i <= length; i++) {
dp[i] = Math.max(dp[i - 1] + nums[i - 1], nums[i - 1]);
res = Math.max(res, dp[i]);
}
return res;
}