第六章 贪心（一）

一、贪心区间问题

（一）905 区间选点

找出一组个数最少的点集，使得每个区间都至少包含其中的一个点

思路：按照区间的右边界排序。

证明：为什么这样选的点数是最小的

1、根据思路的过程，我们找到的所有点的集合是一组合法解。

2、ans（最优解）<= cnt(一个可行解)

3、按照思路我们最后得到的点集就是所有互不相交的区间。根据常识，最优解一定最少是需要这些个互不相交的区间的个数（cnt）个的，也就是ans>=cnt 

4、得证

#include<bits/stdc++.h>
using namespace std;
//905 区间选点
const int N=1e5+10;
struct Range
{
    int l,r;
    //重载小于号
    bool operator < (const Range &W)const
    {
        return r<W.r;
    }
}range[N];
int main()
{
    int n;
    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;
    for(int i=0;i<n;i++)
    {
        if(range[i].l>ed)ans++,ed=range[i].r;
    }
    cout<<ans<<endl;
    return 0;
}

(二) 908 最大不相交区间数量

与（一）完全相同

（三）906 区间分组

按照左端点进行分组，利用优先队列（小根堆）实现对目前所有分组的最右端的动态管理。

比最小的都小，就新建一个组，也就是新插入一个右端点参与排序；

#include<bits/stdc++.h>
using namespace std;
//906 区间分组
const int N=1e5+10;

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

int main()
{
    int n;
    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 t=range[i];
        //需要建立新的小组
        if(heap.empty()||heap.top()>t.l)heap.push(t.r);
       //不需要建立任何小组
        else
        {
           //更新某一个小组的最新情况
           heap.pop();//删除最小的那个
           heap.push(t.r);//添加到那个小组里面
        }
    }
    cout<<heap.size()<<endl;
    return 0;
}

（四）907 区间覆盖

给出一个大区间和一组小区间，找出能使得大区间覆盖的小区间数量的最小值。

按照左端点排序，然后找可以覆盖上次覆盖后的截止位置开始的位置的区间，并找出右端点最大的那个区间。

（第一次自己独立做出的贪心）

#include<bits/stdc++.h>
using namespace std;
//907 区间覆盖
const int N=1e5+10;
 int n;
//按照左端点排序
struct Range
{
    int l,r;
    bool operator <(const Range &W)const
    {
        return l<W.l;
    }
}range[N];

int cont(int L,int R)
{
    int ed=L;
    bool st[N];
    memset(st,true,sizeof(st));
    sort(range,range+n);
    int cnt=0;
    if(ed<range[0].l)return -1;//特殊情况第一个点都不能覆盖
    while(ed<R)
    {
      int idx,maxx=-2e9; 
       for(int i=0;i<n;i++)  //循环找最合适的
       {
           if(range[i].l<=ed)
           {
               if(st[i]&&range[i].r>maxx)
               {
                     maxx=range[i].r;
                     idx=i;
               }
           }
           else
           {
               break;
           }

       }
       if(maxx==-2e9)return -1;//在某次循环中没有找到任何一个合适的
       st[idx]=false;
       ed=range[idx].r;
       maxx=-2e9;
       cnt++;
    }
    return cnt;
}
int main()
{
    int L,R;
    cin>>L>>R;
    cin>>n;
    int flag=0;
    for(int i=0;i<n;i++)
    {
        int l,r;
        cin>>l>>r;
        range[i]={l,r};
        if(l<=L&&r>=R&&flag==0)//存在一个特殊区间可以整个覆盖掉直接输出
        {
            flag=1;
            cout<<1<<endl;
        }
    }
    if(!flag)
    {
        // cout<<"此时"<<flag<<endl;
         cout<<cont(L,R)<<endl;
    }
}

本题y做法是利用双指针，i进行n次遍历，每次让j从i开始向后找右边边界最大而且左边界是小于ed的。然后更新i为j，为什么要更新i呢，因为只要找到某个符合条件的j之后，它前面的所有线段一定是不可用的。

#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);
    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);

    int res = 0;
    bool success = false;
    for (int i = 0; i < n; i ++ )
    {
        int j = i, r = -2e9;
        while (j < n && range[j].l <= st)
        {
            r = max(r, range[j].r);
            j ++ ;
        }

        if (r < st)
        {
            res = -1;
            break;
        }

        res ++ ;
        if (r >= ed)
        {
            success = true;
            break;
        }

        st = r;
        i = j - 1;
    }

    if (!success) res = -1;
    printf("%d\n", res);

    return 0;
}


作者：yxc
链接：https://www.acwing.com/activity/content/code/content/65087/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

二、Huffman树

（一）148 合并果子

  自己ac啦

#include<bits/stdc++.h>
using namespace std;
//148 合并果子
const int N=1e5+10;

int main()
{
    priority_queue<int,vector<int>,greater<int>>heap;
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int num;
        cin>>num;
        heap.push(num);
    }
    if(heap.size()==1)
    {
        cout<<0<<endl;
        return 0;
    }
    int ant=0;
    while(!heap.empty())
    {
       int i=heap.top();
       heap.pop();
       ant+=i;
       if(heap.empty())break;
       int j=heap.top();
       heap.pop();
       ant+=j;
       if(heap.empty())break;
       heap.push(i+j);
    }

    cout<<ant<<endl;
    return 0;

}

y总做法：循环条件是只要堆里面有多于两个的点就行

#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);
    }

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


作者：yxc
链接：https://www.acwing.com/activity/content/code/content/65246/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。