LeetCode | 218. 天际线问题

news2025/11/15 17:55:44

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

每个建筑物的几何信息由数组 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 <= buildings.length <= 10⁴
0 <= left_i < right_i <= 2³¹ - 1
1 <= height_i <= 2³¹ - 1
buildings 按 left_i 非递减排序

思路：扫描线加优先队列。
对于本题，对应的扫描线分割形状如图：
在这里插入图片描述
扫描线根据 x 大小排序，从左往右遍历。
维护一个优先队列，优先队列中保存建筑的右坐标和高度。遍历竖线，当竖线的 x 坐标在建筑的区间 $[l, 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) { // 用 while 是因为可能出现多根竖线重合的情况
            que.emplace(buildings[idx][1], buildings[idx][2]);
            idx++;
        }
        while (!que.empty() && que.top().first <= boundary) { // 当竖线不在建筑的区间中（竖线的x坐标大于或等于建筑的右边坐标）时，建筑移除优先队列
            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;
}

// 
vector<vector<int>> getSkyline(vector<vector<int>>& buildings) {
    vector<vector<int>> res;
    int cur = 0, cur_X, cur_H, len = buildings.size();
    priority_queue<pair<int, int>> liveBlg; // 保存高度 和 y 坐标
    while (cur < len || !liveBlg.empty()) {
        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++;
            }
        }
        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;
}