第六章 贪心 【完结】

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

#算法

贪心类题型没有固定的模板只有多做题，总结经验。
基本都熟练了

目录

905. 区间选点

在这里插入图片描述
https://www.acwing.com/problem/content/description/907/

本题和区间合并那种题几乎一样的思路，不过还是有差别的。
首先：按左端点从小到达排，这是没有悬念的必须做的。
这时候分析，会有如下几种情况：
情况一：
在这里插入图片描述
这种包含的情况，我们要选小的，因为我们要的是公共部分。
情况二：
在这里插入图片描述
这种相交的情况选，相交的。
情况三：
在这里插入图片描述
不相交的情况选b,个数加1。

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+10;
struct student 
{
    int x,y;
}stu[N];
bool cmp(student a,student b)
{
    return a.x<b.x;
}
int main(void)
{
    int n; cin>>n;
    
    for(int i=0;i<n;i++) cin>>stu[i].x>>stu[i].y;
    
    sort(stu,stu+n,cmp);
    
    int ans=1;
    int startx=stu[0].x,endx=stu[0].y;
    for(int i=1;i<n;i++)
    {
        if(stu[i].x<=endx&&stu[i].y<=endx) startx=stu[i].x,endx=stu[i].y;
        else if(stu[i].x<=endx&&stu[i].y>endx) startx=stu[i].x;
        else ans++,startx=stu[i].x,endx=stu[i].y;
    }
    cout<<ans<<endl;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
vector<PII> ve;
int main(void)
{
    int n; cin>>n;
    while(n--)
    {
        int l,r; cin>>l>>r;
        ve.push_back({l,r});
    }
    sort(ve.begin(),ve.end());
    int ans=0;
    int l=-1e9-10,r=-1e9-5;
    for(int i=0;i<ve.size();i++)
    {
        if(ve[i].first>r) l=ve[i].first,r=ve[i].second,ans++;
        else if(ve[i].second<=r) l=ve[i].first,r=ve[i].second;
        else if(ve[i].first<=r&&ve[i].second>=r) l=ve[i].first;
    }
    cout<<ans<<endl;
    return 0;
}

方法二 从小到大排序右端点：
在这里插入图片描述
因为我们选右端点，才可能尽量大的覆盖掉后面的区间

#include<cstdio>
#include<algorithm>
#include<iostream>
using namespace std;
const int N=1e5+10;
struct node
{
    int x,y;
}Node[N];
bool cmp(node a,node b)
{
    return a.y<b.y;
}
int main(void)
{
    int n; cin>>n;
    for(int i=0;i<n;i++) cin>>Node[i].x>>Node[i].y;
    sort(Node,Node+n,cmp);
    int ans=0;
    int flag=-1e9;
    for(int i=0;i<n;i++)
    {
        if(flag<Node[i].x) ans++,flag=Node[i].y;
    }
    cout<<ans<<endl;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
vector<PII> ve;
int main(void)
{
    int n; cin>>n;
    while(n--)
    {
        int l,r; cin>>l>>r;
        ve.push_back({r,l});
    }
    int flag=-1e9;
    int ans=0;
    sort(ve.begin(),ve.end());
    for(int i=0;i<ve.size();i++) if(flag<ve[i].second) ans++,flag=ve[i].first;
    cout<<ans<<endl;
    return 0;
}

908. 最大不相交区间数量

在这里插入图片描述
https://www.acwing.com/problem/content/910/

老规矩：左端点从小到大排序
第一种情况：
在这里插入图片描述
这种得选a,这样右边的区间的选择范围才会更大。
第二种情况：
在这里插入图片描述
此时不用变，还是a这样才会有更大的空间。
第三种情况：
在这里插入图片描述
选b，数量加1

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=1e5+10;
struct student
{
    int x,y;
}stu[N];
bool cmp(student a,student b)
{
    return a.x<b.x;
}
int main(void)
{
    int n; cin>>n;
    for(int i=0;i<n;i++) cin>>stu[i].x>>stu[i].y;
    sort(stu,stu+n,cmp);
    
    int ans=1;
    int startx=stu[0].x,endx=stu[0].y;
    
    for(int i=1;i<n;i++)
    {
        if(stu[i].y<endx) startx=stu[i].x,endx=stu[i].y;
        else if(stu[i].x>endx) ans++,startx=stu[i].x,endx=stu[i].y;
    }
    
    cout<<ans<<endl;
    return 0;
}

方法二：从小到大排序右端点

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+10;
struct node
{
    int x,y;
}Node[N];
bool cmp(node a,node b)
{
    return a.y<b.y;
}
int main(void)
{
    int n; cin>>n;
    for(int i=0;i<n;i++) cin>>Node[i].x>>Node[i].y;
    sort(Node,Node+n,cmp);
    int ans=0;
    int flag=-1e9;
    for(int i=0;i<n;i++)
    {
        if(Node[i].x>flag) ans++,flag=Node[i].y;
    }
    cout<<ans<<endl;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
vector< pair<int,int> > ve;
int main(void)
{
    int n; cin>>n;
    while(n--)
    {
        int l,r; cin>>l>>r;
        ve.push_back({r,l});
    }
    sort(ve.begin(),ve.end());
    int ans=0;
    int flag=-1e9-5;
    for(int i=0;i<ve.size();i++) if(ve[i].second>flag) ans++,flag=ve[i].first;
    cout<<ans<<endl;
}

906. 区间分组 【有意思】

在这里插入图片描述
https://www.acwing.com/problem/content/description/908/

在这里插入图片描述

#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
const int N=1e5+10;
struct node
{
    int x,y;
}Node[N];
bool cmp(node a,node b)
{
    return a.x<b.x;
}
int main(void)
{
    int n; cin>>n;
    for(int i=0;i<n;i++) cin>>Node[i].x>>Node[i].y;
    sort(Node,Node+n,cmp);
    priority_queue<int, vector<int>, greater<int> >heap;
    for(int i=0;i<n;i++)
    {
        if(heap.empty()||heap.top()>=Node[i].x)//组为空，或者任何一个组内都放不下
        {
            heap.push(Node[i].y);
        }
        else if(heap.top()<Node[i].x)//可以放进组内
        {
            heap.pop();//将原来的区间的最右值更新
            heap.push(Node[i].y);
        }
    }
    cout<<heap.size()<<endl;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
vector< pair<int,int> > ve;
priority_queue<int, vector<int>, greater<int> >heap;
int l,r,n;
int main(void)
{
    cin>>n;
    while(n--) cin>>l>>r, ve.push_back({l,r});
    sort(ve.begin(),ve.end());
    for(int i=0;i<ve.size();i++)
    {
        if(heap.empty()||heap.top()>=ve[i].first) heap.push(ve[i].second);
        else if(heap.top()<ve[i].first) heap.pop(),heap.push(ve[i].second);
    }
    cout<<heap.size()<<endl;
    return 0;
}

907. 区间覆盖【有意思】

在这里插入图片描述
https://www.acwing.com/problem/content/description/909/
在这里插入图片描述
对于可以覆盖之前的，我们要选它们中最长的。

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+10;
struct node
{
    int x,y;
}Node[N];
bool cmp(node a,node b)
{
    return a.x<b.x;
}
int main(void)
{
    int st,ed; cin>>st>>ed;
    int n; cin>>n;
    for(int i=0;i<n;i++) cin>>Node[i].x>>Node[i].y;
    sort(Node,Node+n,cmp);

    int res=0;
    bool flag=false;
    for(int i=0;i<n;i++)
    {
        int j=i,r=-1e9;
        while(j<n&&Node[j].x<=st)//找到最大的右端点
        {
            r=max(r,Node[j].y);
            j++;
        }

        if(r<st)//说明r没有更新，说明这两段没有公共部分，故不能覆盖
        {
            res=-1;
            break;
        }

        res++;
        if(r>=ed)//覆盖完了
        {
            flag=true;
            break;
        }
        st=r;//更新
        i=j-1;
    }
    if(!flag) cout<<-1<<endl;
    else cout<<res<<endl;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
vector< pair<int,int> > ve;
int n,l,r,st,ed;
int main(void)
{
    cin>>st>>ed;
    cin>>n;
    while(n--) cin>>l>>r,ve.push_back({l,r});
    sort(ve.begin(),ve.end());
    int ans=0;
    for(int i=0;i<ve.size();i++)
    {
        int j=i;
        bool flag=false;
        int temp=st;
        while(j<ve.size()&&ve[j].first<=temp) flag=true,st=max(st,ve[j++].second);
        if(flag) ans++,i=j-1;
        if(st>=ed) 
        {
            cout<<ans<<endl;
            return 0;
        }
    }
    cout<<-1<<endl;
    return 0;
}

148. 合并果子

在这里插入图片描述
https://www.acwing.com/problem/content/description/150/

方法：每次选最小的两个合并。

小根堆做法

#include<cstdio>
#include<iostream>
#include<queue>
using namespace std;
int main(void)
{
    priority_queue<int, vector<int>, greater<int> >heap;
    int n; cin>>n;
    while(n--)
    {
        int x; cin>>x;
        heap.push(x);
    }
    long long 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);
    }
    cout<<res<<endl;
    return 0;
}

大根堆做法

#include<cstdio>
#include<queue>
#include<iostream>
using namespace std;
int main(void)
{
    int n; cin>>n;
    priority_queue<int> heap;
    while(n--)
    {
        int x; cin>>x;
        heap.push(-x);
    }
    long long 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));
    }
    cout<<res<<endl;
    return 0;
}

913. 排队打水

在这里插入图片描述
https://www.acwing.com/problem/content/description/915/

思路： 由于若把时间长的放在后面接水，那么就较少人等，所以排序+贪心即可。

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+10;
long long int a[N],s[N];
int main(void)
{
    int n; cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    sort(a+1,a+n+1);
    long long int sum=0;
    for(int i=1;i<=n-1;i++) s[i]=s[i-1]+a[i],sum+=s[i];
    //1代表的就是第二个人的等待时间，第一个人的等待时间为零
    cout<<sum<<endl;
    return 0;
}

104. 货仓选址

在这里插入图片描述

https://www.acwing.com/problem/content/description/106/
选中间的位置最优

详细的证明

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+10;
int a[N],sum;
int main(void)
{
    int n; cin>>n;
    for(int i=0;i<n;i++) cin>>a[i];
    sort(a,a+n);
    int area=a[n/2];
    for(int i=0;i<n;i++) sum+=abs(area-a[i]);
    cout<<sum<<endl;
    return 0;
}

125. 耍杂技的牛

在这里插入图片描述
https://www.acwing.com/problem/content/description/127/

按其和从小到大排序

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+10;
struct student
{
    int w,s;
}stu[N];
bool cmp(student a,student b)
{
    return a.w+a.s<b.w+b.s;
}
int main(void)
{
    int n;cin>>n;
    for(int i=1;i<=n;i++) cin>>stu[i].w>>stu[i].s;
    sort(stu+1,stu+n+1,cmp);
    int ans=-1e9;
    int res=0;
    for(int i=1;i<=n;i++)
    {
        ans=max(ans,res-stu[i].s);
        res+=stu[i].w;
    }
    cout<<ans<<endl;
    return 0;
}
1836：【04NOIP提高组】合并果子(三种做法)
weq2011的博客
10-06 3210
贪心/堆/优先队列来解题
信息学奥赛一本通 1369：合并果子(fruit) | 1836：【04NOIP提高组】合并果子 | 洛谷 P1090 [NOIP2004 提高组] 合并果子
君义NOIP的博客
12-12 2819
复杂度内取到所有果堆中数量最小的一堆，也就是取当前多个数字中的最小值，需要用到堆（heap）这一数据结构，C++ STL中提供了以堆为原理的优先队列(priority_queue)，可以使用该容器求数字中的最小值。将优先队列设为小顶堆，将n个数字加入到优先队列之中，每次出队两个数字，出队的两个数字就是最小的两个数字，将这两个数字加和，即为合并两堆果子。如果a, b两堆合为一堆，则可以画一个根结点g表示a，b合并后的果堆，这个结点的左孩子是a，右孩子是b。下图中，冒号后面的数字表示果子数量。
Test001-合并果子
lovefantasy2010的博客
03-20 752
算法001:合并果子
二叉堆 合并果子
weixin_30598225的博客
07-24 695
问题描述 在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。 每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。 因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节...
1369：合并果子(fruit)
pheatonhb的博客
04-10 800
信息学奥赛一本通： 1369：合并果子(fruit)
第6章 贪心算法.ppt
09-16
贪心算法是计算机科学中解决优化问题的一种方法，它以问题的局部最优解为基础，通过一系列的局部最优选择，来构造问题的整体最优解。贪心算法的核心在于贪心选择性质，即每一步选择都做出在当前情况下最好或最优的...
《信息学竞赛宝典-基础算法》视频讲解-第6章 贪心算法
03-15
c++基础算法视频讲解---第6章 第6章 6.1.1删数问题 6.1.4排座椅 6.1.5修理牛棚 6.1.2数列极差问题 6.1.3均分纸牌 6.1.6地鼠游戏 6.1.8电视节目安排 6.1.10监测点 6.1.7最优分解 6.1.11雷达问题 6.1.12广告问题1 ...
算法基础 第6章 贪心算法--第5版(2022.03.05).pdf
03-05
【例2】均分纸牌（NOIP2002 提高组第1题） 有 N 堆纸牌，编号分别为 1，2，…, N。每堆上有若干张，但纸牌总数必为 N 的倍数。可以在任一堆上取若干张纸牌，然后移动。 移牌规则为：在编号为 1 堆上取的纸牌，只能...
算法学习系列（三十五）：贪心（杂）
weixin_60033897的博客
02-18 792
上一篇文章也说过了这个贪心问题没有一个规范的套路和模板，主要还是因题而异，到了考场上基本是靠猜，所以本篇文章主要还是以讲题为主。
合并果子的研究
缪语博的博客
07-16 539
合并果子的研究
合并果子源程序
11-27
合并果子（NOIP2004TG_2）快排+插入
合并果子（贪心算法，huffman树）
qq_73802975的博客
01-05 1216
在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。达达决定把所有的果子合成一堆。每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过 n−1 次合并之后，就只剩下一堆了。达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可能地节省体力。
优先队列合并果子
初九·潜龙勿用的博客
02-18 1244
队列那么先要包含头文件#include , 他和queue不同的就在于我们可以自定义其中数据的优先级, 让优先级高的排在队列前面,优先出队top 访问队头元素empty 队列是否为空size 返回队列内元素个数push 插入元素到队尾 (并排序)emplace原地构造一个元素并插入队列pop 弹出队头元素swap 交换内容定义：priority_queue
[Huffman树] 合并果子(哈夫曼树模型+贪心)
Y-puyu 的博客
11-13 1174
文章目录0. 前言1. 构建Huffman树+贪心 0. 前言 经典的哈夫曼树模型。 关于哈夫曼树推荐大佬博文，简单了解即可。 1. 构建Huffman树+贪心 148. 合并果子 贪心思路： 每次选择最小的两个点合并，采用小根堆存储 这些石子会构成一颗哈夫曼树 证明： 证明1： 权值最小的两个点，在哈夫曼树中的深度一定最深，且可以互为兄弟节点，即可以优先合并，且代价最小 反证法，假设最小两点深度不是最深，设点 a、f 是最小的两个点。当交换点 b 和 f 后，影响到最终结果会从 3b+2f+C
算法设计——合并果子的两种不同合并方式
qq_45096265的博客
05-02 1800
目录 问题描述 不同应用背景分析 代码及注释 总结 问题描述 目前有n堆果子，现在要将果子两两合并为一堆，每一次合并，可以把两堆果子合并到一起 消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过 n−1 次合并之后， 就只剩下一堆了。合并果子时总共消耗的体力等于每次合并所耗体力之和。假定每个果子重量都为 111 ，并且已知果子的堆 数和每堆果子的数目，你的任务是设计出合并的次序方案，...
[题解] 合并果子 三种方法
Lazer2001
01-16 2949
博主与合并果子斗争许久了，最初接触到的便是贪心。 于是就有如下双队列的方法。 #include #include #include #include #include #include #include #include #include #include #define re return #define s(a) sizeof(a) #define maxx(a,b
P1090 [NOIP2004 提高组] 合并果子 / [USACO06NOV] Fence Repair G
aqfcca的博客
11-08 332
接着，将新堆与原先的第三堆合并，又得到新的堆，数目为 1212 ，耗费体力为 1212。假定每个果子重量都为 11 ，并且已知果子的种类 数和每种果子的数目，你的任务是设计出合并的次序方案，使多多耗费的体力最少，并输出这个最小的体力耗费值。每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。第二行包含 n 个整数，用空格分隔，第 i 个整数 ai​(1≤ai​≤20000) 是第 i 种果子的数目。
算法基础13 —— 树进阶(优先队列的应用—合并果子 + 哈夫曼树)
smallrain6的博客
02-09 1496
堆的应用 虽然可以把堆画成二叉树的形式，但是其本质依然是一维数组 拓展：树状数组也可以画成树的形式，它与堆一样，本质依然是一个一维数组 堆的例题：NOIP 2004 合并果子 非常妙的一道例题，即是堆，也是贪心 分析： 假设目前有四堆果子分别是2、3、5、6。 合并果子方案一： 如果先将2与3合并，会耗费体力值5； 再将5与6合并，会耗费体力值11； 最后将5与11合并，会耗费体力值16； 采取以上合并方案，一共需要耗费体力5 + 11 + 16 = 32 合并果子方案二： 先将耗费体力最小的2与3合并，会
洛谷P1090 [NOIP2004 提高组] 合并果子
song0789的博客
11-06 641
可以先合并 1 和 2 这两堆，新堆的数量为 3，消耗体力为 3。然后将新堆与原来的第三堆合并，得到新堆数量为 12，消耗体力为 12。假设每个果子的重量都是 1，已知果子的种类数和每种果子的数量，你的任务是设计一个合并方案，使得多多消耗的体力最少，并输出这个最小的体力耗费值。每次合并，多多可以选择任意两堆果子合并，合并时所消耗的体力等于这两堆果子的重量之和。因此，多多在合并果子过程中总共消耗的体力是每次合并所耗体力的总和。在一片果园中，多多已经将所有的果子采摘完毕，并将它们按照种类分成了不同的堆。
算法设计与分析（第二章 贪心法作业-选做）：贪心算法思想的应用
最新发布
03-31
### 贪心算法思想及其应用 贪心算法是一种在每一步选择中都采取当前状态下最优策略的算法设计方法，其目标是希望最终能够达到全局最优解。然而需要注意的是，贪心算法并不总是能保证得到真正的全局最优解[^3]。 #### 贪心算法的核心特点 - **局部最优决策**：每次迭代过程中只考虑当下最有利的选择。 - **不可回溯性**：一旦做出某个决定，则不会更改该决定的结果。 下面是一个经典的活动安排问题作为例子来展示如何运用贪心算法解决实际问题： 假设我们有若干个需要调度的任务列表，每个任务都有自己的起始时间和完成时间。我们的目的是尽可能多地安排这些不重叠的任务。 ```python def activity_selection(s, f): n = len(f) i = 0 result = [] # 将第一个活动加入结果集中 result.append(i) # 遍历剩余的所有活动 for j in range(1, n): if s[j] >= f[i]: result.append(j) i = j return result # 示例数据 s = [1 , 3 , 0 , 5 , 8 , 5] f = [2 , 4 , 6 , 7 , 9 , 9] selected_activities = activity_selection(s, f) print("Selected activities indices:", selected_activities) ``` 上述代码实现了基于结束时间排序后的活动选取过程，确保所选中的每一个新活动都不会与其他已选定的活动发生冲突。 ### 第二章 算法设计与分析 作业解析 对于第二章关于算法设计与分析部分涉及的习题解答，通常会围绕以下几个方面展开讨论： 1. 明确题目要求； 2. 判断是否适合采用某种特定类型的算法（如动态规划、分治或者本节提到的贪心算法）； 3. 编写伪代码并逐步优化成正式实现版本； 4. 对复杂度进行理论推导验证效率高低； 具体到某一道具体的练习题上时，可以根据实际情况调整思路方向。比如针对最大连续子序列求和这类经典问题也可以尝试利用类似的思维模式去探索解决方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值