基础贪心问题

最新推荐文章于 2025-03-01 23:39:19 发布
最新推荐文章于 2025-03-01 23:39:19 发布
阅读量570 收藏 4
点赞数 18
分类专栏： 备战蓝桥杯 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62734493/article/details/137482212
版权
本文介绍了12个编程问题，涉及背包问题、队列操作、线段覆盖、数据结构如小根堆的应用、优化糖果分配等，展示了在IT技术中如何通过算法解决实际问题。
摘要由CSDN通过智能技术生成

1.部分背包问题

在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 110;
double v[N], w[N];
pair<double, int> a[N];
int n, m;

int main(){
	cin>>n>>m;
	double x, y;
	for(int i = 0; i < n; i++){
		cin>>v[i]>>w[i];
		a[i] = {w[i] / v[i], i};
	}
	sort(a, a + n, greater<pair<double, int>>());
	double sum = 0, ans = 0;
	int i = 0;
	while(sum + v[a[i].second] <= m && i < n){
		sum += v[a[i].second];
		ans += w[a[i].second];
		i++;
	}
	if(sum < m && i < n){
		double x = m - sum;
		ans += x * a[i].first;
	}
	printf("%.2lf", ans);
	return 0;
}

2.排队接水

在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1010;
pair<double, int> a[N];
int n; 

int main(){
	cin>>n;
	double x;
	for(int i = 0; i < n; i++){
		cin>>x;
		a[i] = {x, i};
	}
	sort(a, a + n);
	double sum = 0;
	int m = n;
	for(int i = 0; i < n; i++){
		cout<<a[i].second + 1<<" ";
		m--;
		sum += m * a[i].first;
	}
	cout<<endl;
	sum /= n;
	printf("%.2lf", sum);
	return 0;
}

3.线段覆盖

按区间右端点升序排序，如果能接上就接
在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e6 + 10;
pair<int, int> a[N];
int n; 

bool cmp(const pair<int, int>& p, const pair<int, int>& q){
	return p.second < q.second;
}

int main(){
	cin>>n;
	int x, y;
	for(int i = 0; i < n; i++){
		cin>>x>>y;
		a[i] = {x, y};
	}
	sort(a, a + n, cmp);
	int st, ed = -1e9;
	int cnt = 0;
	for(int i = 0; i < n; i++){
		if(a[i].first >= ed){
			st = a[i].first;
			ed = a[i].second;
			cnt++;
		}
	}
	cout<<cnt;
	return 0;
}

4.合并果子

用小根堆维护最小值，每次取出两个最小值
在这里插入图片描述

#include<iostream>
#include<queue>
using namespace std;
priority_queue<int, vector<int>, greater<int>> q;
int n; 

int main(){
	cin>>n;
	int x;
	for(int i = 0; i < n; i++){
		cin>>x;
		q.push(x);
	}
	int sum = 0, a = 0, b = 0;
	while(q.size() > 1){
		a = q.top();
		q.pop();
		b = q.top();
		q.pop();
		sum += a + b;
		q.push(a + b);
	}
	cout<<sum;
	return 0;
}

5.小A的糖果

如果两个相邻的多了，那就先减去第二个，因为第二个还关联第三个
在这里插入图片描述

#include<iostream>
#include<queue>
using namespace std;
const int N = 1e5 + 10;
int a[N];
int n, m; 

int main(){
	cin>>n>>m;
	for(int i = 0; i < n; i++){
		cin>>a[i];
	}
	long long sum = 0;
	for(int i = 0; i < n - 1; i++){
		if(a[i] + a[i + 1] > m){
			int x = a[i] + a[i + 1] - m;
			if(a[i + 1] >= x) a[i + 1] -= x;
			else{
				a[i] -= x - a[i + 1];
				a[i + 1] = 0;
			}
			sum += x;
		}
	}
	cout<<sum;
	return 0;
}

6.删数问题

删掉下坡数
在这里插入图片描述

#include<iostream>
using namespace std;
const int N = 1e5 + 10;
int a[N];
int n, m; 
string s;

int main(){
	cin>>s;
	cin>>n;
	int len = s.size();
	for(int i = 0; i < len; i++){
		a[i] = s[i] - '0';
	}
	while(n--){
		for(int i = 0; i < len; i++){
			if(a[i] > a[i + 1]){
				for(int j = i; j < len; j++) a[j] = a[j + 1];
				len--;
				break;
			}
		}
	}
	int z = 0, st = 0;
	while(a[z] == 0 && st < len - 1){
		z++, st++;
	}
	for(int i = st; i < len; i++){
		cout<<a[i];
	}
	return 0;
}

7.陶陶摘苹果（升级版）

按花费力气升序排序，先摘花费力气小的
在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e5 + 10;
pair<int, int> q[N];
int n, m, a, b;

bool cmp(const pair<int, int>& pp, const pair<int, int>& qq){
	if(pp.second != qq.second) return pp.second < qq.second;
	else return pp.first < qq.first; 
}

int main(){
	cin>>n>>m;
	cin>>a>>b;
	int x, y;
	for(int i = 1; i <= n; i++){
		cin>>x>>y;
		q[i] = {x, y};
	}
	sort(q + 1, q + n + 1, cmp);
	int cnt = 0;
	for(int i = 1; i <= n; i++){
		if(m - q[i].second >= 0 && a + b >= q[i].first){
			cnt++;
			m -= q[i].second;
		}
	}
	cout<<cnt;
	return 0;
}

8.铺设道路

大的带着小的填，如果后面一个大于前一个高度，那就多填这个差值，最后加上第一个需要填的高度
在这里插入图片描述

#include<iostream>
using namespace std;
const int N = 1e5 + 10;
int a[N];
int n;

int main(){
	cin>>n;
	for(int i = 0; i < n; i++) cin>>a[i];
	int ans = 0; 
	for(int i = 1; i < n; i++){
		if(a[i] > a[i - 1]){
			ans += a[i] - a[i - 1];
		}
	}
	ans += a[0];
	cout<<ans;
	return 0;
}

9.混合牛奶

按照价格升序排序，先买便宜的
在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 2e6 + 10;
pair<int, int> q[N];
int n, m;

int main(){
	cin>>n>>m;
	int x, y;
	for(int i = 0; i < m; i++){
		cin>>x>>y;
		q[i] = {x, y};
	}
	//cout<<"-------------------"<<endl;
	sort(q, q + m);
	int ans = 0, sum = 0;
	for(int i = 0; i < m; i++){
		if(sum + q[i].second <= n){
			ans += q[i].first * q[i].second;
			sum += q[i].second;
			//cout<<ans<<endl;
		}else if(sum < n){
			ans += (n - sum) * q[i].first;
			sum = n;
			break;
		}else if(sum >= n){
			break;
		}
		//cout<<q[i].first<<" "<<sum<<endl;
	}
	cout<<ans;
	return 0;
}

10.纪念品分组

让大的和小的组合
在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 3e4 + 10;
int a[N];
int n, m;

int main(){
	cin>>m>>n;
	for(int i = 0; i < n; i++) cin>>a[i];
	sort(a, a + n, greater<int>());
	int cnt = 0;
	for(int i = 0, j = n - 1; i <= j; i++){
		if(a[i] + a[j] <= m){
			j--;
		}
		cnt++;
	}
	cout<<cnt;
	return 0;
}

11.跳跳！

高低高低，反复跳
在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 3e4 + 10;
long long a[N];
int n, m;

int main(){
	cin>>n;
	for(int i = 0; i < n; i++) cin>>a[i];
	sort(a, a + n, greater<int>());
	long long sum = 0, ed = 0;
	for(int i = 0, j = n - 1; i <= j; i++, j--){
		sum += (a[i] - ed) * (a[i] - ed);
		sum += (a[j] - a[i]) * (a[j] - a[i]);
		ed = a[j]; 
	}
	cout<<sum;
	return 0;
}

12.分组（难）

二分查找当前满足条件的最后一个小组，如果可以进这个小组，那就进去，否则就新建一个小组
在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e5 + 10;
int a[N], q[N], siz[N];
int n, m;

int main(){
	cin>>n;
	for(int i = 0; i < n; i++) cin>>a[i];
	sort(a, a + n);
	q[0] = 1e9;
	int cnt = 0, res = 0;
	for(int i = 0; i < n; i++){
		int l = 0, r = cnt + 1;
		while(l + 1 < r){
			int mid = (l + r) / 2;
			if(a[i] < q[mid]) r = mid;
			else l = mid;
		}
		if(a[i] == q[l]){
			q[l]++, siz[l]++;
		}else{
			q[++cnt] = a[i] + 1, siz[cnt] = 1;
		}
	}
	int ans = 1e9;
	for(int i = 1; i <= cnt; i++){
		ans = min(ans, siz[i]);
	}
	cout<<ans;
	return 0;
}

13.国王游戏（难）

按照左手和右手乘积升序排序，所得的奖赏之和最少
在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e3 + 10;
pair<int, int> q[N];
int n, m;

bool cmp(const pair<int, int>& pp, const pair<int, int>& qq){
	if(pp.first * pp.second != qq.first * qq.second) return pp.first * pp.second < qq.first * qq.second;
	else if(pp.first != qq.first) return pp.first < qq.first;
	else return pp.second > qq.second;
}

int main(){
	cin>>n;
	int a, b;
	for(int i = 0; i <= n; i++){
		cin>>a>>b;
		q[i] = {a, b};
	}
	sort(q + 1, q + n + 1, cmp);
	long long ans = 0, sum = 0, res = 1;
	for(int i = 1; i <= n; i++){
		cout<<q[i].first<<" "<<q[i].second<<endl;
		res *= q[i - 1].first;
		sum = res / q[i].second;
		ans = max(ans, sum);
	}
	cout<<ans;
	return 0;
}
基于贪心法求解单源最短路径问题.docx
06-03
"基于贪心法求解单源最短路径问题" 本资源是关于基于贪心法求解单源最短路径问题的实验报告，包括实验内容、算法设计、算法描述、算法正确性证明、算法分析、算法实现与测试等部分。 实验目的：理解贪心法的核心...
阿里巴巴背包问题贪心算法
01-20
0-1背包问题是最基础的形式，物品是不可分割的，即每个物品要么完全装入背包，要么不装。完全背包问题则允许物品可以被分割成任意大小放入背包。在这个案例中，我们处理的是0-1背包问题。 为了求解0-1背包问题，...
基础贪心问题总结
qq12323qweeqwe的博客
01-02 1471
贪心，就是取局部最优解，通常贪心问题能获得最优解的情况都是当前局部最优不会影响到全局最优，或者可以扩大到全局最优，如果从全局的角度来看，当前局部最优的选择策略是错误的，那么贪心算法就不适用了 贪心问题就是不考虑全局，尽可能的选择某种属性的物品，只有当局部最优可以扩展到全局最优的时候，贪心的策略才是正确的 主要有以下几种类型 1.简单贪心 简单贪心顾名思义就是我们可以很容易的做出某种选择，通常是考虑题目中的特性 ...
贪心法经典问题练习
qqrrjj2011的博客
06-12 1051
贪心法经典问题练习
贪心算法（基础）
m0_63783532的博客
01-31 7538
1. 装载问题 2. 完全背包问题
贪心算法：基础入门篇
Krisit的博客
08-11 2386
贪心算法所作的选择来源于以往的选择，并非将来的选择。贪心算法相对于其他算法有一定的速度优势，在一题可以多解的情况下，可以优先选择贪心算法。
贪心算法理论基础
m0_69057918的博客
01-17 274
贪心算法理论基础
贪心算法问题
热门推荐
【Dyson】的博客
09-15 2万+
一、概念 1. 贪心法（Greedy Algorithm）定义         求解最优化问题的算法通常需要经过一系列的步骤，在每个步骤都面临多种选择；         贪心法就是这样的算法：它在每个决策点作出在当时看来最佳的选择，即总是遵循某种规则，做出局部最优的选择，以推导出全局最优解（局部最优解-&gt;全局最优解） 2. 对贪心法的深入理解         （1）原理：一种启发式...
贪心算法解决tsp问题
lengyue815的博客
12-03 2502
printf("本次访问的城市%d 距离下一个%d城市%d\n",s[i],s[i+1], distance[ s[i] ][ s[i+1] ] );distance是一个二维数组,存放了 i, j 城市间的距离, distance [i][ s [currentCity]] 表示第i个城市 和 当前访问城市间的距离 .i 不断增加,遍历了所有的城市,就可以找到最短距离了.// 剩下就是初始条件了, 初始化出发的城市,可以是0,1,2,3任意一个。
贪心算法基础
lee2813的博客
01-23 318
一、贪心算法 贪心算法利用贪心策略，保证每次操作都是局部最优的，从而使得最终的结果是全局最优的。 另外要求全局结果是局部结果的简单求和，而局部结果之间互不相干（在考虑一种特定策略时，不需要考虑另外一种策略），因此局部最优的策略也同样是全局最优的策略。 二、分类 贪心的题目大体可以分为两类： 分配问题 分配问题即在一个场景中，存在着资源分配的问题。这时需要设置合理的贪心策略，利用排序，选择，遍历等方法，从局部分配最优得到全局分配最优。 区间问题 区间问题即在处理一串区间时，例如减去相连区间等等操作，可能会
Day29: 贪心算法基础 |||
weixin_44839942的博客
08-29 1747
i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。情况二：rest[i] = gas[i]-cost[i]为一天剩下的油，i从0开始计算累加到最后一站，如果累加没有出现负数，说明从0出发，油就没有断过，那么0就是起点。你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。
算法基础：贪心策略
阿呆的隐秘角落
10-22 2395
算法成神之路：贪心策略
信息学奥赛基础算法之贪心算法测试题
01-18
贪心算法是信息学奥赛的基础算法之一，它是一种简单、快速的算法，适用于解决一些特殊的优化问题。贪心算法的基本思想是，在每一步骤中选择当前最优解，然后在下一步骤中继续选择最优解，直到达到最终的解。 1. ...
多机调度问题 -贪心法——C++代码
05-24
在计算机科学领域，多机调度问题是一个典型的优化问题，它涉及到如何有效地分配多个任务到多台机器上，以达到最大化效率或最小化某些成本的目标...但这个简单的C++代码提供了一个基础的贪心法解决多机调度问题的起点。
多机调度问题贪心算法是什么以及学习多机调度问题贪心算法的意义
04-27
1. **理论基础**：掌握多机调度问题的基本理论和技术对于理解现代计算环境中的资源管理至关重要。 2. **实践应用**：学习贪心算法不仅可以帮助我们快速解决问题，还能够提高我们在实际项目中的工作效率。 3. **创新...
算法-二叉树篇08-完全二叉树的节点个数
Buling_0的博客
02-26 194
完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（从第 0 层开始），则该层包含 1~ 2h 个节点。写一个二叉树遍历加上一个计数即可。我这里用的是递归，层序遍历，深度/广度遍历都可以。给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。
455. 分发饼干（LeetCode）
weixin_53009877的博客
02-28 192
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。虽然你有两块小饼干，由于他们的尺寸都是 1，你只能让胃口值是 1 的孩子满足。，这个孩子会得到满足。你的目标是满足尽可能多的孩子，并输出这个最大数值。你有三个孩子和两块小饼干，3 个孩子的胃口值分别是：1,2,3。你有两个孩子和三块小饼干，2 个孩子的胃口值分别是 1,2。，这是能让孩子们满足胃口的饼干的最小尺寸；你拥有的饼干数量和尺寸都足以让所有孩子满足。从后往前 又包含着什么思考呢。所以你应该输出 1。
【算法】图论 —— Floyd算法 python
最新发布
查理零世的博客
03-01 515
如果有更多问题或需要进一步的帮助，可以在评论区留言讨论哦！，分别代表点的个数和边的条数。
力扣1462. 课程表 IV
Pisasama的博客
02-27 154
题目要求判断query中每组询问是否正确判断是否先决，拓扑排序 + 所有先决条件都存在二维数组中，询问直接调用。
C语言实现图着色问题的贪心算法解析
1. 图着色问题的基础概念 图着色问题可以从图论的角度来理解。图由顶点（Vertex）和边（Edge）组成，顶点集合V和边集合E构成一个图G=(V,E)。图可以是有向的或无向的。在图着色问题中，通常指的是无向图。图着色问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值