贪心算法——个人笔记（1）

贪心算法是一种比较短视的策略，通过局部最优解得到全局最优解，难点在于证明，一般做法可能对于个人而言是（猜+证明）

例题1：区间选点

给定 NN 个闭区间 [ai,bi][ai,bi]，请你在数轴上选择尽量少的点，使得每个区间内至少包含一个选出的点。输出选择的点的最小数量。位于区间端点上的点也算作区间内。

输入格式：第一行包含整数 NN，表示区间数。接下来 NN 行，每行包含两个整数 ai,biai,bi，表示一个区间的两个端点。

输出格式：输出一个整数，表示所需的点的最小数量。

思路：

证明一下ans <= cnt的情况，考虑一般情况和特殊的情况，一般来说存在多个区间包含至少一个公共点以及不同的重复点以及穿插情况，所以答案是要小于等于点数量，证明ans>=cnt的情况，也就是特殊情况，每一个区间可能都没有交集，并且每一个区间的右端点不和下一个区间的左端点重合，这样所得到的答案是大于等于点数量

对所有区间右端点排一下序，然后枚举后面的每一个区间，如果包含的话就过掉，否则选取右端点

代码如下：

#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 r < W.r;
    }
}Range[N];

int main(){ 
    cin >> n;                        //区间个数
    for (int i = 0 ; i < n ; i++){   //输入所有的区间
        int l , r;
        cin >> l >> r;
        Range[i] = {l ,r};
    }
    
    sort(Range , Range + n);         //对区间进行排序
    
    int ans = 0 , ed = -2e9;         //ed是上一个区间的下标，初始设为负无穷
    
    for(int i = 0 ; i < n ; i++){    //如果左端点大于上一个下标，ans自增，当前选择点下标
        if(Range[i].l > ed){         //更新成右端点
            ans++;
            ed = Range[i].r;
        }
    }
    cout << ans << endl;
    
    return 0;
}

例题2：区间分组

给定 NN 个闭区间 [ai,bi][ai,bi]，请你将这些区间分成若干组，使得每组内部的区间两两之间（包括端点）没有交集，并使得组数尽可能小。输出最小组数。

输入格式：第一行包含整数 NN，表示区间数。接下来 NN 行，每行包含两个整数 ai,biai,bi，表示一个区间的两个端点。

输出格式：输出一个整数，表示最小组数。

思路：

将所有的区间按照左端点进行排序，从前向后处理每个区间，需要判断一下能不能将区间放到组里，不能就开一个新组，能的话就放入并且更新右端点的最大值

代码如下：

#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(){
    
    cin >> n;
    for(int i = 0 ; i < n ; i++){
        int l , r;
        cin >> l >> r;
        range[i] = {l , r};
    }
    
    sort(range , range + n);
    
    
    priority_queue<int , vector<int> , greater<int>> heap; //用小根堆维护组的右端点和最大值
    
    for(int i = 0 ; i < n ; i++){
        
        auto r = range[i];     //用r来表示当前的组
        if(heap.empty() || heap.top() >= r.l) heap.push(r.r);
        //如果当前组是空的或者最小值都大于等于当前左端点的话，要开一个新组
        else{    //否则要放入最小值的组中
            int t = heap.top();  
            heap.pop();
            heap.push(r.r);
        }
    }
    
    cout << heap.size() << endl;
    
    return 0;
    
}

例题3：区间覆盖

给定 NN 个闭区间 [ai,bi][ai,bi] 以及一个线段区间 [s,t][s,t]，请你选择尽量少的区间，将指定线段区间完全覆盖。输出最少区间数，如果无法完全覆盖则输出 −1−1。

输入格式：第一行包含两个整数 ss 和 tt，表示给定线段区间的两个端点。第二行包含整数 NN，表示给定区间数。接下来 NN 行，每行包含两个整数 ai,biai,bi，表示一个区间的两个端点。

输出格式：输出一个整数，表示所需最少区间数。如果无解，则输出 −1−1。

思路：

首先先将所有左端点进行排序，从前向后枚举每个区间，在可以覆盖start区间中，选择最大的右端点，并且将start更新为最大的右端点继续开始向后枚举

代码如下：

#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;
    cin >> st >> ed;
    cin >> n;
    
    for(int i = 0 ; i < n ; i++){
        int l , r;
        cin >> l >> r;
        range[i] = {l , r};
    }
    
    sort(range , range + n);     //对左端点进行排序
    
    int ans = 0;
    bool flag = false;           //设置一个flag判断有没有get到右端点
    for(int i = 0 ; i < n ; i++){
        
        int j = i , r = -2e9;     
        while(j < n && range[j].l <= st){ //小于数量并且左端点小于start开始
            r = max(r , range[j].r);   //选取较大的右端点保存
            j++;                     
        }
        
        if(r < st){        //当右端点一直是小于start端点的时候，那么直接判定为-1，直接
            ans = -1;
            break;
        }
        
        ans++;             //答案个数自加
        
        if(r >= ed){       //如果右端点大于end端点，那么是可以找到右端点的，也可在此break
            flag = true;
            break;
        }
        
        st = r;         //此处要将刚刚得到的右端点当做新的start端点，我理解为砍掉
        i = j - 1;      //刚刚得到的区间，从新的点开始在循环如上的过程直到找到所有覆盖的区间
    }
    if(!flag) ans = -1;              //输出
    
    cout << ans << endl;
    
    return 0;
}

例题4：合并果子（典型贪心问题——Huffman树）

在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。达达决定把所有的果子合成一堆。每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。

可以看出，所有的果子经过 n−1n−1 次合并之后，就只剩下一堆了。达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可能地节省体力。

假定每个果子重量都为 11，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使达达耗费的体力最少，并输出这个最小的体力耗费值。

例如有 33 种果子，数目依次为 1，2，91，2，9。可以先将 1、21、2 堆合并，新堆数目为 33，耗费体力为 33。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为 1212，耗费体力为 1212。所以达达总共耗费体力=3+12=15=3+12=15。可以证明 1515 为最小的体力耗费值。

输入格式：输入包括两行，第一行是一个整数 nn，表示果子的种类数。第二行包含 nn 个整数，用空格分隔，第 ii 个整数 aiai 是第 ii 种果子的数目。

输出格式：输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。输入数据保证这个值小于 231231。

思路：满足最小的两个点，深度一定最深，且互为兄弟节点，思路基本跟Huffman树的一样，手绘一颗Huffman树就是果子堆累加的过程。

代码如下：

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

using namespace std;

int main(){
    int n;
    cin >> n;
    
    priority_queue<int , vector<int> , greater<int>> heap; // 设置一个优先队列
    while(n--){       //依次输入
        int x;
        cin >> x;
        heap.push(x);   //压入
    }
    
    int ans = 0;
    while(heap.size() > 1){    //只要当前果子还没有合成为最后一堆就继续循环
        int a = heap.top();
        heap.pop();
        int b = heap.top();
        heap.pop();
        ans += a + b;      
        heap.push(a + b);        //将a+b新组成的果子堆重新放入队列中
    }
    
    cout << ans << endl;
    
    return 0;
    
}