LeetCode 354 Russian Doll Envelopes (动态规划)

一道好题目，把最长递增子序列扩展到二维，但是这道题和最长递增子序列是有区别的，它不要求是序列，只是在数组中找到一组最长的组合，不要求顺序在初始中相同。

这是个二维的最长递增子序列，由于没有顺序限制，所以我们把第一维进行排序，然后对第二维进行动态规划

接下来就和最长递增子序列的思路一样：效率是O(n^2)的算法，

struct Node
{
    int x;
    int y;
    Node(){}
    Node(int x,int y)
    {
        this->x = x;
        this->y = y;
    }
}a[100005];
int dp[100005];
int compare1(Node a,Node b)
{
    if(a.x==b.x)
        return a.y<b.y;
    return a.x<b.x;
}

int compare2(Node a,Node b)
{
    if(a.x<b.x && a.y<b.y)
        return 1;
    return 0;
}

int pos;
class Solution {
public:
    int maxEnvelopes(vector<vector<int>>& envelopes) {
        
        pos=0;
        for(int i=0;i<envelopes.size();i++)
        {
            a[pos++] = Node(envelopes[i][0],envelopes[i][1]);
        }
        
        sort(a,a+pos,compare1);
        
        int res=0;
        for(int i=0;i<pos;i++)
        {
            dp[i]=1;
            for(int j=i-1;j>=0;j--)
            {
                if(compare2(a[j],a[i]))
                {
                    dp[i]=max(dp[i],dp[j]+1);
                }
            }
            
            res = max(res,dp[i]);
        }
        return res;
        
    }
};

最长递增序列，还有一种O(nlogn)的解法，这道题目也有同样的解法。 但是这种解法里给第一维排序的时候，第二维也要顺道排一下，在第一维相同的情况，第二维排倒序，然后再去动态规划， 这是因为，根据O(nlogn)的解法，我们需要维护一个第二维的递增数组，在第一维相同的而情况，第二维越小越小，在不断往递增数组里插入的时候，很明显第二维倒序会非常符合题目要求，并且减少很多不必要的判断

struct Node
{
    int x;
    int y;
    Node(){}
    Node(int x,int y)
    {
        this->x = x;
        this->y = y;
    }
}a[100005];
int dp[100005];
int compare(Node a,Node b)
{
    if(a.x==b.x)
        return a.y>b.y;
    return a.x<b.x;
}
int pos;
int len;
int binarySearch(int x)
{
    int l=0;
    int r=len-1;
    
    while(l<=r)
    {
        int mid = (l+r)/2;
        if(x > dp[mid])
        {
            l = mid+1;
        }
        else
        {
            r = mid-1;
        }
    }
    
    return l;
}

int last;
class Solution {
public:
    int maxEnvelopes(vector<vector<int>>& envelopes) {
        
        pos=0;
        for(int i=0;i<envelopes.size();i++)
        {
            a[pos++] = Node(envelopes[i][0],envelopes[i][1]);
        }
        
        sort(a,a+pos,compare);
        return fun();
        
    }
    
    int fun()
    {
        len = 0;
        for(int i=0;i<pos;i++)
        {
            int index = binarySearch(a[i].y);
            dp[index] = a[i].y;
            if(index==len)
                len++;
        }
        return len;
    }
};