5.23算法练习最长公共子序列

Posted 2021-06-04 在路上的德尔菲

题目

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

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

例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例

输入：text1 = “abcde”, text2 = “ace”
输出：3
解释：最长公共子序列是 “ace” ，它的长度为 3 。

输入：text1 = “abc”, text2 = “abc”
输出：3
解释：最长公共子序列是 “abc” ，它的长度为 3 。

解题

采用动态规划思想，如果字符串1第i位和字符串2上第j位的字符相同，那么取[i,j]左上边位置的值然后加1得到此位置的结果，否则取[i,j]相邻左边和上边位置值的最大值。如何理解呢？举个🌰
当比较“ac”和“abc” 当c相同时，相当于在子串“a” 和“ab”公共子序列结果上加1，所以最后的结果应该取表格右下角的值。
伪代码如下

if(text1[i] == text2[j]){
	dp[i][j] = dp[i-1][j-1] + 1;
}else{
	dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
}

根据伪代码我们能绘制出下面这样的表格

	a	b	c	d	e
a	1	1	1	1	1
c	1	1	2	2	2
e	1	1	2	2	3

我写的代码

    public static int longestCommonSubsequence(String text1, String text2) {
        char[] text1Array = text1.toCharArray();
        char[] text2Array = text2.toCharArray();
        int length1 = text1Array.length;
        int length2 = text2Array.length;
        if (length1 == 0 || length2 == 0) return 0;
        int[][] matrix = new int[length1][length2];
        for (int i = 0; i < length1; i++) {
            for (int j = 0; j < length2; j++) {
                if (text1Array[i] == text2Array[j]) {
                	//考虑首行首列越界问题
                    if (i - 1 < 0 || j - 1 < 0) {
                        matrix[i][j] = 1;
                    } else {
                        matrix[i][j] = matrix[i - 1][j - 1] + 1;
                    }
                } else {
                	//考虑首行首列越界问题
                    if (i - 1 < 0 && j - 1 < 0) {
                        matrix[i][j] = 0;
                    } else if (i - 1 < 0) {
                        matrix[i][j] = matrix[i][j - 1];
                    } else if (j - 1 < 0) {
                        matrix[i][j] = matrix[i - 1][j];
                    } else {
                        matrix[i][j] = Math.max(matrix[i][j - 1], matrix[i - 1][j]);

                    }
                }
            }
        }
        return matrix[length1 - 1][length2 - 1];
    }

参考力扣上高票答案，思想是一样的，但是代码写的简单明了多了

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length(), n = text2.length();
        //设一个[m+1][n+1]大小的矩阵，首行首列都是为0，不用考虑越界问题
        int[][] dp = new int[m + 1][n + 1];
        //循环范围为[1,m]
        for (int i = 1; i <= m; i++) {
        	//不用在内层循环中每次再取第i-1的值
        	//直接用String.charAt(index)来取某位的字符，免去转为字符数组步骤，减少内存消费
            char c1 = text1.charAt(i - 1);
            for (int j = 1; j <= n; j++) {
                char c2 = text2.charAt(j - 1);
                if (c1 == c2) {
                    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[m][n];
    }
}

小结

用《算法图解》里关于动态规划的总结结束今天的练习。

• 需要在给定约束条件下优化某种指标，动态规划很有用
• 问题可分解为离散子问题时，可使用动态规划来解决。
• 每种动态规划解决方案都涉及网格。
• 单元格中都是一个子问题，因此你需要考虑如何将问题分解为子问题。
• 没有放之四海皆准的计算动态规划解决方案公式。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-common-subsequence
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。