131. Building Outline

最新推荐文章于 2025-11-29 20:55:25 发布
原创 最新推荐文章于 2025-11-29 20:55:25 发布 · 572 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #lintcode

本文介绍了一种使用最大堆和最小堆来减少排序消耗的方法，从而高效地找出一组建筑物的外轮廓线。通过灵活拆分和比较建筑数据，该算法能够处理复杂的重叠情况。

画建筑轮廓

LintCode链接

题目描述

水平面上有 N 座大楼，每座大楼都是矩阵的形状，可以用一个三元组表示 (start, end, height)，分别代表其在x轴上的起点，终点和高度。大楼之间从远处看可能会重叠，求出 N 座大楼的外轮廓线。
外轮廓线的表示方法为若干三元组，每个三元组包含三个数字 (start, end, height)，代表这段轮廓的起始位置，终止位置和高度。
参考下面的图，黑色线为建筑，红色线即为建筑的轮廓线

样例
对于下面三个链表，输出-1->2->4->null
[
  2->4->null,
  null,
  -1->null
],

思路

  1. 首先肯定能想到的是需要对输入的所有数据进行排序，排序规则应该也很好想：
    • 如果start相等，height相等，则end大的在前面
    • 如果start相等，则height大的在前面
    • start小的在前面
  2. 考虑到以下两种情况
    • [1,5,3],[2,3,5]，这种情况下，需要输出[1,2,3], [2,3,5], [3,5,3]
    • [1,5,5],[2,6,3], 这种情况下，需要输出[1.5,5], [5,6,3]
  3. 考虑情景2中的两种情况，我们需要在比较过程中把建筑灵活的进行拆分，然后重新加入到待比较的数组中，再进行排序，每次排序肯定不现实，所以用到了最大最小堆来减少排序带来的消耗

代码

class Solution {
public:
    /*
    * @param buildings: A list of lists of integers
    * @return: Find the outline of those buildings
    */
    vector<vector<int>> buildingOutline(vector<vector<int>> &buildings) {
        // write your code here

        vector<vector<int>> ret;

        if (buildings.empty())
        {
            return ret;
        }

        auto func = [](vector<int> &left, vector<int> &right) {
            if (left[0] == right[0] && left[2] == right[2])
            {
                return left[1] < right[1];
            }

            if (left[0] == right[0])
            {
                return left[2] < right[2];
            }

            return left[0] > right[0];
        };
        // 建堆;
        make_heap(buildings.begin(), buildings.end(), func);

        pop_heap(buildings.begin(), buildings.end(), func);
        vector<int> cur_outline = *buildings.rbegin();
        buildings.pop_back();

        while (buildings.empty() == false)
        {
            pop_heap(buildings.begin(), buildings.end(), func);
            vector<int> building = *buildings.rbegin();
            buildings.pop_back();

            if (building[0] > cur_outline[1])
            {
                // 建筑与当前轮廓分离;
                ret.push_back(cur_outline);
                cur_outline = building;
            }
            else if (building[2] > cur_outline[2])
            {
                // 建筑与当前轮廓未分离，并且高度比当前高;
                if (building[1] < cur_outline[1])
                {
                    // 该建筑没有当前轮廓宽，生成新的建筑;
                    vector<int> new_building = { building[1], cur_outline[1], cur_outline[2] };
                    buildings.push_back(new_building);
                    push_heap(buildings.begin(), buildings.end(), func);
                }

                cur_outline[1] = building[0];
                ret.push_back(cur_outline);
                cur_outline = building;
            }
            else if (building[2] == cur_outline[2])
            {
                // 建筑与当前轮廓未分离，并且高度相等，则看是否合并轮廓;
                cur_outline[1] = max(cur_outline[1], building[1]);
            }
            else if (building[2] < cur_outline[2])
            {
                // 建筑与当前轮廓未分离，并且高度比当前小;
                if (building[0] == cur_outline[1])
                {
                    // 正好在边缘;
                    ret.push_back(cur_outline);
                    cur_outline = building;
                }
                else if (building[1] > cur_outline[1])
                {
                    // 有重叠，并且该建筑比当前轮廓宽，生成新的建筑;
                    vector<int> new_building = { cur_outline[1], building[1], building[2] };
                    buildings.push_back(new_building);
                    push_heap(buildings.begin(), buildings.end(), func);
                }
            }
        }

        ret.push_back(cur_outline);
        return ret;
    }
};
附上我的测试代码
void printfOutline(vector<vector<int>> &outline)
{
    cout << "[" << endl;
    for (auto &i : outline)
    {
        cout << "\t[";
        for (auto j : i)
        {
            cout << j << ",";
        }
        cout << "]" << endl;
    }
    cout << "]" << endl;
}

int main()
{
    Solution s;
    {
        vector<vector<int>> input = { {1, 3, 3}, { 2, 4, 4 }, { 5, 6, 1} };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    {
        // {1,3,3}
        vector<vector<int>> input = { { 1, 3, 3 } };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    {
        // {1,3,5}
        vector<vector<int>> input = { { 1, 3, 3 }, {1,3,5} };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    {
        // {1,3,5}, {3,4,3}
        vector<vector<int>> input = { { 1, 4, 3 },{ 1,3,5 } };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    {
        // {1,2,3}, {2,3,5}, {3,4,3}
        vector<vector<int>> input = { { 1, 4, 3 },{ 2,3,5 } };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    {
        // {1,5,5}
        vector<vector<int>> input = { { 1, 4, 5 },{ 4,5,5 } };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    {
        // {1,4,5}
        vector<vector<int>> input = { { 1, 4, 5 },{ 2,3,3 } };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    {
        // {1,2,3},{2,5,5}
        vector<vector<int>> input = { { 1, 4, 3 },{ 2,5,5 } };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    {
        // {1,5,3}
        vector<vector<int>> input = { { 1, 4, 3 },{ 2,5,3 } };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    {
        // {1,4,5},{4,5,3}
        vector<vector<int>> input = { { 1, 4, 5 },{ 2,5,3 } };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    {
        // {1,4,3}
        vector<vector<int>> input = { { 1, 4, 3 },{ 1,3,3 } };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    {
        // {1,4,3}
        vector<vector<int>> input = { { 1, 4, 3 },{ 1,4,3 } };
        vector<vector<int>> out = s.buildingOutline(input);
        printfOutline(out);
    }

    while (1);
}
【Lintcode】Building Outline
weixin_30697239的博客
02-19 112
class Solution { public: /** * @param buildings: A list of lists of integers * @return: Find the outline of those buildings */ set<int> loc; ...
Lintcode 131 Building Outline
earthma的专栏
05-08 2927
这道题确实挺纠结的，在Lintcode上过的也挺奇葩，有时候能过，有时候又过不了，但总体而言还是过了，写一下记录一下思路 刚开始想的是用堆将大楼从高到低开始找轮廓，但是每次大楼分裂，或者从前面找到结果时，需要把vector里面的元素右移，复杂度太高，自然是过不了，只能过到第17组数据 后来就改成了按坐标从左至右扫描大楼边的方式，并通过大堆记录当前楼的最高值，依次
LintCode_131 Building Outline
Bernini @ buffalo
08-09 368
Given N buildings in a x-axis，each building is a rectangle and can be represented by a triple (start, end, height)，where start is the start position on x-axis, end is the end position on x-axis and
building outline 问题及set, mutilset以及堆的一些理解
binling的专栏
05-26 963
1扫描线法，需要考虑的就是当来一条竖线的时候，需要更新什么 2本例中，只需要考虑 是否更新当前最高高度的起点curX，是否产生一个输出。还有扫描线法固定的步骤：当起点来时候加进一个高度，当终点来时移除对应的高度。 3循环不变式：curX是当前outline的起点，堆里的最大高度就是当前outline的高度。当一个面来时： 1）堆是空的（没有建筑）进入一个outline, 记录curX 2）
Lintcode131 Building Outline solution 题解
nekomilk的博客
09-24 325
【题目描述】 GivenNbuildings in a x-axis，each building is a rectangle and can be represented by a triple (start, end, height)，where start is the start position on x-axis, end is the end position on x-a
【2023.06.11】复现论文《TOWARD AUTOMATIC BUILDING FOOTPRINT DELINEATION FROM AERIAL IMAGES》
KLeinLAN的博客
06-11 742
最近pua老师一直让我不停给毕设做实验，无奈去给他打工。实话来说毕设工作并不开心，其实自己是有许多想法，但是被他打击后并不想在这篇工作里继续深挖，只想着早日毕业，自己在工作之外多多读文献，练练编程~最近武大的师兄建了个pytorch学习群，让我们几个即将入学的研0同学互相学习交流，这篇博客写的目的也是记录一下论文复现过程。
Introduction to Model Building -Outline
11-25
该文件是关于混合动力车辆系统建模入门的短期课程大纲，使用Matlab中的Simulink进行模型构建。课程内容覆盖了从基础的系统设置到模型的创建，再到模型改进和控制方法的实现。 首先，课程会引导学习者了解Simulink的...
Building.Great.Software.Engineering.Teams.1484211340
07-14
He draws on this experience to outline specific, detailed solutions augmented by instructive stories from his own experience. In this book you’ll learn how to build your team, starting with your ...
LintCode 131. 大楼轮廓 python实现
weixin_44133727的博客
08-26 420
题目描述（链接） 水平面上有 N 座大楼，每座大楼都是矩阵的形状，可以用一个三元组表示 (start, end, height)，分别代表其在x轴上的起点，终点和高度。大楼之间从远处看可能会重叠，求出 N 座大楼的外轮廓线。 外轮廓线的表示方法为若干三元组，每个三元组包含三个数字 (start, end, height)，代表这段轮廓的起始位置，终止位置和高度。 输入: [ [1, 3, 3],...
Building.Database.Clouds.in.Oracle.12c.0134310861
11-16
The authors first explain the key concepts underlying DBaaS, describe cloud computing implementations related to it, and outline the business and technology benefits. Next, they show how the Oracle ...
C++对象在作为函数参数时候的拷贝研究
Drecik__的专栏
02-06 3335
介绍C++对象在作为函数参数以及返回值的copy策略一直是我困扰的一个问题，特别是在今天看到了C++11的新增加的特性std::move以及右值概念之后，激发了我的求知欲，决定把这一块详细的搞清楚。测试对象代码写了个简单的测试对象，在每个不同的构造函数以及析构函数中打印logclass A { public: A() { cout << "construct" <<
75. Find Peak Element
Drecik__的专栏
02-06 422
查找无续数组的峰值LintCode链接题目说明给出一个整数数组(size为n)，其具有以下特点： - 相邻位置的数字是不同的 - A[0] < A[1] 并且 A[n - 2] > A[n - 1]假定P是峰值的位置则满足A[P] > A[P-1]且A[P] > A[P+1]，返回数组中任意一个峰值的位置。样例给出数组[1, 2, 1, 3, 4, 5, 7, 6]返回1, 即数值 2 所在位置
81. Data Stream Median
Drecik__的专栏
02-06 418
数组最中间值LintCode链接题目描述输入的一组数字，返回每次输入新数字之后，该序列的最中间值 说明最中间值的意思是指，一个有序数组的最中间的那个值。如果这个有序数组A的长度n为偶数，则中间值为A[n/2]，如果为奇数，中间值为A[(n-1)/2]。例如：如果A=[1,2,3], 中间值为2. 如果A=[1,19], 中间值为1.样例给定输入数字为: [1, 2, 3, 4, 5], 返回 [
86. Binary Search Tree Iterator
Drecik__的专栏
02-06 336
遍历二查找叉树LintCode链接题目描述设计一个迭代器，该迭代器可以按照以下要求一棵二叉查找树 - 遍历的顺序按照从小到大的排序规则 - next与hasNext的时间复杂度平均为O(1)样例对于下面的二叉树，使用迭代器遍历将按照如下顺序遍历：[1, 6, 10, 11, 12] 10 / \ 1 11 \ \ 6 12思路首先需要理解二叉查
104. Merge k Sorted Lists
Drecik__的专栏
02-06 316
合并k个已排序的链表LintCode链接题目描述合并k个已排序的链表样例对于下面三个链表，输出-1->2->4->null [ 2->4->null, null, -1->null ],思路对于写过归并排序的人来说，题目比较简单，思路就是从k个链表中，找到当前最小的元素，插入到返回的链表中，并从被选择的链表中删除这元素代码class Solution { public: /**
华为OD机试双机位C卷 - 敌情监控 (C++ & Python & JAVA & JS & GO)
qq_45776114的博客
11-29 578
华为OD机试 双机位C卷 敌情监控，提供Java、C++、Python、Go、JavaScript源码实现，并提供完整思路讲解。
C++课后习题训练记录Day38
zmzb0103的博客
11-29 122
在蓝桥云课中选择课程《16届蓝桥杯省赛无忧班（C&C++ 组）4期》，选择第一章中“竞赛常用库函数”课程7并开始练习。输入一个字符，判断其为大写还是小写，若为大写则转换为小写，若为小写则转换为大写，输出转换后的值。（3）练习心得：注意每段代码末尾的分号是否存在，如不存在则需即使补充；对此代码进行检验，检验后无报错，提交此代码，判题结果为正确100分。是否切换为英语模式；
2025年03月CCF-GESP编程能力等级认证C++编程一级真题解析
最新发布
人生就是一个不断学习的过程
11-29 38
本文收录了C++等级认证CCF-GESP的真题解析，包含单选题30分（15题）、判断题20分（10题）和编程题50分（2题）。单选题涉及C++基础语法、变量命名、运算符优先级等知识点；判断题考察对语言特性的理解；编程题包含"图书馆老鼠啃书"和"整数四舍五入"两个实际问题。所有题目均提供标准答案，其中编程题给出了完整代码实现，适合备考者系统复习C++基础知识和编程能力。
outline知识库
04-03
### Outline 知识库使用指南及相关资源 Outline 是一种高效的开源知识管理工具，支持团队协作和信息共享。它不仅提供了友好的界面用于创建、编辑和分类文档，还通过其 API 接口实现了更深层次的功能扩展[^1]。 #### 官方文档与基础设置 Outline 的官方文档是获取基础知识的最佳起点。可以通过访问 [Outline官方网站](https://www.getoutline.com) 获取详细的安装说明、配置选项以及基本操作指导[^3]。这些内容涵盖了从零开始搭建 Outline 实例的过程，适合初学者快速上手。 #### 高级功能：API 和 LangChain 整合 如果希望利用 Outline 提供的高级功能，则可以参考其 API 文档。该 API 支持多种请求方式，允许开发者提取存储于 Outline 中的数据，并与其他系统集成。例如，在文章中提到过的一个案例就是将 Outline 与 LangChain 结合起来构建智能检索器[^4]。这种组合使得用户不仅可以轻松存取已有数据，还能借助自然语言处理技术实现更加精准的知识查询。 以下是基于 Python 调用 Outline API 的简单示例代码： ```python import requests def fetch_documents(api_key, collection_id): url = f"https://your-outline-instance/api/collections/{collection_id}/documents" headers = {"Authorization": f"Bearer {api_key}"} response = requests.get(url, headers=headers) if response.status_code == 200: return response.json() else: raise Exception(f"Failed to retrieve documents: {response.text}") # 替换为实际使用的 api key 和 collection id api_key = 'YOUR_API_KEY' collection_id = 'COLLECTION_ID' try: docs = fetch_documents(api_key, collection_id) print(docs) except Exception as e: print(e) ``` 此脚本展示了如何通过 RESTful API 访问特定集合下的所有文档列表[^2]。 #### 学习路径建议 对于想要深入了解 Outline 功能及其潜在应用场景的人士来说，除了阅读上述提及的文章外，还可以查阅更多关于 **Retriever** 技术的相关资料。此外，“Building Intelligent Applications with LLMs” 这本书籍也值得推荐给那些对大型语言模型感兴趣的朋友。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值