Sweep Line

391. Number of Airplanes in the Sky

https://www.lintcode.com/problem/number-of-airplanes-in-the-sky/description?_from=ladder&&fromId=4

思路：将起飞时间和降落时间放到同一个数组中, 标识出是起飞还是降落时间, 然后对数组排序，遍历数组即可, 碰到起飞计数器加一, 碰到降落计数器减一. 维护最大值作为答案.

注意降落优先于起飞 可通过flag标记降落为0 上升为1，保证按time相等按flag排序降落为先

/**
 * 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;

    }
}

919. Meeting Rooms II

https://www.lintcode.com/problem/meeting-rooms-ii/description?_from=ladder&&fromId=4

/**
 * 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;
    }
}

821. Time Intersection

https://www.lintcode.com/problem/time-intersection/description?_from=ladder&&fromId=4

/**
 * 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;
    }
}

131. The Skyline Problem

https://www.lintcode.com/problem/the-skyline-problem/description?_from=ladder&&fromId=4

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;
    }
}