动态规划——最长公共子序列计算

最长公共子序列计算步骤：

第一步：先计算最长公共子序列的长度。

第二步：根据长度，然后通过回溯求出最长公共子序列。

现有两个序列X={x₁,x₂,x_3，...x_i}，Y={y₁,y₂,y_3，....，y_i}，

一共有两种情况，一种是

x1 = = y1,则长度为lcs({x2,x3,x4....xi},{y₂,y_3，....，y_i})+1

若不等，则递归计算取

lcs({x1,x3,x4....xi},{y₂,y_3，....，y_i})和 lcs({x2,x3,x4....xi},{y₁,y₂,y_3，....，y_i})之中较大的值作为公共子序列的长度。

递推方程为：（此图片来源于网络）

　　　　

动态规划最重要最核心的就是求出递推方程，有了递推方程，我们可以非常容易的利用递归写出代码：

public class LCS {
     String x = "122f35624";
     char [] m = x.toCharArray();
     String y = "2135ff4";
    char [] n = y.toCharArray();


    int [][] a = new int[x.length()][y.length()];//用来保存中间计算的状态
    public static void main(String[] args) {

       LCS lcs = new LCS();
        lcs.init();
        int result = lcs.solve(0,0);
        System.out.println();
        System.out.println(result);
        lcs.resolvePath(result);
    }

    public void init(){
        for (int i=0; i<x.length(); i++)
            for (int j=0; j<y.length(); j++){
                a[i][j] = -1;
            }
    }

    public  int solve(int i,int j){//记忆化搜索
        if (i==x.length()|| j==y.length())
            return 0;
        if (a[i][j] >=0)//此处为了提高效率，防止重复计算，当计算过时直接返回值，不再重复计算
            return a[i][j];
        if (m[i]==n[j]){
            return a[i][j] = solve(i+1,j+1)+1;
        }
        else
        return a[i][j] = Math.max(solve(i+1,j),solve(i,j+1));
    }

    /**
     * 打印最长公共字串
     * @param result
     */
    public void resolvePath(int result){
        int x = 0;
        int y = 0;
        char [] path = new char[result];
        int count = 0;
        while (x <m.length && y <n.length) {
            if (m[x] == n[y]) {
                path[count++] = m[x];
                x++;
                y++;
            }
            else if (x<m.length-1&&a[x][y] == a[x+1][y]){
                x++;
            }else if (y<n.length-1 &&a[x][y] == a[x][y+1])
                y++;
        }
        for (int i=0; i<path.length; i++)
            System.out.print(path[i]);
    }


}

除了利用递归方法解决上述问题外，还可以采用递推法解决。将上述函数换成数组

设一个c[i,j]: 保存X_i与Y_j的LCS的长度。（此图片来源于网络）

对应代码如下：

    /**
     * 递推法计算最长公共子序列
     * @return 最长公共子序列长度
     */
    public int lcs(){
        for (int i=0; i<m.length; i++){//0行0列初始化为0
            a[i][0] = 0;
            a[0][i] = 0;
        }
        for (int i=1; i<=m.length; i++)
            for (int j=1; j<=n.length; j++){
                if (m[i-1] == n[j-1])
                    a[i][j] = a[i-1][j-1] + 1;
                else
                    a[i][j] = Math.max(a[i][j-1],a[i-1][j]);
            }
        return a[m.length][n.length];
    }

打印公共子序列函数与递归法相同。

程序运行结果如下：