76. 最长上升子序列

描述

给定一个整数序列，找到最长上升子序列（LIS），返回LIS的长度。

说明

最长上升子序列的定义：
最长上升子序列问题是在一个无序的给定序列中找到一个尽可能长的由低到高排列的子序列，这种子序列不一定是连续的或者唯一的。
https://en.wikipedia.org/wiki/Longest_increasing_subsequence

样例

给出[5,4,1,2,3]，LIS 是[1,2,3]，返回3
给出[4,2,4,5,3,7]，LIS 是[2,4,5,7]，返回4

挑战

要求时间复杂度为O(n^2) 或者 O(nlogn)

注意

动态规划求的是方案的个数而不是具体的方案，即求出最长子序列的长度，但最长子序列究竟由哪些位置构成无法得知

代码

1. 动态规划O(n ^ 2)

思路
本题属于坐标型动态规划，也叫接龙型动态规划，但坐标并没有明显给出，要想成为当前元素的上一个坐标需要满足两个条件：
a. 下标位于当前元素左边
b. 数组中对应的值小于当前元素

数组当中每一个元素都可以成为最长序列的起点，所以我们初始定义一个 f 数组，f[i] 记录数组中相应下标对应的最长序列大小，初始化定义 f[i] = 1，如果存在下标 j 满足上述 a 和 b 两个条件且满足 f[j] + 1 > f[i]，即 f[j] 对应的最长序列接上 nums[j] 组成的新序列长度大于 f[i]，那得到新的状态，需要更新 f[i] 的值，f 数组中最大的值即为最长上升子序列

状态转移方程为f[i] = max{1, f[j] + 1} (j = 1, 2, ..., i - 1, 且A[j] < A[i])

public class Solution {
    /**
     * @param nums: The integer array
     * @return: The length of LIS (longest increasing subsequence)
     */
    public int longestIncreasingSubsequence(int[] nums) {
        // f数组存储着当前index对应的最长上升子序列
        int []f = new int[nums.length];
        int max = 0;
        // 每个点都可以成为起点，初始化令f[i] = 1
        // 如果只令f[0] = 1，代表只有index = 0才能做起点
        for (int i = 0; i < nums.length; i++) {
            f[i] = 1;
            // index小于i且值小于nums[i]的数才能做为上一个点的候选     
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    f[i] = f[i] > f[j] + 1 ? f[i] : f[j] + 1;
                }
            }
            // 从所有候选点里找到最长的
            if (f[i] > max) {
                max = f[i];
            }
        }
        return max;
    }
}

2. 二分法 O(log n)

思路
O(n^2)的算法复杂度高的原因就在于必须在1 ~ i-1中枚举找到最大的 f[j] 的值才能最终更新f[i]的值，上一种算法的状态转移方程为 f[i] = max{1, f[j] + 1} (j = 1, 2, ..., i - 1, 且A[j] < A[i])，f[i] 代表当前下标对应的最长子序列。
现在，我们仔细考虑计算 f[i] 时的情况。假设有两个元素nums[x]和nums[y]，满足

1. x < y < i
2. nums[x] < nums[y] < nums[i]
3. f[x] = f[y]

此时，选择 f[x] 和选择 f[y] 都可以得到同样的 f[i] 值，那么，在最长上升子序列的这个位置中，应该选择nums[x]还是应该选择nums[y]呢？

很明显，选择nums[x]比选择nums[y]要好。如果在nums[x+1] ... nums[i-1]这一段中，如果存在nums[z]，nums[x] < nums[z] < nums[y]，则选择nums[x]相比，可能会得到更长的上升子序列，当前子序列构成更长子序列的潜力增大了。

如此，我们根据数组 f 的值进行分类。对于数组 f 的每一个取值k，我们只需要保留满足f[i] = k的所有nums中的最小值。用数组minLast记录这个值，即minLast[k] = min{nums[i]} (f[i] = k) (minLast数组中元素按升序存储)
我们在遍历nums数组的过程中，将在minLast数组中找到第一个大于当前nums[i]的元素，用nums[i]替换该元素就可以实现刚刚说的记录满足f[i] = k的所有nums元素中的最小值 (nums中元素是顺序遍历，minLast元素刚刚大于nums[i]说明它们在nums之间的所有元素都大于nums[i]，也就意味着从minLast中找出的当前元素本身到nums[i]之间所有元素不能成为接龙中nums[i]的上一个元素，即minLast找出的当前元素对应的f数组值和f[i]是相等的)

因为我们对minLast的替换操作，遍历到数组最后minLast的长度也就成为了最长子序列的长度，要说明的是由于动态规划的特性我们得到的minLast并不是真正的接龙方案，因为实际接龙挑选元素时nums数组元素的顺序不能改变，而minLast元素的顺序是插入得到的，所以minLast中的元素并不是实际方案

public class Solution {
    /**
     * @param nums: The integer array
     * @return: The length of LIS (longest increasing subsequence)
     */
    public int longestIncreasingSubsequence(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }        

        // 二分法寻找的是end位置，所以minLast数组至少要有两个元素才能进行插入更新值
        // 所以minLast数组要多加一个元素
        // 实际上minLast[0]会一直保持Integer.MIN_VALUE不变
        int[] minLast = new int[nums.length + 1];
        minLast[0] = Integer.MIN_VALUE;
        for (int i = 1; i <= nums.length; i++) {
            minLast[i] = Integer.MAX_VALUE;
        }
        
        for (int i = 0; i < nums.length; i++) {
            // find the first number in minLast >= nums[i]
            int index = binarySearch(minLast, nums[i]);
            minLast[index] = nums[i];
        }
        
        for (int i = nums.length; i >= 1; i--) {
            if (minLast[i] != Integer.MAX_VALUE) {
                return i;
            }
        }
        
        return 0;
    }
    
    // find the first number > num
    private int binarySearch(int[] minLast, int num) {
        int start = 0, end = minLast.length - 1;
        while (start + 1 < end) {
            int mid = (end - start) / 2 + start;
            if (minLast[mid] < num) {
                start = mid;
            } else {
                end = mid;
            }
        }
        
        return end;
    }
}