题目：leetcode 252 会议室（1）

给定一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，请你判断一个人是否能够参加这里面的全部会议。
示例 1： 输入：intervals = [[0,30],[5,10],[15,20]] 输出：false
示例 2： 输入：intervals = [[7,10],[2,4]] 输出：true
思路总结：简单来说就是一类寻找有无冲突的题目，必要条件在于必须要使得先开始的会议结束在下一次会议开始之前，那么可以直接对会议开始时间排序，看前一个结束的时间是否比下一次开始时间大，一次遍历，只要出现比他大那就是false
代码如下：

class Solution {
    public boolean canAttendMeetings(int[][] intervals) {
        Arrays.sort(intervals, new Comparator<int[]>(){
            public int compare(int[] a, int[] b) {
                return a[0] - b[0];
            }
        });

        for( int i = 0; i < intervals.length - 1; i++ ){
            if( intervals[i][1] > intervals[i + 1][0] ) {
                return false;
            }
        }
        return true;
    }
}

题目：leetcode 253 会议室（2）

给你一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，为避免会议冲突，同时要考虑充分利用会议室资源，请你计算至少需要多少间会议室，才能满足这些会议安排。
示例 1：
输入：intervals = [[0,30],[5,10],[15,20]] 输出：2 示例 2：
输入：intervals = [[7,10],[2,4]] 输出：1
思路总结：在1的基础上，冲撞的问题可以转化为占用资源的问题，即会有几个人同时占用资源，注意有一点，出现开始与结束时间相同的情况下，这种情况要先结束后开始，否则会出现多开一个会议室的局面。

class Solution {
    public int minMeetingRooms(int[][] intervals) {
        int[][] inte = new int[intervals.length * 2][2];
        int res = 0;
        int cur = 0;
        for( int i = 0; i < intervals.length * 2; i+=2 ){
            inte[i][0] = intervals[i / 2][0];
            inte[i][1] = 1;
            inte[i + 1][0] = intervals[i / 2][1];
            inte[i + 1][1] = -1;
        }

        Arrays.sort(inte, new Comparator<>(){
            public int compare(int[] a, int[] b){
                return a[0] == b[0] ? a[1] - b[1] : a[0] - b[0];
            } 
        });
        for( int[] a : inte ){
            cur += a[1];
            res = Math.max(cur, res);
        }
        return res;
    }
}

后续会出一个重叠区间类题目的专题，做一个综合整理，如果有更好的解法欢迎留言交流。