贪心-合并区间、交集、无重叠区间、俄罗斯套娃信封

1. 给出一个区间的集合，请合并所有重叠的区间。

/*
* https://leetcode-cn.com/problems/merge-intervals/
*
* 给出一个区间的集合，请合并所有重叠的区间。
* */
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class code056_MergeIntervals
{
    public int[][] merge(int[][] intervals) {
        if (intervals == null || intervals.length == 0)
            return intervals;
        Arrays.sort(intervals, new Comparator<int[]>()
        {
            @Override
            public int compare(int[] o1, int[] o2)
            {
                if (o1[0] == o2[0])
                    return o1[1] - o2[1];
                return o1[0] - o2[0];
            }
        });
        List<int[]> res = new ArrayList<>();
        res.add(intervals[0]);
        for (int i = 0; i < intervals.length; i++)
        {
            int[] last = res.get(res.size() - 1);
            int[] curr = intervals[i];
            if(curr[0] <= last[1]){
                last[1] = Math.max(last[1], curr[1]);
            }else {
                res.add(curr);
            }
        }
        int[][] result = new int[res.size()][2];
        for (int i = 0; i < result.length; i++)
        {
            result[i] = res.get(i);
        }
        return result;
    }
}

2. 给定两个由一些闭区间组成的列表，每个区间列表都是成对不相交的，并且已经排序。返回这两个区间列表的交集。

/*
* https://leetcode-cn.com/problems/interval-list-intersections/
*
* 给定两个由一些闭区间组成的列表，每个区间列表都是成对不相交的，并且已经排序。
*
* 返回这两个区间列表的交集。*/
import java.util.ArrayList;
import java.util.List;

public class code986_IntervalListIntersections
{
    public int[][] intervalIntersection(int[][] A, int[][] B) {
        if(A == null)
            return A;
        if(B == null)
            return B;
        List<int[]> res = new ArrayList<>();
        int l1 = A.length, l2 = B.length;
        int i = 0, j = 0;
        while(i < l1 && j < l2){
            int a1 = A[i][0], a2 = A[i][1];
            int b1 = B[j][0], b2 = B[j][1];
            if(a1 <= b2 && a2 >= b1){
                res.add(new int[]{Math.max(a1, b1), Math.min(a2, b2)});
            }
            if(a2 < b2){
                i++;
            }else{
                j++;
            }
        }
        int[][] result = new int[res.size()][2];
        for(int k = 0; k < result.length; k++){
            result[k] = res.get(k);
        }
        return result;
    }
}

3. 给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

import java.util.Arrays;
import java.util.Comparator;

/*
* https://leetcode-cn.com/problems/non-overlapping-intervals/
* 给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。
* */
class Solution
{
    public int eraseOverlapIntervals(int[][] intervals)
    {
        if (intervals.length == 0)
            return 0;
        Arrays.sort(intervals, new Comparator<int[]>()
        {
            public int compare(int[] a, int[] b)
            {
                return a[1] - b[1];
            }
        });
        int count = 1;
        int init_end = intervals[0][1];
        for (int[] inter : intervals)
        {
            int start = inter[0];
            if (start >= init_end)
            {
                count++;
                init_end = inter[1];
            }
        }
        return intervals.length - count;
    }
}

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

/*
*
* https://leetcode-cn.com/problems/russian-doll-envelopes/
*
* 给定一些标记了宽度和高度的信封，宽度和高度以整数对形式 (w, h) 出现。
* 当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。
* 请计算最多能有多少个信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。
**/
import java.util.Arrays;
import java.util.Comparator;

public class code354_RussianDollEnvelopes
{
    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];
                return o1[0] - o2[0];
            }
        });
        int[] height = new int[envelopes.length];
        for (int i = 0; i < envelopes.length; i++){
            height[i] = envelopes[i][1];
        }
        return LenLongestIncreaseSubSequence(height);
    }

    private int LenLongestIncreaseSubSequence(int[] nums)
    {
        int maxLength = 0;
        int dp[] = new int[nums.length];
        for (int i = 0; i < nums.length; i++)
        {
            dp[i] = 1;
        }
        for (int i = 0; i < dp.length; i++)
        {
            for (int k = 0; k < i; k++)
            {
                if (nums[i] > nums[k])
                    // dp[i]:以i结尾，最长的递增子序列
                    dp[i] = Math.max(dp[i], dp[k] + 1);
            }
            maxLength = Math.max(maxLength, dp[i]);
        }
        return maxLength;
    }

}