Acwing贪心（C++例题与答案）（顺序六）

区间问题

区间选点

一个题解

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010; // 最多有10w个区间

int n;
// -----------------问题一：重载怎么理解？----------------------------
// 定义结构体range，重载小于号按右端点排序
// 结构体中保存每个区间的左端点l与右端点r
// range[0].l表示 输入的第1个区间的左端点，右端点的表示同理
struct Range
{
    int l, r;
    bool operator< (const Range &W)const
    {
        return r < W.r;
    }
}range[N];

int main()
{
    scanf("%d", &n);
    // 读入n个区间
    for (int i = 0; i < n; i ++ ) scanf("%d%d", &range[i].l, &range[i].r);
    
    // 按右端点排序
    sort(range, range + n);
    
    // res表示当前点的数量，ed表示上一个区间的右端点
    int res = 0, ed = -2e9;
    for (int i = 0; i < n; i ++ )
        // 如果当前区间的左端点>上一个区间的右端点
        // 更新ed，res+1
        if (range[i].l > ed)
        {
            res ++ ;
            ed = range[i].r;
        }

    printf("%d\n", res);

    return 0;
}

最大不相交区间数量

一个题解

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010; // 最多有10w个区间

int n;
// -----------------问题一：重载怎么理解？----------------------------
// 定义结构体range，重载小于号按右端点排序
// 结构体中保存每个区间的左端点l与右端点r
// range[0].l表示 输入的第1个区间的左端点，右端点的表示同理
struct Range
{
    int l, r;
    bool operator< (const Range &W)const
    {
        return r < W.r;
    }
}range[N];

int main()
{
    scanf("%d", &n);
    // 读入n个区间
    for (int i = 0; i < n; i ++ ) scanf("%d%d", &range[i].l, &range[i].r);
    
    // 按右端点排序
    sort(range, range + n);
    
    // res表示当前点的数量，ed表示上一个区间的右端点
    int res = 0, ed = -2e9;
    for (int i = 0; i < n; i ++ )
        // 如果当前区间的左端点>上一个区间的右端点
        // 更新ed，res+1
        if (range[i].l > ed)
        {
            res ++ ;
            ed = range[i].r;
        }

    printf("%d\n", res);

    return 0;
}

区间分组

一个题解

#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 100010;

int n;
struct Range
{
    int l, r;
    // 重载<，按左端点排序
    bool operator< (const Range &W)const
    {
        return l < W.l;
    }
}range[N];

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ )
        scanf("%d%d", &range[i].l, &range[i].r);

    sort(range, range + n);
    
    // 用小根堆维护所有组的右端点的最大值
    // 堆中的每一个值存的是每个组的右端点的最大值
    priority_queue<int, vector<int>, greater<int>> heap;
    for (int i = 0; i < n; i ++ )
    {
        // 如果堆为空或者堆的最小右端点 >= 现在区间的左端点，则说明有交集，不能合并，需要新开一个堆
        if (heap.empty() || heap.top() >= range[i].l) heap.push(range[i].r);
        // 否则说明至少与最小的右端点的组没有交集，将它放到右端点最小的组里去
        else
        {
            heap.pop(); // 弹出这个区间的最小右端点，插入当前区间的右端点，即将其更新了
            heap.push(range[i].r);
        }
    }
    // 输出组的数量
    printf("%d\n", heap.size());

    return 0;
}

区间覆盖

一个题解

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int n;
struct Range
{
    int l, r;
    // 重载小于号，区间按左端点排序
    bool operator< (const Range &W)const
    {
        return l < W.l;
    }
}range[N];

int main()
{
    // 输入线段区间的两个端点
    int st, ed;
    scanf("%d%d", &st, &ed);
    // 输入n个区间
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ )
    {
        int l, r;
        scanf("%d%d", &l, &r);
        range[i] = {l, r};
    }
    
    // 对输入的区间按左端点排序
    sort(range, range + n);

    // 枚举每个区间，在所有能覆盖start的区间中，选择右端点最大的区间
    // 然后将start更新为当前选择区间的右端点
    int res = 0; // 用res存储所需区间的最少数量
    bool success = false; // success表示能否用这些区间将线段完全覆盖
    
    // 开始枚举n个区间
    for (int i = 0; i < n; i ++ )
    {
        int j = i, r = -2e9;
        // 找出能覆盖start的所有区间的右端点，取最大值
        while (j < n && range[j].l <= st)
        {
            r = max(r, range[j].r);
            j ++ ;
        }
        
        // 如果没有区间能覆盖start ，说明线段无法被覆盖，break，返回-1
        if (r < st)
        {
            res = -1;
            break;
        }
            
        // 否则res++
        res ++ ;
        
        // 如果已经覆盖完了，success置为true，break
        if (r >= ed)
        {
            success = true;
            break;
        }
        
        // 一段区间覆盖完成，将start更新为当前选择区间的右端点
        st = r;
        // 剪枝，直接跳到被选中的区间的下一个区间处
        i = j - 1;
    }

    if (!success) res = -1; // 如果不能完全覆盖线段，则置位-1
    printf("%d\n", res);

    return 0;
}

Huffman树

合并果子

一个题解

#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

int main()
{
    int n;
    scanf("%d", &n);

    priority_queue<int, vector<int>, greater<int>> heap;
    while (n -- )
    {
        int x;
        scanf("%d", &x);
        heap.push(x);
    }

    int res = 0;
    while (heap.size() != 1)
    {
        int a = heap.top(); heap.pop();
        int b = heap.top(); heap.pop();
        res += a + b;
        heap.push(a + b); // 注意这里是push a+b，不是push res
    }

    printf("%d\n", res);
    return 0;
}