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

掌握动态规划求解问题的思想；针对不同的问题，会利用动态规划进行设计求解以及时间复杂度分析，并利用JAVA/C/C++等编程语言将算法转换为对应的程序上机运行（语言自选）。

理解两组序列的最长公共子序列问题，能够根据动态规划思想，进行最优子结构性质分析、子结构递归关系构建、编码实现子结构最优值求解以及最优解构造。

实验要求：

①掌握动态规划求解问题的策略及思路；

①基于动态规划算法设计求解序列的最长公共子序列；

③对上述算法进行时间复杂性分析，并输出程序运行时间及运行结果。

理解：

求解过程是多阶段决策的时候，每一步处理一个子问题，可用于求解最后的组合优化问题。我们能够保存已解决的子问题的答案，在需要时再找出已求得的答案，这样就可以避免大量的重复计算。我们用一个表来记录所有已解的子问题的答案。而且用动态规划方法必须满足优化原则，就是说最优解的任何一个子问题的解的状态是最优的解，也必须不是相互独立的。下面以求最短路径问题为例子。

例子：X={A,B,C,B,A,D,B}，Y={B,C,B,A,A,C}，那么，二者的最长公共子序列是{B,C,B,A}，长度为4。

先明白最长公共子序列和最长公共子串，找两个字符串的最长公共子串，这个子串要求在原字符串中是连续的。而最长公共子序列则并不要求连续。利用动态规划解决最长公共子序列问题的理解，界定子问题，子问题的依赖LCS，以及求LCS长度，最后构造最优解，如图所示。

 

四、实验步骤

完整代码实现；包括代码详细解释及功能设计说明。要求：格式清晰、卷面规范整洁。

package week5;
//最长公共子序列
public class zd {
    public static int lcscd(char[] x,char[] y,int[][] b){
        int m = x.length;        // x数组的长度
        int n = y.length;
// 首先要初始化第一行和第一列为0
        int[][] c = new int[m+1][n+1];
//        第一行第一列初始化为0
        for (int i = 1; i <= m; i++) {
            c[i][0] = 0;
        }
        for (int i = 1; i <= n; i++) {
            c[0][i] = 0;
        }
//  找公共子序列  从第一个字母开始
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
//           求三种情况下的 c[i][j]
                if (x[i-1] == y[j-1]){        //这是两个序列当前对比元素相等的时候，这个时候要在前一个右上对角元素上+1
                    c[i][j] = c[i-1][j-1] + 1;
                    b[i][j] = 1;
                }
//              在上边或者左边取一个较大的填入当前的c[i][j]
//              b数组是用来标识哪个情况是序列字母相等的，可以用于输出工作
                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;
                }
            }
        }
//        把c输出可以看出一个运算过程
        show(c);
        return c[m][n];     //返回最长序列的长度
    }
    //    最长公共子序列
    public static void Lcs(int i,int j,char[] x,int[][] b){
        if (i==0 || j==0)
            return;
//        上述记录的元素相等的情况输出
        if (b[i][j] == 1){
            Lcs(i-1,j-1,x,b); //递归回对角上的情况
            System.out.print(x[i-1]+" ");
        }
        else if (b[i][j] == 2){
            Lcs(i-1,j,x,b);
        }
        else {
            Lcs(i,j-1,x,b);
        }
    }
    //    打印数组
    public  static void show(int[][] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                System.out.print(arr[i][j]+"  ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        char[] x = new char[]{'a','d','c','b','c','a'};
        char[] y = new char[]{'a','b','c','d','c','d'};
        int[][] b = new int[x.length+1][y.length+1];
        System.out.println("最长子序列长度："+lcscd(x,y,b));
        System.out.println("最长公共子序列：");
        Lcs(x.length,y.length,x,b);
    }
}

五、记录与处理（实验数据、误差分析、结果分析）

实验数据及结果分析：

 

 

六、思考与总结

我认为动态规划算法是很好用的算法，应备受推崇，他是真的强，真的用空间换时间的，可以将时间复杂度很高的问题降低其时间复杂度，现在硬件很好，不怕空间不够，这种算法应多多推广。

最长公共子序列问题，就是要先理解最长公共子序列和最长公共子串。利用动态规划求解最主要就是数组c【i，j】,就是记录子问题的数据结构。分三种特殊情况，在里面找到最长公共子序列的长度。建立递推关系式利用最优子结构。找出最优就可以了。能弄明白这几点，最长公共子序列问题就迎刃而解。