LeetCode | 218. 天际线问题

城市的天际线是从远处观看该城市中所有建筑物形成的轮廓的外部轮廓。给你所有建筑物的位置和高度，请返回由这些建筑物形成的天际线 。

每个建筑物的几何信息由数组 buildings 表示，其中三元组 buildings[i] = [left_i, right_i, height_i] 表示：

left_i 是第 i 座建筑物左边缘的 x 坐标。
right_i 是第 i 座建筑物右边缘的 x 坐标。
height_i 是第 i 座建筑物的高度。
你可以假设所有的建筑都是完美的长方形，在高度为 0 的绝对平坦的表面上。

天际线 应该表示为由 “关键点” 组成的列表，格式 [[x1,y1],[x2,y2],…] ，并按 x 坐标 进行 排序 。关键点是水平线段的左端点。列表中最后一个点是最右侧建筑物的终点，y 坐标始终为 0 ，仅用于标记天际线的终点。此外，任何两个相邻建筑物之间的地面都应被视为天际线轮廓的一部分。

注意：输出天际线中不得有连续的相同高度的水平线。例如 […[2 3], [4 5], [7 5], [11 5], [12 7]…] 是不正确的答案；三条高度为 5 的线应该在最终输出中合并为一个：[…[2 3], [4 5], [12 7], …]

示例 1：

输入：buildings = [[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]]
输出：[[2,10],[3,15],[7,12],[12,0],[15,10],[20,8],[24,0]]
解释：
图 A 显示输入的所有建筑物的位置和高度，
图 B 显示由这些建筑物形成的天际线。图 B 中的红点表示输出列表中的关键点。
示例 2：

输入：buildings = [[0,2,3],[2,5,3]]
输出：[[0,3],[5,0]]
1
2
3
4
5
6
7
8
9

提示：

• 1 <= buildings.length <= 10⁴
• 0 <= left_i < right_i <= 2³¹ - 1
• 1 <= height_i <= 2³¹ - 1
• buildings 按 left_i 非递减排序

思路：扫描线加优先队列。
对于本题，对应的扫描线分割形状如图：

扫描线根据 x 大小排序，从左往右遍历。
维护一个优先队列，优先队列中保存建筑的右坐标和高度。遍历竖线，当竖线的 x 坐标在建筑的区间 $[l,r)$ 中时，建筑添加优先队列中；当竖线在 $[r,+\infty )$ 时，建筑出优先队列（当建筑的高度不是优先队列中最高的时，会延迟移出队列，但是因为建筑不是最高，所以不会影响结果）。

// 从左往右遍历每一条竖线（上图的红色线）
vector<vector<int>> getSkyline(vector<vector<int>>& buildings) {
    auto cmp = [](const pair<int, int>& a, const pair<int, int>& b) -> bool { return a.second < b.second; };
    priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(cmp)> que(cmp);

    vector<int> boundaries;
    for (auto& building : buildings) {
        boundaries.emplace_back(building[0]);
        boundaries.emplace_back(building[1]);
    }
    sort(boundaries.begin(), boundaries.end());

    vector<vector<int>> ret;
    int n = buildings.size(), idx = 0;
    for (auto& boundary : boundaries) {
        while (idx < n && buildings[idx][0] == boundary) { // 竖线进入建筑的区间 [l, r) 中，建筑添加到队列；用 while 是因为可能出现多个建筑的左边界重合的情况
            que.emplace(buildings[idx][1], buildings[idx][2]);
            idx++;
        }
        while (!que.empty() && que.top().first <= boundary) { // 当竖线不在建筑的区间中（竖线的x坐标大于或等于建筑的右边坐标）时，建筑移除优先队列；用while是因为多个建筑右边界重合的情况
            que.pop();
        }

        int maxn = que.empty() ? 0 : que.top().second; // 竖线在建筑中，取所在建筑中最高的高度
        if (ret.size() == 0 || maxn != ret.back()[1]) { // 只要和前面一个关键点的y值不一样，就是新的关键点
            ret.push_back({boundary, maxn});
        }
    }
    return ret;
}

// 从左往右遍历，队列为空时，竖线 cur_X 是当前建筑的左边界；队列不为空时，竖线是队列中最高建筑的右边界
// 只有在这两个地方，会产生关键点。（这种遍历方式可以跳过一些竖线不遍历；每个建筑都遍历了左边界，加入到队列中，
// 如果建筑不是最高的建筑，跳过建筑的右边界，不遍历）
vector<vector<int>> getSkyline(vector<vector<int>>& buildings) {
    vector<vector<int>> res;
    int cur = 0, len = buildings.size();
    priority_queue<pair<int, int>> liveBlg; // 保存高度 和 y 坐标
    while (cur < len || !liveBlg.empty()) {
        int cur_X = liveBlg.empty() ? buildings[cur][0] : liveBlg.top().second; 

        if (cur >= len || buildings[cur][0] > cur_X) { // 所有的建筑遍历完，或者当前建筑的x坐标比竖线要大，前面遍历完的建筑要出队列
            while (!liveBlg.empty() && liveBlg.top().second <= cur_X) {
                liveBlg.pop(); 
            }
        } else { 
            cur_X = buildings[cur][0];
            while (cur < len && buildings[cur][0] == cur_X) { //竖线在建筑的左坐标上时，建筑添加到优先队列
                liveBlg.emplace(buildings[cur][2], buildings[cur][1]);
                cur++;
            }
        }
        
        int cur_H = liveBlg.empty() ? 0 : liveBlg.top().first;
        if (res.empty() || (res.back()[1] != cur_H)) {
            res.push_back({cur_X, cur_H});
        }
    }
    return res;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60