贪心算法

贪心算法（就是猜测再试试证明）

905. 区间选点905. 区间选点 - AcWing题库

给定

输出选择的点的最小数量。

位于区间端点上的点也算作区间内。

输入格式

第一行包含整数

接下来

输出格式

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

数据范围

输入样例：

输出样例：

查看代码

#include<bits/stdc++.h> 
using namespace std;
const int N=1e5+6;
typedef long long int ll;
struct point{
	ll l;
	ll r;
}p[N];
int n;
bool com(point&a,point&b){
	return a.r<b.r;
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++)cin>>p[i].l>>p[i].r;
	sort(p,p+n,com);
	int cnt=1;
	ll h=p[0].r;
	for(int i=1;i<n;i++){
		if(h<p[i].l){
		cnt++;
		h=p[i].r;
		}
	}
	cout<<cnt;
	return 0;
}

贪心：

每次选取右端点作为参考点，因为右端点可以包含于多个区间，当参考点<当前区间左端点，那么选取点的个数+1并且更新参考点为当前区间的右端点。

908. 最大不相交区间数量908. 最大不相交区间数量 - AcWing题库

给定 $N$ 个闭区间 $[a_{i}, b_{i}]$ ，请你在数轴上选择若干区间，使得选中的区间之间互不相交（包括端点）。

输出可选取区间的最大数量。

输入格式

第一行包含整数 $N$ ，表示区间数。（和906上面区间点一样！）

接下来 $N$ 行，每行包含两个整数 $a_{i}, b_{i}$ ，表示一个区间的两个端点。

输出格式

输出一个整数，表示可选取区间的最大数量。

数据范围

$1 \leq N \leq 10^{5}$ ,
$- 10^{9} \leq a_{i} \leq b_{i} \leq 10^{9}$

输入样例：

输出样例：

代码：

查看代码

 #include<bits/stdc++.h> 
using namespace std;
const int N=1e5+6;
typedef long long int ll;
struct point{
	ll l;
	ll r;
}p[N];
int n;
bool com(point&a,point&b){
	return a.r<b.r;
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++)cin>>p[i].l>>p[i].r;
	sort(p,p+n,com);
	cout<<endl;
	//cout<<"-------------------------------------------------------"<<endl;
//	for(int i=0;i<n;i++)cout<<p[i].l<<" "<<p[i].r<<endl;
	int cnt=1;
	ll h=p[0].r;
cout<<"h= "<<h<<endl;
	for(int i=1;i<n;i++){
		if(h<p[i].l){
		cnt++;
		h=p[i].r;
		//cout<<"h= "<<h<<endl; 
		}
	}
	cout<<cnt;
	return 0;
}

906. 区间分组

给定 $N$ 个闭区间 $[a_{i}, b_{i}]$ ，请你将这些区间分成若干组，使得每组内部的区间两两之间（包括端点）没有交集，并使得组数尽可能小。

输出最小组数。

输入格式

第一行包含整数 $N$ ，表示区间数。

接下来 $N$ 行，每行包含两个整数 $a_{i}, b_{i}$ ，表示一个区间的两个端点。

输出格式

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

数据范围

$1 \leq N \leq 10^{5}$
$- 10^{9} \leq a_{i} \leq b_{i} \leq 10^{9}$

输入样例：

输出样例：

查看代码

#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int N=1e5+6;
struct point{
	ll l;
	ll r;
}p[N];
int n;
bool com(point&a,point&b){
	return a.l<b.l;
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>p[i].l>>p[i].r;
	}
	sort(p,p+n,com);
	//将右端点放入小根堆 
	priority_queue<ll,vector<ll>,greater<ll> >q;
	for(int i=0;i<n;i++) {
		point y=p[i];
		//整个新组 
		if(q.empty()||q.top()>=y.l){
			q.push(y.r);
		}
		else{
			q.pop();
			q.push(y.r);
		}
	}
	cout<<q.size();
	return 0;
}

现将每个点坐标按左端点从小到大排序

然后用小根堆存放每个点右端点

贪心：

（1）当区间左端点<=所有组最小的右端点（即堆顶）--->开一个新组，将当前区间右端点放入堆

（2）else

新区间在右端点最小的那个组内

所以只用弹出堆顶

并更新堆

--->堆是优先队列默认大根堆，会自动排序，对堆顶为最值。

哈夫曼树：合并果子148. 合并果子 - AcWing题库

在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。

达达决定把所有的果子合成一堆。

每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。

可以看出，所有的果子经过 $n - 1$ 次合并之后，就只剩下一堆了。

达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。

因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可能地节省体力。

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

例如有 $3$ 种果子，数目依次为 $1 ， 2 ， 9$ 。

可以先将 $1 、 2$ 堆合并，新堆数目为 $3$ ，耗费体力为 $3$ 。

接着，将新堆与原先的第三堆合并，又得到新的堆，数目为 $12$ ，耗费体力为 $12$ 。

所以达达总共耗费体力 $= 3 + 12 = 15$ 。

可以证明 $15$ 为最小的体力耗费值。

输入格式

输入包括两行，第一行是一个整数 $n$ ，表示果子的种类数。

第二行包含 $n$ 个整数，用空格分隔，第 $i$ 个整数 $a_{i}$ 是第 $i$ 种果子的数目。

输出格式

输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。

输入数据保证这个值小于 $2^{31}$ 。

数据范围

$1 \leq n \leq 10000$

$1 \leq a_{i} \leq 20000$

输入样例：

3 
1 2 9

输出样例：

查看代码

 #include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main(){
   int n;
   cin>>n;
   priority_queue<ll,vector<ll>,greater<ll> >p;
   int a;
   while(n--){
       scanf("%d",&a);
       p.push(a);
   }
   ll res=0;
  while(p.size()>1) {
      int b=p.top();p.pop();
      int c=p.top();p.pop();
      res+=b+c;
      p.push(b+c);
  } 
    
   cout<<res; 
    
    return 0;
}

哈夫曼树：利用小根堆--->写法用stl中的优先队列

小根堆：priority_queue<ll,vector<ll>,greater<ll> >p ；大根堆：priority_queue<ll,vector<ll>>p；

小根堆：greater<ll>与右>相隔一个空格！

放入优先队列用push

放入小根堆会使堆顶最小

先全部放入小根堆，然后弹出堆顶元素两次--->即每次取出两个最小的元素相加，将相加结果加在保存结果的res里，并将相加的两个元素和放入堆

堆会自动排序

堆顶为最值

循环退出条件：元素<=1不用合并了。

907. 区间覆盖

907. 区间覆盖 - AcWing题库

给定 $N$ 个闭区间 $[a_{i}, b_{i}]$ 以及一个线段区间 $[s, t]$ ，请你选择尽量少的区间，将指定线段区间完全覆盖。

输出最少区间数，如果无法完全覆盖则输出 $- 1$ 。

输入格式

第一行包含两个整数 $s$ 和 $t$ ，表示给定线段区间的两个端点。

第二行包含整数 $N$ ，表示给定区间数。

接下来 $N$ 行，每行包含两个整数 $a_{i}, b_{i}$ ，表示一个区间的两个端点。

输出格式

输出一个整数，表示所需最少区间数。

如果无解，则输出 $- 1$ 。

数据范围

$1 \leq N \leq 10^{5}$
$- 10^{9} \leq a_{i} \leq b_{i} \leq 10^{9}$
$- 10^{9} \leq s \leq t \leq 10^{9}$

输入样例：

输出样例：

查看代码

#include<bits/stdc++.h> 
using namespace std;
const int N=1e5+6;
typedef long long int ll;
int n;ll start;ll end1;
struct point{
	ll l;
	ll r;
}p[N];
bool com(point&a,point&b){
	return a.l<b.l;
}
bool flag=false; 
int main(){
	cin>>start>>end1;//覆盖区间起点和终点 
	cin>>n;
	int res=0;
	for(int i=0;i<n;i++){
		cin>>p[i].l>>p[i].r;
	}
	sort(p,p+n,com);
	for(int i=0;i<n;i++){
		ll j=i;ll right=-2e9;
		while(j<n&&p[j].l<=start){
			right=max(right,p[j].r);
			j++;
		}
		if(right<start){
			cout<<"-1"<<endl;
			return 0;
		}
		res++;
		if(right>=end1){
			flag=true;
			break;
		}
		i=j-1;//因为循环里i会+1所以先减1
		start =right;
	}
	if(!flag)cout<<"-1";//遍历完后没有成功
	else{
		cout<<res;
	}
	
	
	return 0;
}

算法思想：

贪心

首先将区间按左端点从小到大排序

记录题目要求的起点和终点

然后循环遍历每个排好序后的区间

res记录选取的最少区间数

取满足条件的最大右端点为end1

每个区间左端点是为了看是否满足条件，右端点是用来选择的（要满足条件的最大值）

排序不等式

题目：913 排队打水

913. 排队打水 - AcWing题库

有 $n$ 个人排队到 $1$ 个水龙头处打水，第 $i$ 个人装满水桶所需的时间是 $t_{i}$ ，请问如何安排他们的打水顺序才能使所有人的等待时间之和最小？

输入格式

第一行包含整数 $n$ 。

第二行包含 $n$ 个整数，其中第 $i$ 个整数表示第 $i$ 个人装满水桶所花费的时间 $t_{i}$ 。

输出格式

输出一个整数，表示最小的等待时间之和。

数据范围

$1 \leq n \leq 10^{5}$
$1 \leq t_{i} \leq 10^{4}$

输入样例：

7
3 6 1 4 2 5 7

输出样例：

查看代码

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+6;
int t[N];
int n;
int main(){
	cin>>n;
	for(int i=1;i<=n;i++)cin>>t[i];
	sort(t+1,t+n+1);//从小到大排序
	long long int sum=0;
	for(int i=1;i<=n;i++) {
		sum=sum+(n-i)*t[i];
	}
	cout<<sum;
	return 0;
}

每个同学打水时间 3 6 1 4 2 5 7

等待总时间：sum=3*6+6*5+1*4+4*3+2*2+5*1=a[1]*(n-1)+a[2]*(n-2)+...+a[n-1]*(n-n+1);

当前同学打水时间是他后面所有同学都要等待的时间！

贪心算法--->让小时间放前面

做法：对时间从小到大排序

绝对值不等式：取中位数作为所求点

104 货仓选址

104. 货仓选址 - AcWing题库

在一条数轴上有 $N$ 家商店，它们的坐标分别为 $A_{1} \sim A_{N}$ 。

现在需要在数轴上建立一家货仓，每天清晨，从货仓到每家商店都要运送一车商品。

为了提高效率，求把货仓建在何处，可以使得货仓到每家商店的距离之和最小。

输入格式

第一行输入整数 $N$ 。

第二行 $N$ 个整数 $A_{1} \sim A_{N}$ 。

输出格式

输出一个整数，表示距离之和的最小值。

数据范围

$1 \leq N \leq 100000$
$0 \leq A_{i} \leq 40000$

输入样例：

4
6 2 9 1

输出样例：

查看代码

 #include<bits/stdc++.h> 
using namespace std;
const int N=1e5+6;
int n;
int a[N];
int main(){
	cin>>n;
	for(int i=0;i<n;i++)cin>>a[i];
	sort(a,a+n) ;
	long long int sum=0;
	for(int i=0;i<n;i++){
		sum=sum+abs(a[i]-a[n/2]);
	}
	cout<<sum;
	return 0;
}

考点：贪心

初始下标0~n

最值处为中位数（中间那个数用n/2下标）

125. 耍杂技的牛

125. 耍杂技的牛 - AcWing题库

农民约翰的 $N$ 头奶牛（编号为 $1.. N$ ）计划逃跑并加入马戏团，为此它们决定练习表演杂技。

奶牛们不是非常有创意，只提出了一个杂技表演：

叠罗汉，表演时，奶牛们站在彼此的身上，形成一个高高的垂直堆叠。

奶牛们正在试图找到自己在这个堆叠中应该所处的位置顺序。

这 $N$ 头奶牛中的每一头都有着自己的重量 $W_{i}$ 以及自己的强壮程度 $S_{i}$ 。

一头牛支撑不住的可能性取决于它头上所有牛的总重量（不包括它自己）减去它的身体强壮程度的值，现在称该数值为风险值，风险值越大，这只牛撑不住的可能性越高。

您的任务是确定奶牛的排序，使得所有奶牛的风险值中的最大值尽可能的小。

输入格式

第一行输入整数 $N$ ，表示奶牛数量。

接下来 $N$ 行，每行输入两个整数，表示牛的重量和强壮程度，第 $i$ 行表示第 $i$ 头牛的重量 $W_{i}$ 以及它的强壮程度 $S_{i}$ 。

输出格式

输出一个整数，表示最大风险值的最小可能值。

数据范围

$1 \leq N \leq 50000$
$1 \leq W_{i} \leq 10, 000$
$1 \leq S_{i} \leq 1, 000, 000, 000$

输入样例：

输出样例：

查看代码

#include<bits/stdc++.h>
using namespace std;
const int N=5e4+6;
typedef long long int ll;
struct a{
	ll w;
	ll s;
}cow[N];
int n;
bool com(a&b,a&c){
	return b.w+b.s<c.w+c.s;
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>cow[i].w>>cow[i].s;
	}
	sort(cow,cow+n,com);

for(int i=1;i<n;i++){
	cow[i].w+=cow[i-1].w;
}
ll ans= -1*cow[0].s;
for(int i=1;i<n;i++){
	ans=max(ans,cow[i-1].w-cow[i].s);
}
	cout<<ans;
	return 0;
}

贪心

第i个物品与第i+1个物品交换前后

第i个物品第i+1个物品

交换前风险值 w₀+w₁+w₂+...+w_i-1 -s_i w₀+w₁+w₂+...+w_i -s_i+1

交换后风险值 w₀+w₁+w₂+...+w_i+1 -s_i w₀+w₁+w₂+...+w_i-1 -s_i+1

简化:

第i个物品第i+1个物品

交换前风险值 -s_i w_i -s_i+1

交换后风险值 w_i+1 -s_i -s_i+1

易知：

w_i -s_{i+1 > -^si+1}

若w_i-s_{i+1 > ^w} _i+1_{-^si 需要交换}

_{所以为了使风险值最大值最小}

_{就使wi+si按升序排列}

_注意：

计算风险值不要用双重循环会超时当超过1e9次

两重循环分开算

一个for

改写每个w

每个物品的w改写为从第0个物品到该物品的总重量--->递推

另一个for

循环遍历求风险值的最大值ans=max(ans,cow[i-1].w-cow[i].s);

该物品上面的总重量-他自己承受值

posted @ 2024-02-04 08:28 Annaprincess 阅读(17) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 2021第十二届蓝桥杯省赛

· 2018蓝桥杯省赛B组

· 贪心算法（进阶）

· 基础算法 —— 贪心算法

· 第六章贪心二

阅读排行：
· 地球OL攻略 —— 某应届生求职总结
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 提示词工程——AI应用必不可少的技术
· .NET周刊【3月第1期 2025-03-02】

公告

昵称： Annaprincess
园龄： 1年3个月
粉丝： 0
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六

luckyyaoyao

贪心算法

贪心算法（就是猜测再试试证明）

输入格式

输出格式

数据范围

输入样例：

输出样例：

输入格式

输出格式

数据范围

输入样例：

输出样例：

输入格式

输出格式

数据范围

输入样例：

输出样例：

哈夫曼树：合并果子148. 合并果子 - AcWing题库

输入格式

输出格式

数据范围

输入样例：

输出样例：

907. 区间覆盖

907. 区间覆盖 - AcWing题库

输入格式

输出格式

数据范围

输入样例：

输出样例：

排序不等式

输入格式

输出格式

数据范围

输入样例：

输出样例：

绝对值不等式：取中位数 作为所求点

输入格式

输出格式

数据范围

输入样例：

输出样例：

125. 耍杂技的牛

输入格式

输出格式

数据范围

输入样例：

输出样例：

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

绝对值不等式：取中位数作为所求点