耐心排序——专门快速解决最长递增子数组

耐心排序的规则

其实最长递增子序列和一种叫做 patience game 的纸牌游戏有关，甚至有一种排序方法就叫做 patience sorting（耐心排序，复杂度为$nlogn$）。而这个排序的本质是由二分查找实现的。
其规则为：
1、依次抽牌、压牌，但是只能把点数小的牌压到点数比它大的牌上。
2、如果当前牌点数较大没有可以放置的堆，则新建一个堆，把这张牌放进去。
3、如果当前牌有多个堆可供选择，则选择最左边的那一堆放置。
按照上述规则执行，可以算出最长递增子序列，牌的堆数就是最长递增子序列的长度。其中，第三个规则的实现就用寻找左侧边界的二分查找！

耐心排序的实现

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        //先建立好牌组
        vector<int>top(n);
        //记录牌堆个数
        int ans = 0;
        //开始放每个牌
        for(int i=0;i<n;++i)
        {
            int card = nums[i];
            //第一个牌堆和最后一个牌堆
            int left = 0,right = ans-1;
            while(left <= right)
            {
                int mid = left+(right-left)/2;
                //当前牌小于牌顶即满足条件
                if(card <= top[mid]) right = mid-1;
                else left = mid+1;
            }
            if(left == ans) ++ans;//相当于查找超界
            //放入牌
            top[left] = card;
        }
        return ans;
    }
};

二维的最大的递增子序列

先对宽度 w 进行升序排序，如果遇到 w 相同的情况，则按照高度 h 降序排序(这是因为一个宽度w只能有一个信封存在，所以索性将最大h的排在最前面，即这样可以专注于h，而不必担心选择多个w相同的信封)；之后把所有的 h 作为一个数组，在这个数组上计算 LIS 的长度就是答案。

class Solution {
public:
    int maxEnvelopes(vector<vector<int>>& envelopes) {
        int n = envelopes.size();
        sort(envelopes.begin(),envelopes.end(),[](vector<int> &a,vector<int>& b){return a[0]==b[0]?
        a[1]>b[1]:a[0]<b[0];});
        //下面的就是耐心排序！
        vector<int>top(n,0);
        int ans = 0; 
        for(int i=0;i<n;++i)
        {
            int card = envelopes[i][1];
            int left = 0,right = ans-1;
            while(left<=right)
            {
                int mid = left+(right-left)/2;
                if(card<=top[mid])  right = mid-1;
                else left = mid+1;
            }
            if(left == ans) ++ans;
            top[left] = card;
        }
        return ans;
    }
};