最长递增子序列问题

最近学习了这个基础算法原型，最长递增子序列，所谓子序列，就是可以不连续，去除数组中任意元素获得的子数组都是子序列。

举个栗子，现在有数组arr，长度为5，分别是10，4，5，12，8

那么这个数组的最长递增子序列长度为3。

解法一：

动态规划思想，原问题分成子问题，那么自问题就是到结尾为arr[i]时的最大递增子序列长度。

创建一个辅助数组dp，和原数组长度相等，这个数组中存放的是以arr[i]结尾的时候，获得的最大递增子序列长度。

还是上面的栗子，arr数组中的元素为10，4，5，12，8，

那么dp[0]=1，这个子序列数字10本身

dp[1]=1，因为4比10小，再来看dp[2]，这时候5>4，但是比10小，所以dp[2]=dp[1]+1。

dp[3]，12比4和5都大，所以dp[3]=max(dp[1],dp[2])+1……最终得出dp数组为1，1，2，3，3

所以得到结果3。这种解法时间复杂度O(n²)

解法二：

解法二属于那种打死我我自己也想不出那种，同样的，这种方法也需要一个辅助数组，我们还叫做dp好了。

但是这次dp存放的不一样了，dp这次存放的是当最长递增子序列为i是，这个序列的最小结尾，注意了，是结尾！

继续看上面的栗子，10，4，5，12，8，

dp[0]=10，先把第一个放进去，因为当我们检索到10的时候，最长子序列长度为1，且最小结尾是10，所以存放这个10，

遍历到4的时候，我们发现，最长长度还是1，但是4比10小，所以4替换掉10，

继续遍历，5的时候，发现最长长度是2了，ok，那有有效区扩大为2，把5放进去，这时候数组里是4，5，

12的时候一样，数组变成4，5，12，然后最后一个8比12小，替换掉12，遍历结束，有效区长度为3，所以结果为3

这个方法的主要思想就是遍历到arr[i]的时候，去找之前的dp数组中第一个比他大的数，有的话替换掉，没有的话，扩大有效区。

这么一想其实这个方法也是两个循环，但是这个方法比方法一快，原因就在于我们可以加速第二个循环。

第二层循环我们去找比他大的数，可以用二分啊，所以时间复杂度加速到O(nlogn)。

下面上代码，

public class GetLis {
    // O(n²)
    public static int getLis1(int[] arr) {
        int maxLen = 1;
        int[] dp = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            dp[i] = 1;
            for (int j = 0; j < i; j++) {
                if (arr[i] > arr[j] && dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1;
                }
            }
            maxLen = Math.max(maxLen, dp[i]);
        }
        return maxLen;
    }

    // O(nlogn)
    public static int getLis2(int[] arr) {
        int maxLen = 1;
        int[] dp = new int[arr.length];
        int right = 0;
        int l = 0;
        int r = 0;
        int m = 0;
        dp[0] = arr[0];
        for (int i = 1; i < arr.length; i++) {
            l = 0;
            r = right;
            while (l <= r) {
                m = (l + r) / 2;
                if (arr[i] > dp[m]) {
                    l = m + 1;
                } else {
                    r = m - 1;
                }
            }
            right = Math.max(l, right);
            dp[l] = arr[i];

        }
        maxLen = right + 1;
        return maxLen;
    }

    public static void main(String[] args) {

        /*
         * Scanner scan = new Scanner(System.in); int n = scan.nextInt(); int[]
         * arr = new int[n]; for (int i = 0; i < n; i++) { arr[i] =
         * scan.nextInt(); } System.out.println(getLis1(arr));
         * System.out.println(getLis2(arr)); scan.close();
         */

        // 对数器验证一波

        for (int i = 0; i < 100000; i++) {
            int n = (int) (Math.random() * 98 + 2);
            int[] arr = new int[n];
            for (int j = 0; j < n; j++) {
                arr[j] = (int) (Math.random() * 200);
            }
            int res1 = getLis1(arr);
            int res2 = getLis2(arr);
            if (res1 != res2) {
                System.out.println("出错了！");
            }
        }

    }
}