动态规划——最长子序列、子串问题

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 不相交的线

1035. 不相交的线

在两条独立的水平线上按给定的顺序写下 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 最长重复子数组

718. 最长重复子数组

给两个整数数组 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 最大子序和

53. 最大子序和

给定一个整数数组 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;
}