【算法 - 动态规划】最长公共子序列问题

强连通子图

已于 2024-02-20 22:06:54 修改

阅读量1k

点赞数 32

分类专栏：动态规划—从0到1 文章标签：算法动态规划 leetcode 数据结构 java

于 2024-02-20 21:54:37 首次发布

本文链接：https://blog.csdn.net/weixin_46879314/article/details/136199488

版权

动态规划—从0到1 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

在上两篇文章中，我们将 暴力递归 逐步修改成为 动态规划 ，并介绍了有严格 dp表依赖 和无表依赖结构的解题方法。其中，前篇文章中的纸牌博弈问题属于 [L , R]上范围尝试模型。该模型给定一个范围，在该范围上进行尝试，套路就是 思考 [L ,R] 两端该如何取舍。

本篇文章我们学习一个新的模型： 样本对应模型，该模型的套路就是 以结尾位置为出发点，思考两个样本的结尾都会产生哪些可能性 。

力扣1143：最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共子序列，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

两个字符串的公共子序列是这两个字符串所共同拥有的子序列。

示例 1：

输入: text1 = “abcde”, text2 = “ace”

*输出：*3

*解释：*最长公共子序列是 “ace” ，它的长度为 3 。

示例 2:

*输入：*text1 = “abc”, text2 = “def”

*输出：*0

*解释：*两个字符串没有公共子序列，返回 0 。

首先我们依然采用最朴素的 暴力递归 来思考这道题目。

递归的准备

定义递归函数的功能： 返回 str1 中 [0...i] ，str2 中 [0...j] 范围上两个字符串的最长公共子序列。

思考递归需要的参数： str1, str2 两个字符串，分别要比较的范围 i, j。

明确递归的边界条件： 当两个字符串长度均为 1 时：若两个字符相同返回 1 ，不同返回 0 。

思路

这道题就是典型的 样本对应模型 ，因此，递归就可以按照 两个样本的结尾都会产生哪些可能性 的思路来划分情况：

公共子序列 既不以 str1 结尾，也不以 str2 结尾；
公共子序列以 str1 结尾，不以 str2 结尾；
公共子序列不以 str1 结尾，以 str2 结尾；
公共子序列既以 str1 结尾，也以 str2 结尾。

因为要求最长子序列，因此要返回这四种情况当中的最大值。

代码

public static int longestCommonSubsequence(String s1, String s2) {
    if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0) {
        return 0;
    }
    char[] str1 = s1.toCharArray();
    char[] str2 = s2.toCharArray();
    return process(str1, str2, str1.length - 1, str2.length - 1);
}

public static int process(char[] str1, char[] str2, int i, int j) {
    if (i == 0 && j == 0) {
        return str1[i] == str2[j] ? 1 : 0;
    } else if (i == 0) {
        return str1[i] == str2[j] ? 1 : process(str1, str2, i, j - 1);
    } else if (j == 0) {
        return str1[i] == str2[j] ? 1 : process(str1, str2, i - 1, j);
    } else {
        int p1 = process(str1, str2, i - 1, j - 1);
        int p2 = process(str1, str2, i, j - 1);
        int p3 = process(str1, str2, i - 1, j);
        int p4 = str1[i] == str2[j] ? 1 + process(str1, str2, i - 1, j - 1) : 0;
        return Math.max(Math.max(p1, p2), Math.max(p3, p4));
    }
}

代码解释

因为递归调用中使用到了 i-1 , j-1，因此需要做边界处理。例如：当str1 中只剩下一个字符时，若与 str2 最后一个字符相等即找到了此时最长子序列，否则排除掉 str2 的最后一个字符继续递归寻找。

写出该暴力版的递归之后发现，最终要求的是最大值，因此其实 p1 的情况是一定不会比 p2 ，p3 的情况返回值要大，所以可以减少一次递归的调用，做个小小的优化。

动态规划版

public static int longestCommonSubsequence(String s1, String s2) {
    if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0) {
        return 0;
    }
    char[] str1 = s1.toCharArray();
    char[] str2 = s2.toCharArray();
    int N = str1.length;
    int M = str2.length;
    int[][] dp = new int[N][M];
    // 处理 str1 和 str2 均剩下一个字符的情况
    dp[0][0] = 1;
    // 处理 str1 剩下一个字符的情况 
    for (int j = 1; j < M; j++) {
        dp[0][j] = str1[0] == str2[j] ? 1 : dp[0][j - 1];
    }
    // 处理 str2 剩下一个字符的情况 
    for (int i = 1; i < N; i++) {
        dp[i][0] = str1[i] == str2[0] ? 1 : dp[i - 1][0];
    }
    // str1 str2 均有多个字符的情况
    for (int i = 1; i < N; i++) {
        for (int j = 1; j < M; j++) {
            int p1 = dp[i][j - 1];
            int p2 = dp[i - 1][j];
            int p3 = str1[i] == str2[j] ? 1 + dp[i - 1][j - 1] : 0;
            dp[i][j] = Math.max(Math.max(p1, p2), p3);
        }
    }
    return dp[N - 1][M - 1];
}