【leetcode】354. 俄罗斯套娃信封问题 O(nlogn) 求最长上升子序列

给你一个二维整数数组 envelopes ，其中 envelopes[i] = [wi, hi] ，表示第 i 个信封的宽度和高度。

当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。

请计算 最多能有多少个 信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。

注意：不允许旋转信封。

 
示例 1：

输入：envelopes = [[5,4],[6,4],[6,7],[2,3]]
输出：3
解释：最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。
示例 2：

输入：envelopes = [[1,1],[1,1],[1,1]]
输出：1

这道题的解法重点主要有两个， 一个是固定长宽其中一个顺序，另外一个倒序，方便做数值比较。
另外一个是 O(nlogn) 时间复杂度求最长上升子序列

O(n^2) 的时间复杂度在于每一个数字需要向前遍历之前的数据，如果遍历到比他小的，那么取一个最长的序列作为前面的子序列。

O(nlogn)的事件复杂度在于用一个数组去维护每一个长度的最长上升子序列最后一位。这个最长上升子序列的最后一位越小，那么整个数组最长上升子序列长度就可能越大。

所以遍历每一个数字的时候，需要找出这个值应该放在哪一位后面，那么需要找到比这个数大的最小的一个值，进行更新。因为维护最长上升子序列的原因，这个数组是单调递增的，所以可以用二分法找出这个位置。

当这个值本身就是整个最长上升子序列中最大的时候，就将它作为新的一个长度的最后一位。

    public int maxEnvelopes(int[][] envelopes) {
        Arrays.sort(envelopes, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0] == o2[0]) {
                    return o2[1] - o1[1];
                } else {
                    return o1[0] - o2[0];
                }
            }
        });
        int[] nums = new int[envelopes.length];
        for(int i = 0; i < nums.length; i++) {
            nums[i] = envelopes[i][1];
        }

        int[] lis = new int[nums.length];
        int index = 0;
        for(int i = 0; i < nums.length; i++) {
            int l = 0;
            int r = index;
            while(l < r) {
                int mid = l + (r - l) >> 1;
                if(lis[mid] >= nums[i]) {
                    r = mid;
                } else {
                    l = mid + 1;
                }
            }
            if(l == index) {
                index++;
            }
            lis[l] = nums[i];
        }
        return index;
    }