24暑假算法刷题 | Day44 | 动态规划 XI | 子序列问题 II | LeetCode 1143. 最长公共子序列，53. 最大子数组和，392. 判断子序列

---

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 仅由小写英文字符组成。

题解

动态规划的经典问题。

• dp 数组的含义：

  • 记 text1 的前 i 个字符组成的子串为 $A$
  • 记 text2 的前 j 个字符组成的子串为 $B$

  dp[i][j] 表示 $A$ 和 $B$ 的最长公共子序列长度

• 状态转移方程：

  • 如果 text1[i - 1] == text2[j - 1] ，即当前的 $A$ 和 $B$ 末尾字符相同，则自然可以将其加入之前的公共子序列中，相应的最长公共子序列长度即为 dp[i][j] = dp[i - 1][j - 1] + 1
  • 否则，无法形成更长的公共子序列，继承之前的最大长度： dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])

该算法更详细的讲解参见 代码随想录-1143

代码（C++）

int longestCommonSubsequence(string text1, string text2)
{
    vector<vector<int>> dp(text1.size() + 1, vector<int>(text2.size() + 1, 0));
    for (int i = 1; i <= text1.size(); ++i) {
        for (int j = 1; j <= text2.size(); ++j) {
            if (text1[i - 1] == text2[j - 1]) 
                dp[i][j] = dp[i - 1][j - 1] + 1;
            else
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
        }
    }
    return dp[text1.size()][text2.size()];
}

完事可以接着做 1035. 不相交的线 - 力扣（LeetCode） ，稍微想一下就会发现那题就是个最长公共子序列问题，算法与本题一模一样 🤣 ​

---

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 = [5,4,-1,7,8]
输出：23

提示：

• 1 <= nums.length <= 105
• -104 <= nums[i] <= 104

**进阶： ** 如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。

题解

动态规划

简单的一维动态规划问题。

• dp 数组的含义： dp[i] 表示 nums[0...i] 里的最大子数组和

• 状态转移方程：由于子数组是 连续的 ， dp[i] 显然只由两种状态得来：

  • 将 nums[i] 接在以 nums[i - 1] 为结尾的子数组后面，长度为 dp[i - 1] + 1
  • 自立门户，将 nums[i] 作为新子数组的开头，长度为1

  取最大值，即 dp[i] = max(dp[i - 1] + nums[i], nums[i]) 。

最后，看以哪个元素为结尾的最大子数组和最大即可。

代码（C++）

int maxSubArray(vector<int> &nums)
{
    vector<int> dp(nums.size());
    dp[0] = nums[0];
    for (int i = 1; i < nums.size(); ++i) {
        dp[i] = max(dp[i - 1] + nums[i], nums[i]);
    }
    return *max_element(dp.begin(), dp.end());
}

分治法

上面算法的时间复杂度为 $O(n)$ 。不过，题目的进阶要求提示我们可以用 分治法 ，实现一个更 “有趣” 的算法如下：

🔗 以下内容基本摘自 LeetCode官方题解

这个分治方法类似于「线段树求解最长公共上升子序列问题」的 pushUp 操作。 也许读者还没有接触过线段树，没有关系，方法二的内容假设你没有任何线段树的基础。当然，如果读者有兴趣的话，推荐阅读线段树区间合并法解决多次询问的**「区间最长连续上升序列问题」和「区间最大子段和问题」**，还是非常有趣的。

我们定义一个操作 get(a, l, r) 表示查询 $a$ 序列 $[l,r]$ 区间内的最大子段和，那么最终我们要求的答案就是 get(nums, 0, nums.size() - 1) 。

如何分治实现这个操作呢？对于一个区间 $[l,r]$ ，我们取 $m=\frac{l+r}{2}$ ，对区间 $[l,m]$ 和 $[m+1,r]$ 分治求解。当递归逐层深入直到区间长度缩小为 $1$ 的时候，递归「开始回升」。

这个时候我们考虑如何通过 $[l,m]$ 区间的信息和 $[m+1,r]$ 区间的信息合并成区间 $[l,r]$ 的信息。最关键的两个问题是：

• 我们要维护区间的哪些信息呢？
• 我们如何合并这些信息呢？

对于一个区间 $[l,r]$ ，我们可以维护四个量：

• $lSum$ 表示 $[l,r]$ 内以 $l$ 为左端点的最大子段和
• $rSum$ 表示 $[l,r]$ 内以 $r$ 为右端点的最大子段和
• $mSum$ 表示 $[l,r]$ 内的最大子段和
• $iSum$ 表示 $[l,r]$ 的区间和

以下简称 $[l,m]$ 为 $[l,r]$ 的「左子区间」， $[m+1,r]$ 为 $[l,r]$ 的「右子区间」。我们考虑如何维护这些量呢（如何通过左右子区间的信息合并得到 $[l,r]$ 的信息）？对于长度为 $1$ 的区间 $[i,i]$，四个量的值都和 nums[i] 相等。对于长度大于 $1$ 的区间：

• 首先最好维护的是 $iSum$，区间 $[l,r]$ 的 $iSum$ 就等于「左子区间」的 $iSum$ 加上「右子区间」的 $iSum$。
• 对于 $[l,r]$ 的 $lSum$，存在两种可能，它要么等于「左子区间」的 $lSum$，要么等于「左子区间」的 $iSum$ 加上「右子区间」的 $lSum$，二者取大。
• 对于 $[l,r]$ 的 $rSum$ ，同理，它要么等于「右子区间」的 $rSum$ ，要么等于「右子区间」的 $iSum$ 加上「左子区间」的 $rSum$ ，二者取大。
• 当计算好上面的三个量之后，就很好计算 $[l,r]$ 的 $mSum$ 了。我们可以考虑 $[l,r]$ 的 $mSum$ 对应的区间是否跨越 $m$ ——它可能不跨越 $m$ ，也就是说 $ [l,r]$ 的 $mSum$ 可能是「左子区间」的 $mSum$ 和 「右子区间」的 $mSum$ 中的一个；它也可能跨越 $m$ ，可能是「左子区间」的 $rSum$ 和 「右子区间」的 $lSum$ 求和。三者取大。

这样问题就得到了解决。

代码（C++）

class Solution // 分治法
{
private:
    struct Status {
        int lSum;
        int rSum;
        int mSum;
        int iSum;    
    };

    Status pushUp(Status l, Status r) {
        int iSum = l.iSum + r.iSum;
        int lSum = max(l.lSum, l.iSum + r.lSum);
        int rSum = max(r.rSum, l.rSum + r.iSum);
        int mSum = max(max(l.mSum, r.mSum), l.rSum + r.lSum);
        return Status{lSum, rSum, mSum, iSum};
    }

    Status get(const vector<int>& a, int l, int r) {
        if (l == r)
            return Status{a[l], a[l], a[l], a[l]};

        int m = l + (r - l) / 2;
        Status left = get(a, l, m);
        Status right = get(a, m + 1, r);
        
        return pushUp(left, right);
    }

public:
    int maxSubArray(vector<int> &nums)
    {
        return get(nums, 0, nums.size() - 1).mSum;
    }
};

复杂度分析

假设序列 $a$ 的长度为 $n$ 。

• 时间复杂度：假设我们把递归的过程看作是一颗二叉树的先序遍历，那么这颗二叉树的深度的渐进上界为 $O(logn)$ ，这里的总时间相当于遍历这颗二叉树的所有节点，故总时间的渐进上界是 $O({\sum }_{i=1}^{logn}{2}^{i-1})=O(n)$ ，故渐进时间复杂度为 $O(n)$ 。
• 空间复杂度：递归会使用 $O(logn)$ 的栈空间，故渐进空间复杂度为 $O(logn)$ 。

题外话

「方法二」相较于「方法一」来说，时间复杂度相同，但是因为使用了递归，并且维护了四个信息的结构体，运行的时间略长，空间复杂度也不如方法一优秀，而且难以理解。那么这种方法存在的意义是什么呢？

对于这道题而言，确实是如此的。但是仔细观察「方法二」，它不仅可以解决区间 $[0,n-1]$ ，还可以用于解决任意的子区间 $[l,r]$ 的问题。如果我们把 $[0,n-1]$ 分治下去出现的所有子区间的信息都用堆式存储的方式记忆化下来，即建成一棵真正的树之后，我们就可以在 $O(logn)$ 的时间内求到任意区间内的答案，我们甚至可以修改序列中的值，做一些简单的维护，之后仍然可以在 $O(logn)$ 的时间内求到任意区间内的答案，对于大规模查询的情况下，这种方法的优势便体现了出来。这棵树就是上文提及的一种神奇的数据结构——线段树。

---

392. 判断子序列

点此跳转题目链接

题目描述

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, … , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

致谢：

特别感谢 @pbrother 添加此问题并且创建所有测试用例。

示例 1：

输入：s = "abc", t = "ahbgdc"
输出：true

示例 2：

输入：s = "axc", t = "ahbgdc"
输出：false

提示：

• 0 <= s.length <= 100
• 0 <= t.length <= 10^4
• 两个字符串都只由小写字符组成。

题解

双指针

首先想到的是双指针方法：两个指针分别遍历 s 和 t ，遇到相同的字符就都往前走，否则 t 的指针往前走，以试图找到与当前 s 中字符相同的字符。最后，如果 s 的指针成功走到末尾，说明 s 这个序列在 t 中找到了，即它是 t 的子串。

这应该是最简单且符合直觉的算法了。

代码（C++）

bool isSubsequence(string s, string t) // 双指针
{
    int sp = 0;
    int tp = 0;
    while (sp < s.size() && tp < t.size()) {
        if (s[sp] == t[tp]) 
            sp++;
        tp++;
    }
    return sp == s.size();
}

动态规划

子序列问题

此外，这题其实完全可以套用动态规划子序列问题的算法：如果 s 是 t 的子序列，则 s 和 t 的最长公共子序列长度就是 s 的长度。

bool isSubsequence(string s, string t)
{
    vector<vector<int>> dp(s.size() + 1, vector<int>(t.size() + 1, 0));
    for (int i = 1; i <= s.size(); ++i)
    {
        int k = t.size() - s.size() + i; // 优化搜索范围：t中没检查的字符数量要多于s中的
        for (int j = 1; j <= k; ++j)
        {
            if (s[i - 1] == t[j - 1])
                dp[i][j] = dp[i - 1][j - 1] + 1;
            else
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
        }
    }
    return dp[s.size()][t.size()] == s.size();
}

动态规划预处理+双指针

考虑题目进阶要求中大量重复（数十亿次）判断子序列的情况，即使采用上面算法中较快的双指针法，每次都要进行 $O(n)$ 的计算，不够高效。

可以发现，每次计算花费了大部分时间用于 在 t 中寻找下一个匹配 s 的字符 ，也就是说如果我们可以通过预处理，提前记录 对于 t 的任意位置 i ，从 i 起往后各字符（本题中即26个英文字母）第一次出现的次数 ，那么每次查找匹配字符就变成 $O(1)$ 的操作了 🎉 ​

这个预处理部分就可以用动态规划解决：

• dp 数组的含义： dp[i][j] 表示 t 中从位置 i 开始，下一次出现字符 j （用数字一一对应字符）的位置（包括 i ）
• 状态转移方程：
  • 如果 t[i] 对应的就是字符 j ，那么目标位置就是 i ： dp[i][j] = i
  • 否则，要在 i 后面去找，即： dp[i][j] = dp[i + 1][j] （由此看出，要逆序构建 dp ）

代码上，为了方便，可以将 dp[t.size()][...] 全部初始化为 t.size() ，表示已经找到末尾、不会再出现目标字符了。

代码（C++）

bool isSubsequence(string s, string t) // DP预处理+双指针
{
    // 预处理
    vector<vector<int>> dp(t.size() + 1, vector<int>(26, t.size()));
    for (int i = t.size() - 1; i >= 0; --i) {
        int charNum = t[i] - 'a';
        for (int j = 0; j < 26; ++j) 
            dp[i][j] = charNum == j ? i : dp[i + 1][j];
    }

    // 双指针匹配
    int sp = 0;
    int tp = 0;
    while (sp < s.size() && tp < t.size()) {
        tp = dp[tp][s[sp] - 'a']; // 利用预处理结果
        if (s[sp] == t[tp]) 
            sp++, tp++;
    }

    return sp == s.size();
}