动态规划：最长递增子序列 思路及解法

题目：

给定数组arr，返回arr的最长递增子序列。

举例：

arr = [2,1,5,3,6,4,8,9,7]，返回的最长递增子序列为[1,3,4,8,9]，长度为5。

思路：

思路解析来自左神的《程序源代码面试指南》;

这里介绍的是时间复杂度为O(N²)，额外空间复杂度O(N)的方法：
1.数组arr的长度n，建立数组dp，其中dp[i]的含义是，以arr[i]这个数结尾的情况下，即a[0…i]这段数组中，最长的递增子序列的长度是多少；
2.设定dp数组的初值，即dp[0] = 1，因为当i = 0时，arr[0]只有一个元素，所以最长的子序列长度就是1；
3.如果当前位置为i，假设其为最后一个元素，那么在此之前的所有小于arr[i]的元素都可以作为倒数第二个元素；所以我们只需要找到所有可能的位置，再在dp数组中找到最大的那个值dp[k]，那么dp[i] = dp[k] + 1；
4.最后关于怎么找到最长子序列：当我们将dp数组构建完成，每个位置都是对应arr中每个位置的最长子序列的长度，所以我们只需要遍历数组，找到最大长度和其位置i，然后从arr[i - 1]向前开始判断。假设最后子序列的数组为lis，其长度len = dp[i]，那么dp[lis[len - 2]] + 1= dp[lis[len - 1]]；这样就能确定前一个元素的位置了；具体可以看代码，很容易理解；

Java代码：

public static int[] solution(int[] arr) {
        int[] dp = geneDP(arr);
        int[] lis = geneLIS(arr,dp);
        return lis;
    }
    public static int[] geneDP(int[] arr) {
        int[] dp = new int[arr.length];
        for(int i = 0; i < dp.length; i++) {
            dp[i] = 1;
            for(int j = 0; j < i; j++) {
                if(arr[j] < arr[i] && dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1;
                }
            }
        }
        return dp;
    }

    public static int[] geneLIS(int[] arr,int[] dp) {
        int len = dp[0];
        int index = 0;
        for(int i = 1; i < dp.length; i++) {
            if(len < dp[i]) {
                len = dp[i];
                index = i;
            }
        }
        int[] lis = new int[len];
        lis[--len] = arr[index];
        while (dp[index] > 1) {
            int cur = dp[index];
            for(int i = index - 1; i >= 0; i--) {
                if(cur == dp[i] + 1) {
                    index = i;
                    lis[--len] = arr[i];
                    break;
                }
            }
        }
        lis[0] = arr[index];
        return lis;
    }