动态规划实例（一）：最长递增子序列（LIS）

    最长递增子序列（LIS）的问题是要找到一个给定序列的最长子序列的长度，使得子序列中的所有元素被排序的顺序增加。
    例如，{10，22，9，33，21，50，41，60，80} LIS的长度是6和 LIS为{10，22，33，50，60，80}。
    有两种方式来求解，一种是转化为LCS问题。即，首先对数组排序，将排序后的结果存储在辅助数组中。排序时间复杂度O(NlogN)，排序后的数组与原数组组成了LCS（N,N）问题。解决LCS问题的时间复杂度为O(N^2)，故整个算法的时间复杂度为O(N^2)，空间复杂度为O(N)
    另一种方式是直接用DP求解，算法如下：时间复杂度为O(N^2)
    ①最优子问题
        设lis[i] 表示索引为 [0...i] 上的数组上的 最长递增子序列。初始时，lis[i]=1，注意，在DP中，初始值是很重要的，
        它是整个算法运行正确的关键。而初始值 则可以 通过 画一个小的示例来 确定。
              当 arr[i] > arr[j]，lis[i] = max{lis[j]}+1 ；其中，j 的取值范围为：0,1...i-1
              当 arr[i] < arr[j]，lis[i] = max{lis[j]} ；其中，j 的取值范围为：0,1...i-1
    ②重叠子结构

        从上面可以看出，计算 lis[i]时，需要计算 lis[j]，其中 j < i，这说明有重叠子问题。

具体实例及实现代码如下所示：

   

/** * @Title: LIS.java * @Package dynamicprogramming * @Description: TODO * @author peidong * @date 2017-6-5 上午8:45:48 * @version V1.0 */package dynamicprogramming;import java.util.Arrays;import java.util.Stack;/** * @ClassName: LIS * @Description: 最长递增子序列 * @date 2017-6-5 上午8:45:48 * */public class LIS {    // 使用动态规划求最长递增子序列的长度    public static int lis(int[] arr) {        if (arr == null || arr.length == 0)            return 0;        return lis(arr, arr.length);    }    public static int lis(int[] arr, int length) {        // 初始化数组        int[] lis = new int[length];        for (int i = 0; i < length; i++) {            lis[i] = 1;        }        // 查找递增子序列        for (int i = 1; i < length; i++) {            for (int j = 0; j < i; j++) {                if (arr[i] > arr[j] && lis[j] + 1 > lis[i]) {                    lis[i] = lis[j] + 1;                }            }        }        int max = lis[0];        for (int i = 1; i < length; i++) {            if (max < lis[i]) {                max = lis[i];            }        }        return max;    }    // 利用辅助数组转变成求最长公共子串的问题    /**     *     * @Title: getLCS     * @Description:获取两个数组的最长公共子串     * @param arr     * @param data     * @return void     * @throws     */    public static void getLCS(int[] arr, int[] data) {        int len1 = arr.length;        int len2 = data.length;        int[][] newArr = new int[len1 + 1][len2 + 1];        // 设置第0行和第0列为0        for (int i = 0; i < newArr.length; i++) {            newArr[i][0] = 0;        }        for (int j = 0; j < newArr[0].length; j++) {            newArr[0][j] = 0;        }        // 二维数组记录相同的字符序列        for (int i = 1; i < newArr.length; i++) {            for (int j = 1; j < newArr[i].length; j++) {                if (arr[i - 1] == data[j - 1]) {                    // 动规公式一：LCS(Xm, Yn) = LCS(Xm-1, Yn-1) +Xm                    newArr[i][j] = newArr[i - 1][j - 1] + 1;                } else {                    // 动规公式二：LCS(Xm, Yn) = MAX{LCS(Xm-1, Yn), LCS(Xm, Yn-1)}                    newArr[i][j] = max(newArr[i - 1][j], newArr[i][j - 1]);                }            }        }        Stack<Integer> stack = new Stack();        int m = arr.length - 1;        int n = data.length - 1;        while (n >= 0 && m >= 0) { // 遍历数组            if (arr[m] == data[n]) {                stack.push(arr[m]);                m--;                n--;            } else {// 字符不同时，根据打印出的二维矩阵（测试数据）查找上一个相同的字符                if (newArr[m + 1][n] > newArr[m][n + 1]) {                    n--;                } else {                    m--;                }            }        }        while (!stack.isEmpty()) {// 打印出最长的递增子序列            System.out.print(stack.pop() + ",");        }    }    public static int max(int a, int b) {        return (a > b) ? a : b;    }    public static void main(String[] args) {        int[] arr = { 10, 22, 9, 33, 21, 50, 41, 60, 80 };        int len = arr.length;        int[] array = new int[len];        // 将arr复制给array        for (int j = 0; j < arr.length; j++) {            array[j] = arr[j];        }        Arrays.sort(array, 0, array.length - 1);        System.out.print("排序前的数组：");        for (int i = 0; i < arr.length; i++) {            System.out.print(arr[i] + ",");        }        System.out.println();        System.out.print("排序后的数组：");        for (int i = 0; i < array.length; i++) {            System.out.print(array[i] + ",");        }        System.out.println();        System.out.println("最长递增子序列为：");        getLCS(arr, array);        System.out.println();        int res = lis(arr);        System.out.println("最长递增子序列长度为：" + res);    }}