先来看最多的线段重合数问题，给出一组线段集合，求最大重合线段数

求解过程：

 把一个线段生成一个对象
 开始位置start
 结束位置end
 选按开始位置排序
 [1,7]
 [1,4]
 [1,9]
 [2,13]
 [5,10]
 再搞一个有序表（按结束位置排序） 用TreeMap,TreeSet，或PriorityQueue都行
 弹出有序表中值小于等于开始位置的值，再把当前线段放入到有序表中
注（有序表中结束位置大于该开始位置说明该线段和有序表中的线段都有重合）

 处理开始位置1
 【4，7，9】

 处理开始位置2
 【4，7，9，13】

 处理开始位置5
 【7，9，10，13】

答案就是有序表中的值的个数

public class MaxRepeatLine {

    public  int maxConvers(int[] start,int[] end){
        if(start==null || end==null ||start.length!=end.length){
            return 0;
        }
        PriorityQueue<Line> startMinHeap=new PriorityQueue<>(start.length,(l1,l2)->l1.start-l2.start);
        for(int i=0;i<start.length;i++){
            if(start[i]!=end[i]){
                startMinHeap.add(new Line(start[i],end[i]));
            }
        }
        PriorityQueue<Line> endMinHeap=new PriorityQueue<>(start.length,(l1,l2)->l2.end-l1.end);
        int max=0;
        while (!startMinHeap.isEmpty()){
            Line cur=startMinHeap.poll();
            while (!endMinHeap.isEmpty()&&cur.start>=endMinHeap.peek().end){
                endMinHeap.poll();
            }
            endMinHeap.add(cur);
            max=Math.max(max,endMinHeap.size());
        }
        return max;
    }

    public class Line{
        public int start;
        public int end;
        public Line(int s,int e){
            this.start=s;
            this.end=e;
        }
    }
}

　

253. 会议室 II　

给你一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，

为避免会议冲突，同时要考虑充分利用会议室资源，请你计算至少需要多少间会议室，才能满足这些会议安排。

示例 1：

输入：intervals = [[0,30],[5,10],[15,20]]
输出：2
示例 2：

输入：intervals = [[7,10],[2,4]]
输出：1

 思路：

和线段重合问题求法 一样
转化为最大线段重合问题：计算至少需要多少间会议室实质也就是求最多的重合数，这些重合的会议都需要不同的会议室

class Solution {

      public class Meet{
        public int start;
        public int end;
        public Meet(int s,int e){
            this.start=s;
            this.end=e;
        }
    }

    public int minMeetingRooms(int[][] intervals) {
       
         PriorityQueue<Meet> startMinHead=new PriorityQueue<Meet>(intervals.length,(a,b)->a.start-b.start);

        for(int i=0;i<intervals.length;i++){
            startMinHead.add(new Meet(intervals[i][0],intervals[i][1]));
        }
        PriorityQueue<Meet> endMinHead=new PriorityQueue<>(intervals.length,(a,b)->a.end-b.end);
        int max=0;
        while(!startMinHead.isEmpty()){
            Meet cur=startMinHead.poll();
            while(!endMinHead.isEmpty()&&endMinHead.peek().end<=cur.start){
                endMinHead.poll();
            }
            endMinHead.add(cur);
            max=Math.max(max,endMinHead.size());
        }
        return max;
    
    }

  
}