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

最长公共子序列

代码（附分析过程）

import java.util.Scanner;

public class one {
    // DP求解最长公共子序列
    public static int LcsLength(char[] x, char[] y, int[][] vis) {
        int m = x.length - 1;
        int n = y.length - 1;
        int[][] c = new int[m + 1][n + 1];  // 记录x[0]...x[i]与y[0]...y[j]的最长公共子序列长度
        for (int i = 1; i <= m; i++) { // 初始化y串长度为0的情况
            c[i][0] = 0;
        }
        for (int i = 1; i <= n; i++) {  // 初始化x串长度为0的情况
            c[0][i] = 0;
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (x[i] == y[j]) {  // x[i]与y[j]相等的情况
                    c[i][j] = c[i - 1][j - 1] + 1;
                    vis[i][j] = 1;  // 记录为第一种情况
                } else if (c[i - 1][j] >= c[i][j - 1]) {  // x[i]与y[j]不相等的第一种情况
                    c[i][j] = c[i - 1][j];
                    vis[i][j] = 2;// 记录为第二种情况
                } else {   // x[i]与y[j]不相等的第二种情况
                    c[i][j] = c[i][j - 1];
                    vis[i][j] = 3;// 记录为第三种情况
                }
            }
        }
        return c[m][n];
    }

    //通过vis数组寻找最长子串序列
    public static void lcs(int i, int j, char[] x, int[][] vis) {
        if (i == 0 || j == 0) {  //由一方为空串
            return;
        }
        if (vis[i][j] == 1) {  //x[i]与y[j]相等的情况
            lcs(i - 1, j - 1, x, vis);
            System.out.print(x[i]+" ");
        } else if (vis[i][j] == 2) {  // x[i]与y[j]不相等的第一种情况
            lcs(i-1,j,x,vis);
        }else{  // x[i]与y[j]不相等的第二种情况
            lcs(i,j-1,x,vis);
        }
    }

    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        int xLen = scanner.nextInt();
        int yLen = scanner.nextInt();
        char[] x = new char[xLen + 1];
        char[] y = new char[yLen + 1];
        for (int i = 1; i <= xLen; i++) {
            x[i] = scanner.next().charAt(0);
        }
        for (int i = 1; i <= yLen; i++) {
            y[i] = scanner.next().charAt(0);
        }
        int[][] vis = new int[xLen + 1][yLen + 1];
        int maxLcs = LcsLength(x, y, vis);
        System.out.println(maxLcs);
        lcs(xLen,yLen,x,vis);
    }
}

测试输入

8 9
1, 3, 4, 5, 6, 7, 7, 8
3, 5, 7, 4, 8, 6, 7, 8, 2

测试输出

5
3 4 6 7 8

运行结果

电路布线

代码（附分析过程）

import java.text.CharacterIterator;
import java.util.Scanner;

public class two {
    //求解最大不想交子集数目
    public static void mnset(int[] c, int[][] size) {
        int n = c.length - 1;
        for (int i = 0; i < c[i]; i++) {
            size[1][i] = 0;  //j<π（1）
        }
        for (int i = c[1]; i <= n; i++) {
            size[1][i] = 1;  //j>=π（1）
        }
        for (int i = 2; i < n; i++) {
            for (int j = 0; j < c[i]; j++) {
                size[i][j] = size[i - 1][j];  //j<π（i）
            }
            for (int j = c[i]; j<=n;j++){
                size[i][j]=Math.max(size[i-1][j],size[i-1][c[i]-1]+1);  //j>=π（i）
            }
        }
        size[n][n]=Math.max(size[n-1][n],size[n-1][c[n]-1]+1);
    }

    //构造最优解
    public static int traceback(int[] c,int[][] size,int[] net){
        int n=c.length-1;
        int j=n;
        int m=0;
        for (int i = n; i > 1; i--) {
            if(size[i][j]!=size[i-1][j]){
                net[m++]=i;
                j=c[i]-1;
                if(j>=c[1]){
                    net[m++]=1;
                }
            }
        }
        return m;
    }

    public static void main(String args[]) {
        Scanner scanner=new Scanner(System.in);
        int len = scanner.nextInt();
        int[] c=new int[len+1];
        int[][] size=new int[len+1][len+1];
        for (int i = 1; i <= len; i++) {
            c[i]=scanner.nextInt();
        }
        mnset(c,size);
        System.out.println(size[len][len]);
    }
}

测试输入

10
8 7 4 2 5 1 9 3 10 6

测试输出

4

运行结果

实验总结

动态规划算法：

全局最优解中一定包含某个局部最优解，但不一定包含前一个局部最优解，因此需要记录之前的所有最优解
动态规划的关键是状态转移方程，即如何由以求出的局部最优解来推导全局最优解
边界条件：即最简单的，可以直接得出的局部最优解

设计动态规划的四个步骤：

1、刻画一个最优解的结构特征。

2、递归地定义最优解的值。

3、计算最优解的值，通常采用自底向上的方法。

4、利用计算出的信息构造一个最优解。

动态规划的应具备两个要素：

1、最优子结构性质。当问题的最优解包含了其子问题的最优解时，称该问题具有最有子结构性质；

2、重叠子问题性质。