最长公共子序列-LeetCode1143

题目：
给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列。
一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。
若这两个字符串没有公共子序列，则返回 0。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-common-subsequence
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
输入：text1 = “abcde”, text2 = “ace”
输出：3
解释：最长公共子序列是 “ace”，它的长度为 3。

暴力算法，常规思路
从样例输入输出入手，输入两个字符串：abcde/ace。
按照字符串角标走的话，从左往右，角标同时想有移动，遇到相同字符则最长公共子序列+1。
两个字符串角标分别是i,j，如果i=0,j=0，那么我们可以知道s1[0]=s2[0],这时公共最长子序列有了字母a,那么剩下需要判断的则是 bcde 和 ce的公共最长子序列。
让i,j同时+1明显是不行的。
肉眼可以看到在剩下要判断的字符串中 s[2]是"c" s[1]是"c"。
也就是如果让i=i+1, j=j 是可以顺利找到下一个相同字符的。可是我们计算机不知道。
假象另一种情况，如果两个字符串是acbde afce，那么 i=i, j=j+1就能让我们找到下一个相同字符。
所以这里要同时计算 i=i, j=j+1 和 i=i+1, j=j 看哪种情况最终返回的长度大。
图解为

在这里插入图片描述
明显，这种算法效率为O(2^N)
下面是编码：

import static java.lang.Math.max;
public class LeetCode1143 {
    public static  int dp(String text1,String text2,int maxlen){
        if(text1.charAt(0) == text2.charAt(0)){

            String ttext1 = text1.substring(1,text1.length());
            String ttext2= text2.substring(1,text2.length());
            maxlen = maxlen + 1;
            if(ttext1.length()>0 && ttext2.length()>0) {
                return dp(ttext1, ttext2, maxlen);
            }
        }

        else{

            if(text1.length()>0 && text2.length()>0) {

                String ttext1 = text1.substring( 1, text1.length());
                String ttext2 = text2.substring(0, text2.length());

                String ttext11 = text1.substring(0, text1.length());
                String ttext22 = text2.substring(1, text2.length());


                if(ttext1.length() == 0  && ttext22.length()>0){
                    return dp(ttext11, ttext22, maxlen);
                }
                if(ttext22.length() == 0 && ttext1.length() > 0 ){
                    return dp(ttext1, ttext2, maxlen);
                }
                if(ttext22.length() > 0 && ttext1.length() > 0) {
                    return max(dp(ttext11, ttext22, maxlen), dp(ttext1, ttext2, maxlen));
                }
            }
        }

        return maxlen;
    }

    public static  int longestCommonSubsequence(String text1, String text2) {
        int a = dp(text1,text2,0);
        return a;
    }

    public static void main(String[] args){

//        String s1 = "abcde";
////        String s2 = "ace";

        String s1 = "pmjghexybyrgzczy";
        String s2 ="hafcdqbgncrcbihkd";
        int a = longestCommonSubsequence(s1,s2);
        System.out.println(a);
    }

}

以上代码是可以找到正确答案的，但是由于是深度搜索的思路，效率非常差，提交后会显示超时。

以上为从左向右深度搜索所有情况，当找到两个相同的字符时，最大长度+1，然后继续向后按照各种情况查找。

优化后的算法，使用动态规划提高效率
上述算法的缺点是，使用了深度优先搜索的思想，将所有查找方式都遍历一遍才找到最大长度。
当找到两个相同字符的时候，让相同字符前的最大长度+1。
例如：
abcde
ace
当我找到c=c的时候，那么最大长度应该是ab 与 a的最大子序列长度+1。
再例如，当我找到e=e的时候，那么最大长度应该是abcd 与 ac的最大子序列长度+1。

也就有了这样的模型。
有一个数组dp[][]

dp[i][j] 表示 s1的0～i 与s2的0～j 两个子串的最长公共子序列。

那么当 s[i]=s[j]的时候 dp[i][j]=dp[i-1][j-1]+1
当 s[i]<>s[j]的时候，那么dp[i][j]的值若想要代表当天位置的最长子序列，我们把角标各自往前推一步，取较大的值。
dp[i][j]=max(dp[i-1][j],dp[i][j-1])

在这里插入图片描述

代码实现：

package com.jinsong.leetcode;

public class LeetCode1143_ac {
    public static  int longestCommonSubsequence(String text1, String text2) {

        int[][] dp = new int[text1.length()+1][text2.length()+1];

        //表示text1[0~i] text2[0~j]的最大子序列长度

        for(int i = 0 ;i<text1.length()+1;i++){
            dp[i][0]=0;

        }
        for(int i = 0 ;i<text2.length()+1;i++){
            dp[0][i]=0;

        }


        for(int i=0;i<text1.length();i++){

            for(int j=0;j<text2.length();j++){

                if(text1.charAt(i)==text2.charAt(j)){
                    dp[i+1][j+1]=dp[i][j]+1;
                }
                else{
                    dp[i+1][j+1]=java.lang.Math.max(dp[i][j+1],dp[i+1][j]);
                }

            }

        }
        return dp[text1.length()][text2.length()];

    }

    public static void main(String[] args){

        String s1 = "pmjghexybyrgzczy";
        String s2 = "hafcdqbgncrcbihkd";
        int a = longestCommonSubsequence(s1,s2);
        System.out.println(a);
    }
}

来源：CSDN

作者：EnterPine

链接：https://blog.csdn.net/EnterPine/article/details/103476203

标签

string

最长公共子序列