Sweep Line

/**
 * Definition of Interval:
 * public classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 * }
 */
 
class Point{
    int time;
    int flag;

    Point(int t, int s) {
        this.time = t;
        this.flag = s;
    }
    public static Comparator<Point> PointComparator = new Comparator<Point>() {
        public int compare(Point p1, Point p2) {
            if(p1.time == p2.time) 
                return p1.flag - p2.flag;
            else 
                return p1.time - p2.time;
      }
    };
}
   

public class Solution {
    /**
     * @param airplanes: An interval array
     * @return: Count of airplanes are in the sky.
     */
    public int countOfAirplanes(List<Interval> airplanes) {
        // write your code here
        List<Point> list = new ArrayList<>(airplanes.size()*2);
        for(Interval i:airplanes){
            list.add(new Point(i.start,1));
            list.add(new Point(i.end,-1));
        }
        
        Collections.sort(list,Point.PointComparator);
        int count=0,ans =1;
        for(Point p:list){
            if(p.flag==1)
                count++;
            else
                count--;
            
            ans = Math.max(ans,count);
        }
        
        return ans;
        
        
    }
}

/**
 * Definition of Interval:
 * public classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 * }
 */
class Meeting{
    int time;
    int flag;
    public Meeting(int time,int flag){
        this.time = time;
        this.flag = flag;
    }
    
    public static Comparator<Meeting> comparator = new Comparator<Meeting>(){
        @Override
        public int compare(Meeting m1, Meeting m2){
            if(m1.time==m2.time){
                return m1.flag - m2.flag;
            }
            return m1.time-m2.time;
        }
    };
}
public class Solution {
    /**
     * @param intervals: an array of meeting time intervals
     * @return: the minimum number of conference rooms required
     */
    public int minMeetingRooms(List<Interval> intervals) {
        // Write your code here
        if(intervals == null || intervals.size()==0){
            return 0;
        }
        
        List<Meeting> meetings = new ArrayList<>();
        for(Interval i:intervals){
            meetings.add(new Meeting(i.start,1));
            meetings.add(new Meeting(i.end,-1));
        }
        
        Collections.sort(meetings,Meeting.comparator);
        
        int count =0;
        int ans =0;
        for(Meeting m:meetings){
            if(m.flag==1){
                count++;
            }
            
            if(m.flag==-1){
                count--;
            }
            
            ans = Math.max(ans,count);
        }
        
        return ans;
    }
}

/**
 * Definition of Interval:
 * public classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 * }
 */
class Point{
    int time;
    int flag;

    Point(int t, int s) {
        this.time = t;
        this.flag = s;
    }
    public static Comparator<Point> PointComparator = new Comparator<Point>() {
        public int compare(Point p1, Point p2) {
            if(p1.time == p2.time) 
                return p1.flag - p2.flag;
            else 
                return p1.time - p2.time;
      }
    };
}

public class Solution {
    /**
     * @param seqA: the list of intervals
     * @param seqB: the list of intervals
     * @return: the time periods
     */
    public List<Interval> timeIntersection(List<Interval> seqA, List<Interval> seqB) {
        // Write your code here
        List<Interval> res = new ArrayList<>();
        if(seqA==null || seqB==null){
            return res;
        }
        
        List<Point> list = new ArrayList<>();
        for(Interval i:seqA){
            list.add(new Point(i.start,1));
            list.add(new Point(i.end,-1));
        }
        
        for(Interval i:seqB){
            list.add(new Point(i.start,1));
            list.add(new Point(i.end,-1));
        }
        
        Collections.sort(list,Point.PointComparator);
        
        int start =-1;
        int count=0;
        for(Point p:list){
            if(p.flag==1)
                count++;
            else
                count--;
            
            if(count==2){
                start = p.time;
            }
            
            if(count==1 && start!=-1){
                res.add(new Interval(start,p.time));
                start = -1;
            }
        }
        
        return res;
    }
}

class Pair implements Comparable{
    int index; //坐标
    int status; //是up还是down
    int height; //高度
    
    Pair(int index,int status,int height){
        this.index = index;
        this.status = status;
        this.height = height;
    }
    
    //先按坐标，再按status，再按高度
    public int compareTo(Object o){
        Pair p = (Pair)o;
        if(this.index==p.index){
            if(this.status==p.status){
                return this.height - p.height;
            }else{
                return this.status - p.status;
            }
        }else{
            return this.index- p.index;
        }
    }
    
}
public class Solution {
    /**
     * @param buildings: A list of lists of integers
     * @return: Find the outline of those buildings
     */
    private static int UP = 0;
    private static int DOWN = 1;
    public List<List<Integer>> buildingOutline(int[][] buildings) {
        // write your code here
        List<List<Integer>> res = new ArrayList<>();
        if(buildings ==null || buildings.length==0||buildings[0].length==0){
            return res;
        }
        
        List<Pair> pairs = new ArrayList<>();
        for(int i=0;i< buildings.length;i++){
            pairs.add(new Pair(buildings[i][0],UP,buildings[i][2]));
            pairs.add(new Pair(buildings[i][1],DOWN,buildings[i][2]));
        }
        
        Collections.sort(pairs);
        
        TreeMap<Integer,Integer> heightMap = new TreeMap<>();
        
        int preIndex =0;
        int preHeight =0;
        for(Pair pair:pairs){
            if(!heightMap.containsKey(pair.height)){
                heightMap.put(pair.height,1);
            }else{
                if(pair.status==UP){
                    heightMap.put(pair.height,heightMap.get(pair.height)+1);
                }else{
                    heightMap.put(pair.height,heightMap.get(pair.height)-1);
                    if(heightMap.get(pair.height)==0){
                        heightMap.remove(pair.height);
                    }
                }
            }
            
            int currHeight = heightMap.size()==0?0:heightMap.lastKey();
            
            if(preHeight!=currHeight){
                if(preHeight!=0 && preIndex!=pair.index){
                    res.add(eachSkyLine(preIndex,pair.index,preHeight));
                }
                
                preHeight = currHeight;
                preIndex = pair.index;
            }
        }
        
        return res;
    
    }
    
    private List<Integer> eachSkyLine(int start,int end,int height){
        List<Integer> list = new ArrayList<>();
        list.add(start);
        list.add(end);
        list.add(height);
        return list;
    }
}