Leetcode 354. 俄罗斯套娃信封问题

题目描述

原题链接

给定一些标记了宽度和高度的信封，宽度和高度以整数对形式 (w, h) 出现。当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。

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

说明:
不允许旋转信封。

示例:

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

思路

最多的信封，后一个的w和h 都大于前一个，因此这个问题就是求w和h维度上的最大升序子序列。那它一定是w和h上升序列集并集的一个。我们可以先将信封排序，在保证w上升序前提下，根据h求最长升序子序列，那么这个就是最后的答案。

解法一 （动态规划）

/**
 * @param {number[][]} envelopes
 * @return {number}
 */
var maxEnvelopes = function(envelopes) {
    if(envelopes.length<2){
        return envelopes.length;
    }
    envelopes.sort((a,b)=>a[0]==b[0]?b[1]-a[1]:a[0]-b[0]);
    let res = 1;
    let left = 0;
    let len = envelopes.length;
    let dp = new Array(len).fill(1);
    for(let i = 1; i<len;++i){
        for(let j = 0; j<i;++j){
            if(envelopes[i][1]>envelopes[j][1]){
                dp[i] = Math.max(dp[i], dp[j]+1);
            }
        }
    }
    return Math.max(...dp);
};

1. 先将数组排序，这里要注意的是，当w值相同时（即：a[0] == b[0] 时），需要按h值递减排序。
2. 在用dp 记录以第i个信封为结尾的最大信封数。
3. 再遍历dp，取最大值。

解法二 （二分查找优化）

/**
 * @param {number[][]} envelopes
 * @return {number}
 */
var maxEnvelopes = function(envelopes) {
    if(envelopes.length<2){
        return envelopes.length;
    }
    envelopes.sort((a,b)=>a[0]==b[0]?b[1]-a[1]:a[0]-b[0]);
    let res = 1;
    let left = 0;
    let len = envelopes.length;
    let dp = new Array(len+1);
    dp[0] = -Infinity;
    dp[1] = envelopes[0][1];
    let maxlen = 1;
    envelopes.forEach(value=>{
        let left = 0, right = maxlen;
        while(left<=right){
            //left <= right 的目的是让保证0到left-1 中的dp值都小于value[1]
            let mid = (left+right)>>1;
            if(dp[mid]<value[1]){
                left = mid+1;
            }else{
                right = mid-1;
            }
        }
        if(left == maxlen+1){
            dp[++maxlen] = value[1];
        }else{
            dp[left] = Math.min(dp[left], value[1]);
        }
    })
    return maxlen;
};

采用二分查找进行了优化，时间复杂度可以降到O(NlogN)， 具体思路可以看LeetCode 300. 最长上升子序列上的题解，这两道本质差不多。