最长公共子串与最长公共子序列问题

TOC

最长公共子串

动态规划解决
注意这题求的是最长公共子串，不是最长公共子序列，子序列可以是不连续的，但子串一定是连续的。

定义dp[i][j]表示字符串str1中第i个字符和str2种第j个字符为最后一个元素所构成的最长公共子串。如果要求dp[i][j]，也就是str1的第i个字符和str2的第j个字符为最后一个元素所构成的最长公共子串，我们首先需要判断这两个字符是否相等。

如果不相等，那么他们就不能构成公共子串，也就是
dp[i][j]=0;

如果相等，我们还需要计算前面相等字符的个数，其实就是dp[i-1][j-1]，所以
dp[i][j]=dp[i-1][j-1]+1;

import java.util.*;


public class Solution {
    /**
     * longest common substring
     * @param str1 string字符串 the string
     * @param str2 string字符串 the string
     * @return string字符串
     */
    public String LCS (String str1, String str2) {
        // write code here
        int n = str1.length();
        int m = str2.length();
        int[][] dp = new int[n+1][m+1];
        int maxlen = 0,index = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(str1.charAt(i) == str2.charAt(j)){
                    dp[i+1][j+1] = dp[i][j] + 1;
                    if(dp[i+1][j+1] > maxlen){
                        maxlen = dp[i+1][j+1];
                        index = i;
                    }
                }else{
                    dp[i+1][j+1] = 0;
                }
            }
        }
        return str1.substring(index-maxlen+1,index+1);
    }
}

最长公共子序列

集合表示：f[i][j]f[i][j]表示a的前i个字母，和b的前j个字母的最长公共子序列长度

集合划分：以a[i]a[i],b[j]b[j]是否包含在子序列当中为依据，因此可以分成四类：

①a[i]a[i]不在，b[j]b[j]不在

max=f[i−1][j−1]max=f[i−1][j−1]
②a[i]a[i]不在，b[j]b[j]在

看似是max=f[i−1][j]max=f[i−1][j] , 实际上无法用f[i−1][j]f[i−1][j]表示，因为f[i−1][j]f[i−1][j]表示的是在a的前i-1个字母中出现，并且在b的前j个字母中出现,此时b[j]b[j]不一定出现，这与条件不完全相等，条件给定是a[i]a[i]一定不在子序列中，b[j]b[j]一定在子序列当中，但仍可以用f[i−1][j]f[i−1][j]来表示，原因就在于条件给定的情况被包含在f[i−1][j]f[i−1][j]中，即条件的情况是f[i−1][j]f[i−1][j]的子集，而求的是max，所以对结果不影响。

例如：要求a，b，c的最大值可以这样求：max(max(a,b),max(b,c))max(max(a,b),max(b,c))虽然b被重复使用，但仍能求出max，求max只要保证不漏即可。

③a[i]a[i]在，b[j]b[j]不在 原理同②

④a[i]a[i]在，b[j]b[j]在 max=f[i−1][j−1]+1max=f[i−1][j−1]+1;

实际上，在计算时，①包含在②和③的情况中，所以①不用考虑

leetcode 1143

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

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

例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。
推荐网站：https://alchemist-al.com/algorithms/longest-common-subsequence
体验一下流程就会了

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
            int m = text1.length(), n = text2.length();
            int[][] dp = new int[m+1][n+1];
            for(int i = 1; i <= m; i++){
                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][j-1],dp[i-1][j]);
                    }
                }
            }
            return dp[m][n];
    }
}

ACW1222. 密码脱落

X星球的考古学家发现了一批古代留下来的密码。

这些密码是由A、B、C、D 四种植物的种子串成的序列。

仔细分析发现，这些密码串当初应该是前后对称的（也就是我们说的镜像串）。

由于年代久远，其中许多种子脱落了，因而可能会失去镜像的特征。

你的任务是：

给定一个现在看到的密码串，计算一下从当初的状态，它要至少脱落多少个种子，才可能会变成现在的样子。

输入格式
共一行，包含一个由大写字母ABCD构成的字符串，表示现在看到的密码串。

输出格式
输出一个整数，表示至少脱落了多少个种子。

数据范围
输入字符串长度不超过1000

输入样例1：
ABCBA
输出样例1：
0
输入样例2：
ABDCDCBABC
输出样例2：
3

分析这道题其实就是算原字符串的长度-最大回文子串的长度.因为两个数字肯定是关于轴对称的，输入样例是脱落后的字符串，但是不用还原直接在这个字符串里找最大回文子串就是了。
那么怎么找最大回文子串了
可以利用最长公共子序列来解这道题，将正序的字符串与逆序的字符串求一下最长公共子序列即可。

上代码：

//总长度减去最长回文串的长度
import java.util.*;
import java.io.*;
class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
        String s1 = read.readLine();
        String s2 = new StringBuilder(s1).reverse().toString();
        System.out.println(s1.length()-find(s1,s2));
    }
    public static int find(String s1,String s2){
        int n = s1.length();
        int[][] dp = new int[n+1][n+1];
        for(int i = 1; i <= n; i++){
            char a = s1.charAt(i-1);
            for(int j = 1; j <= n; j++){
                char b = s2.charAt(j-1);
                if(a==b){
                    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[n][n];
    }
}