最长公共子序列

原创

---

动态规划解最长公共子序列问题

设序列一的序列为：Ai（1<=i<=n）

序列二的序列为：Bj（1<=j<=m）

最长公共子序列为：Ck（1<=k<=z）

能用动态规划解的题目都是可以将原规模的题分解成子问题规模，公共子序列问题可以这样分解：

如果存在An==Bm==Cz，则Ai（1<=i<=n-1）和Bj（1<=j<=m-1）的最长公共子序列为：Ck（1<=k<=z-1）

如果存在An！=Bm，且An！=Cz，则Ai（1<=i<=n-1）和Bj（1<=j<=m）的最长公共子序列为：Ck（1<=k<=z）

如果存在An!=Bm，且Bm！=Cz，则Ai（1<=i<=n）和Bj（1<=j<=m-1）的最长公共子序列为：Ck（1<=k<=z）

利用上述的关系式我们自顶向下的求最长公共子序列长度。

设数组F[ i ][ j ]表示序列一的长度为i，序列二的长度为j时的最长公共子序列长度，显而易见，当i==0或者j==0时，

即存在其中一个序列没有元素时，F[i][j]都是0，然后利用上述的关系式可以继续往下求。

当A[i]==B[j]时，F[i][j]=F[i-1][j-1]

当A[i-1]！=B[j]时，max{ F[i][j-1]，F[i-1][j] }

上面为什么要选出一个最大的呢？

假如是An！=Bm，且An！=Cz这种情况，我们可以知道应该铲除Ai的最后一个元素An，公共子序列长度和原规模

问题的公共子序列长度是相同的，但是如果铲除了Bm，则公共子序列长度肯定会小于等于原规模的公共子序列长度。

为什么会小于等于自己理解了！

import java.util.Scanner;

public class 算法分析与设计3_1 {
    
    static void LCS(int m,int n,int A[],int b[][]){
        if(m==0 || n==0)return;
        if(b[m][n]==1){
            LCS(m-1,n-1,A,b);
            System.out.print(A[m]+" ");
        }else if(b[m][n]==2){
            LCS(m-1,n,A,b);
        }else{
            LCS(m,n-1,A,b);
        }
    }

    static void LCSLength(int A[],int B[],int C[][],int m,int n,int b[][]){
        for(int i=0;i<=m;i++){
            C[i][0]=0;    //B序列无元素 
        }
        for(int i=0;i<=n;i++){
            C[0][i]=0;    //A序列无元素
        }
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(A[i]==B[j]){
                    C[i][j]=C[i-1][j-1]+1;
                    b[i][j]=1;    //斜上方 
                }else if(C[i-1][j]>=C[i][j-1]){
                    C[i][j]=C[i-1][j];
                    b[i][j]=2;    //上一行 
                }else{
                    C[i][j]=C[i][j-1];
                    b[i][j]=3;    //上一列 
                }
            } 
        }
        LCS(m,n,A,b);
    }

    public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
        int A[]=new int[1000];
        int B[]=new int[1000];
        int C[][]=new int[1000][1000];
        int b[][]=new int[1000][1000];
        System.out.print("输入第一个序列的大小：");
        int A_size=reader.nextInt();
        System.out.print("输入第一个序列的值：");
        for(int i=1;i<=A_size;i++){
            A[i]=reader.nextInt();
        }
        System.out.print("输入第二个序列的大小：");
        int B_size=reader.nextInt();
        System.out.print("输入第二个序列的值：");
        for(int i=1;i<=B_size;i++){
            B[i]=reader.nextInt();
        }
        System.out.print("最长公共子序列为：");
        LCSLength(A,B,C,A_size,B_size,b);
        System.out.println("长度为："+C[A_size][B_size]);
        reader.close();
    }

}

10:34:09

2018-10-28