354. Russian Doll Envelopes

You have a number of envelopes with widths and heights given as a pair of integers (w, h). One envelope can fit into another if and only if both the width and height of one envelope is greater than the width and height of the other envelope.

What is the maximum number of envelopes can you Russian doll? (put one inside other)

Example:

Given envelopes = [[5,4],[6,4],[6,7],[2,3]], the maximum number of envelopes you can Russian doll is 3 ([2,3] => [5,4] => [6,7]).

一个信封a可以塞入另外一个信封b，那么a的面积一定是小于b的，否则塞不进去。

给出的信封可以按照面积排序，排完序以后只可能是数组前面的往后面塞，实际上就是一个最大上升子序列问题。

当前位置能否取前面的位置，要依据宽度和高度两个条件，其他套用求最大上升子序列的方法。

public class Solution {
    public int maxEnvelopes(int[][] envelopes)
	{
		int len=envelopes.length;
		if(len<1)
			return 0;
		
		envelop[] enarr=new envelop[len];
		int cnt=0;
		for(int[] a :envelopes )
			enarr[cnt++]=new envelop(a[0], a[1]);
		
		Arrays.sort(enarr);
		
		return lengthOfLIS(enarr);
		
		
	}
	
	public static int lengthOfLIS(envelop[] nums)
	{
		int len=nums.length;
		if(len<1)
			return 0;
		int[] dp=new int[len];
		Arrays.fill(dp, 1);
		for(int i=1;i<len;i++)
		{
			int max=Integer.MIN_VALUE;
			for(int j=0;j<i;j++)
				if(nums[i].height>nums[j].height&&nums[i].width>nums[j].width)
					max=Math.max(max, dp[j]);
				
			if(max>Integer.MIN_VALUE)
				dp[i]=max+1;
		}
			
		int maxlen=Integer.MIN_VALUE;
		for(int i=0;i<len;i++)
			maxlen=Math.max(maxlen, dp[i]);
			
		return maxlen;
	}

}


class envelop implements Comparable<envelop>
{
	int width;
	int height;
	long s;
	public envelop(int width,int height)
	{
		this.width=width;
		this.height=height;
		s=width*height;
	}
	
	public int compareTo(envelop o)
	{
		long cmp=s-o.s;
		if(cmp>0)
			return 1;
		if(cmp<0)
			return -1;
		
		cmp=width-o.width;
		if(cmp>0)
			return 1;
		if(cmp<0)
			return -1;
		
		cmp=height-o.height;
		if(cmp>0)
			return 1;
		if(cmp<0)
			return -1;
		
		return 0;
	}

}

------------------------------------------------------------------------------

其实没必要按照面积排序，按照宽、或者高其中之一排序然后DP就行了，规则还是一样，宽和高都要比前面的大才行

https://discuss.leetcode.com/topic/47594/short-and-simple-java-solution-15-lines

public int maxEnvelopes(int[][] envelopes) {
    Arrays.sort(envelopes, (a, b) -> a[0] - b[0]);
    int max = 0;
    int dp [] = new int [envelopes.length];
    for(int i = 0; i < envelopes.length; i++){
        dp[i] = 1;
        for(int j = 0; j < i; j++){
            if(envelopes[j][0] < envelopes[i][0] && envelopes[j][1] < envelopes[i][1])
                dp[i] = Math.max(dp[i], dp[j] + 1);
        }
        max = Math.max(dp[i], max);
    }
    return max;
}

-----------------------------------------------------------------------------------

求LIS有O(NlogN)的方法，这样总复杂度可以降到O(NlogN)

https://discuss.leetcode.com/topic/47469/java-nlogn-solution-with-explanation/2

1. Sort the array. Ascend on width and descend on height if width are same.
2. Find the longest increasing subsequence based on height.

---

• Since the width is increasing, we only need to consider height.
• [3, 4] cannot contains [3, 3], so we need to put [3, 4] before [3, 3] when sorting otherwise it will be counted as an increasing number if the order is [3, 3], [3, 4]

---

public int maxEnvelopes(int[][] envelopes) {
    if(envelopes == null || envelopes.length == 0 
       || envelopes[0] == null || envelopes[0].length != 2)
        return 0;
    Arrays.sort(envelopes, new Comparator<int[]>(){
        public int compare(int[] arr1, int[] arr2){
            if(arr1[0] == arr2[0])
                return arr2[1] - arr1[1];
            else
                return arr1[0] - arr2[0];
       } 
    });
    int dp[] = new int[envelopes.length];
    int len = 0;
    for(int[] envelope : envelopes){
        int index = Arrays.binarySearch(dp, 0, len, envelope[1]);
        if(index < 0)
            index = -(index + 1);
        dp[index] = envelope[1];
        if(index == len)
            len++;
    }
    return len;
}