动态规划实例（一）：最长递增子序列（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);
    }
}