【1092. 最短公共超序列】

最新推荐文章于 2024-02-10 17:00:00 发布

千北@

最新推荐文章于 2024-02-10 17:00:00 发布

阅读量376

点赞数

分类专栏： LeetCode 文章标签：算法动态规划 leetcode C++ 数据结构

本文链接：https://blog.csdn.net/Sugar_wolf/article/details/129812021

版权

LeetCode 专栏收录该内容

397 篇文章 2 订阅

订阅专栏

该问题是一个编程挑战，涉及动态规划算法来解决。给定两个字符串str1和str2，目标是找到一个最短的字符串，这个字符串同时包含str1和str2作为子序列。动态规划的状态定义为dp[i][j]，表示str1[i:]和str2[j:]的最短公共超序列的长度。通过比较字符和选择最优路径，最终构造出结果字符串。

摘要由CSDN通过智能技术生成

来源：力扣（LeetCode）

描述：

给出两个字符串 str1 和 str2，返回同时以 str1 和 str2 作为子序列的最短字符串。如果答案不止一个，则可以返回满足条件的任意一个答案。

（如果从字符串 T 中删除一些字符（也可能不删除，并且选出的这些字符可以位于 T 中的 任意位置），可以得到字符串 S，那么 S 就是 T 的子序列）

示例：

输入：str1 = "abac", str2 = "cab"
输出："cabac"
解释：
str1 = "abac" 是 "cabac" 的一个子串，因为我们可以删去 "cabac" 的第一个 "c"得到 "abac"。 
str2 = "cab" 是 "cabac" 的一个子串，因为我们可以删去 "cabac" 末尾的 "ac" 得到 "cab"。
最终我们给出的答案是满足上述属性的最短字符串。

提示：

1 <= str1.length, str2.length <= 1000
str1 和 str2 都由小写英文字母组成。

方法：动态规划

思路与算法

首先题目给出两个字符串 str₁ 和 str₂ ，我们需要返回任意一个满足同时以 str₁ 和 str₂ 作为子序列的最短字符串。我们设 str₁ 的长度为 n，str₂ 的长度为 m, dp[i][j] 表示同时以字符串 str₁[i:n] 和 str₂[j:m] 作为子序列的最短字符串长度，其中 str₁[i:j]，str₂[i : j] 表示字符串 str₁，str₂ 从下标 i 到下标 j 的子串（包含下标 i 且不包含下标 j）。现在我们来思考如何求解各个状态：

当 str₁[i] = str₂[j]时，以 str₁[i : n] 和 str₂[j : m] 作为子序列的最短字符串的开头字符为 str₁ [i] 一定是最优的：

dp[i][j] = dp[i + 1][j+ 1] + 1

否则当 str₁[i] ≠ str₂[j] 时，以 str₁[i : n] 和 str₂[j : m] 作为子序列的最短字符串的开头字符只能为 str₁[i] 或者 str₂[j]：

dp[i][j] = min{dp[i + 1][j], dp[i][j + 1]} + 1

上文讨论的是建立在 i < n 和 j < m 的前提上的，我们还需要考虑动态规划的边界条件，当 i = n 或 j = m 时，此时其中一个字符串为空串，同时满足以两字符串作为子序列的最短字符串长度为另一个字符串的长度。因此我们就可以写出动态规划的边界条件：

可以看到每一个区间上的求解都与其子区间的求解有关，所以我们可以采用「自底向上」的编码方式来实现求解过程。求解完毕后，此时 dp[0][0] 即为此时题目中满足同时以 str₁ 和 str₂ 作为子序列的最短字符串长度，然后我们可以通过双指针和通过动态规划状态来从前往后构造出具体方案。我们用指针 t₁ = 0 来指向 str₁ 的头部，用 t₂ = 0 来指向 str₂ 的头部，并根据 dp[i][j] 来从前往后构造出具体字符串方案：

若 t₁ 到达 str₁ 尾部（t₁ = n）或者 t₂ 到达 str₂ 尾部（t₂ = m），将对应的剩下的字符加到结果字符串后面。
否则：
- 若 str₁[t₁] = str₂[t₂]，则此时结果字符串最后添加 str₁[t₁] 为最优条件，然后 t₁
  和 t₂ 指针分别往后移动一单位。
- 否则若当

向结果字符串中添加 str₁ [t₁]，然后 t₁ 指针往后移动一单位。若当

则向结果字符串中添加 str₂[t₂]，然后 t₂ 指针往后移动一单位。由于我们只需要返回任一符合条件的结果字符串，所以若条件 (1)(2) 都满足我们只需要取其中一种情况即可。

代码：

class Solution {
public:
    string shortestCommonSupersequence(string str1, string str2) {
        int n = str1.size(), m = str2.size();
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));
        for (int i = 0; i < n; ++i) {
            dp[i][m] = n - i;
        }
        for (int i = 0; i < m; ++i) {
            dp[n][i] = m - i;
        }
        for (int i = n - 1; i >= 0; --i) {
            for (int j = m - 1; j >= 0; --j) {
                if (str1[i] == str2[j]) {
                    dp[i][j] = dp[i + 1][j + 1] + 1;
                } else {
                    dp[i][j] = min(dp[i + 1][j], dp[i][j + 1]) + 1;
                }
            }
        }
        string res;
        int t1 = 0, t2 = 0;
        while (t1 < n && t2 < m) {
            if (str1[t1] == str2[t2]) {
                res += str1[t1];
                ++t1;
                ++t2;
            } else if (dp[t1 + 1][t2] == dp[t1][t2] - 1) {
                res += str1[t1];
                ++t1;
            } else if (dp[t1][t2 + 1] == dp[t1][t2] - 1) {
                res += str2[t2];
                ++t2;
            }
        }
        if (t1 < n) {
            res += str1.substr(t1);
        }
        else if (t2 < m) {
            res += str2.substr(t2);
        }
        return res;
    }
};

执行用时：20 ms, 在所有 C++ 提交中击败了75.29%的用户
内存消耗：12.5 MB, 在所有 C++ 提交中击败了80.59%的用户
复杂度分析
时间复杂度：O(n×m)。其中预处理动态规划求解的复杂度为 O(n×m)，构造具体字符串方案的复杂度为 O(n+m)，其中 n 为字符串 str₁ 的长度，m 为字符串 str₂ 的长度。
空间复杂度：O(n×m)，其中 n 为字符串 str₁ 的长度，m 为字符串 str₂ 的长度。空间复杂度主要取决于动态规划模型中状态的总数。
author：LeetCode-Solution