218. The Skyline Problem *HARD* -- 矩形重叠

A city's skyline is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Now suppose you are given the locations and height of all the buildings as shown on a cityscape photo (Figure A), write a program to output the skyline formed by these buildings collectively (Figure B).

-->

The geometric information of each building is represented by a triplet of integers [Li, Ri, Hi], where Li and Ri are the x coordinates of the left and right edge of the ith building, respectively, and Hi is its height. It is guaranteed that 0 ≤ Li, Ri ≤ INT_MAX, 0 < Hi ≤ INT_MAX, and Ri - Li > 0. You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height 0.

For instance, the dimensions of all buildings in Figure A are recorded as: [ [2 9 10], [3 7 15], [5 12 12], [15 20 10], [19 24 8] ] .

The output is a list of "key points" (red dots in Figure B) in the format of [ [x1,y1], [x2, y2], [x3, y3], ... ] that uniquely defines a skyline. A key point is the left endpoint of a horizontal line segment. Note that the last key point, where the rightmost building ends, is merely used to mark the termination of the skyline, and always has zero height. Also, the ground in between any two adjacent buildings should be considered part of the skyline contour.

For instance, the skyline in Figure B should be represented as:[ [2 10], [3 15], [7 12], [12 0], [15 10], [20 8], [24, 0] ].

Notes:

• The number of buildings in any input list is guaranteed to be in the range [0, 10000].
• The input list is already sorted in ascending order by the left x position Li.
• The output list must be sorted by the x position.
• There must be no consecutive horizontal lines of equal height in the output skyline. For instance, [...[2 3], [4 5], [7 5], [11 5], [12 7]...] is not acceptable; the three lines of height 5 should be merged into one in the final output as such: [...[2 3], [4 5], [12 7], ...]

class Solution {

public:

    vector<pair<int, int>> getSkyline(vector<vector<int>>& buildings) {

        vector< pair<int, int> > edges;

        //put all of edge into a vector

        //set left edge as negtive, right edge as positive

        //so, when we sort the edges, 

        //  1) for same left point, the height would be descending order

        //  2) for same right point, the height would be ascending order

        int left, right, height;

        for(int i=; i<buildings.size(); i++) {

            left   = buildings[i][];

            right  = buildings[i][];

            height = buildings[i][];

            edges.push_back(make_pair(left, -height));

            edges.push_back(make_pair(right, height));

        }

        sort(edges.begin(), edges.end());

        // 1) if we meet a left edge, then we add its height into a `set`.

        //    the `set` whould sort the height automatically.

        // 2) if we meet a right edge, then we remove its height from the `set`

        //

        // So, we could get the current highest height from the `set`, if the 

        // current height is different with preivous height, then we need add

        // it into the result.

        vector< pair<int, int> > result;

        multiset<int> m;

        m.insert();

        int pre = , cur = ;

        for (int i=; i<edges.size(); i++){

            pair<int,int> &e = edges[i];

            if (e.second < ) {

                m.insert(-e.second);

            }else{

                m.erase(m.find(e.second));

            }

            cur = *m.rbegin();

            if (cur != pre) {

                result.push_back(make_pair(e.first, cur));

                pre = cur;

            }

        }

        return result;

    }

};

/*

* Sweep line with max-heap

* ------------------------

* Notice that "key points" are either the left or right edges of the buildings.

*

* Therefore, we first obtain both the edges of all the N buildings, and store the 2N edges in a sorted array.

* Maintain a max-heap of building heights while scanning through the edge array:

* 1) If the current edge is a left edge, then add the height of its associated building to the max-heap;

* 2) If the edge is a right one, remove the associated height from the heap.

*

* Then we take the top value of the heap (yi) as the maximum height at the current edge position (xi).

* Now (xi, yi) is a potential key point.

*

* If yi is the same as the height of the last key point in the result list, it means that this key point

* is not a REAL key point, but rather a horizontal continuation of the last point, so it should be discarded;

*

* otherwise, we add (xi,yi) to the result list because it is a real key point.

*

* Repeat this process until all the edges are checked.

*

* It takes O(NlogN) time to sort the edge array. For each of the 2N edges,

* it takes O(1) time to query the maximum height but O(logN) time to add

* or remove elements. Overall, this solution takes O(NlogN) time.

*/