贪心练习

最新推荐文章于 2022-11-17 08:58:38 发布
最新推荐文章于 2022-11-17 08:58:38 发布
阅读量207 收藏
点赞数
分类专栏： 地图上我们的距离只有三厘米
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43469554/article/details/98600765
版权

问题 A: 看电视
按照结束时间排序，结束时间越早越排前。

#include <iostream>
#include <algorithm>
using namespace std;
int s[105], e[105];
int main()
{
	int n;
	while (1)
	{
		cin >> n;
		if (!n)
		{
			break;
		}
		for (int i = 0; i < n; i++)
		{
			cin >> s[i] >> e[i];
		}
		pair<int, int> p[105];
		for (int i = 0; i < n; i++)
		{
			p[i].first = e[i];
			p[i].second = s[i];
		}
		sort(p, p + n);
		int ans = 0, t = 0; 
		for (int i = 0; i < n; i++)
		{
			if (t <= p[i].second)
			{
				ans++;
				t = p[i].first;
			}
		}
		cout << ans << endl;
	}
	return 0;
}

问题 B: 出租车费
这题其实只要找到一个分界点就行，在分界点处，决定是否将剩下的路程分两次坐出租车，那么怎么求呢？我们来分析一下：
首先，设路程x，0 < x <= 4时，价格是8，4 < x <= 8时， 价格是2 x + 2， 当 x > 8 时，价格是2.4 - 1.2。这三段区间路程的平均价格分别是 2.5、2、2.4，那么在第二段区间一定存在一个值使得当是剩下路程不分两次走时与分两次走时价格相等。列方程有：
2 x + 2 + 18 = 2.4 x - 1.2
x = 13
那么题目就简单了，当分两次使，x < 5 那么就不该分，否则就分。

# include<stdio.h>
int main()
{
	int n; 
	double s; 
	while (scanf("%d", &n) != EOF, n)
	{
		if (n <= 4)
		{
			printf("10\n"); 
			continue; 
		}
		s = n / 8 * 18; 
		n = n % 8; 
		if (!n) 
		{
			printf("%.lf\n", s); 
		}
		else if (n >= 5)
		{
			s += 2 + 2 * n; 
			printf("%.lf\n", s); 
			
		}
		else
		{
			s += 2.4 * n; 
			printf("%.1lf\n", s);
		}
	}
	return 0;
}

问题 C: To Fill or Not to Fill
① 首先增加一个目的地处的加油站，距离为目的地的距离，价格为0。题目要求最低价格那么先要考虑能不能到达目的地。有两种情况到不了目的地，第一种是所有的加油站距离都没有等于0的，那么说明车哪也去不了，直接输出并return；第二种是中途两个加油站之间的距离大于加满油后汽车能够行驶的最大距离，那么最大距离为当前加油站距离起点的距离加上汽车加满油能行驶最大距离。
② 那么我们来考虑一下最低价格。
i. 先要将加油站按照距离distant从小到大排序，然后寻找比当前加油站距离远的，并且在汽车加满油后能够行使到的范围内，比较油价。如果找到了更低的油价，就加油到刚好能跑到该加油站的油量（因为我们不想用更高的油价来跑）。
ii. 如果找不到更低的，就找出当前加油站以外更低的加油站，然后在当前加油站加满油之后过去（因为当前加油站油最便宜了）。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int cmp(pair<double, double> a, pair<double, double> b)
{
	return a.second < b.second;
}
int main()
{
	double capacity, average;
	int distant, n;
	scanf("%lf%d%lf%d", &capacity, &distant, &average, &n);
	vector<pair<double, double> > v(n);
	for (int i = 0; i < n; i++)
	{
		scanf("%lf%lf", &v[i].first, &v[i].second);
	}
	v.push_back(make_pair(0, distant));
	sort(v.begin(), v.end(), cmp);
	double minPrice = 0, tank = 0;
	int flag = 1;
	if (v[0].second)
	{
		printf("The maximum travel distance = 0.00");
		return 0;
	}
	int i = 0;
	while (i < n)
	{
		if (v[i + 1].second - v[i].second > capacity * average)
		{
			flag = 0;
			printf("The maximum travel distance = %.2f", v[i].second + capacity * average);
			break;
		}
		else
		{
			if (v[i + 1].first <= v[i].first)
			{
				minPrice += ((v[i + 1].second - v[i].second) / average - tank) * v[i].first;
				tank = 0;
				i++;
			}
			else
			{
				int minIndex = i + 1;
				for (int j = i + 1; j < n && (v[j].second - v[i].second) <= capacity * average; j++)
				{
					if (v[minIndex].first >= v[j].first)
					{
						minIndex = j;
					}
				}
				if (v[i].first <= v[minIndex].first)
				{
					if (distant - v[i].second <= capacity * average)
					{
						minPrice += ((distant - v[i].second) / average - tank) * v[i].first;
						break;
					}
					else
					{
						minPrice += (capacity - tank) * v[i].first;
						tank = capacity - (v[minIndex].second - v[i].second) / average;
					}
				}
				else
				{
					minPrice += ((v[minIndex].second - v[i].second) / average - tank) * v[i].first;
					tank = 0;
				}
				i = minIndex;
			}
		}
	}
	if (flag)
	{
		printf("%.2f", minPrice);
	}
	return 0;
}

问题 D: Repair the Wall
这题只要从大到小排序，然后遍历数组，每次加上木板长度，然后判断用了几块木板时大于等于了裂缝长度就行啦。

#include <iostream>
#include <algorithm>
using namespace std;
int a[605];
int main()
{
	int l, n;
	while (scanf("%d%d", &l, &n) != EOF) 
	{
		for (int i = 0; i < n; i++)
		{
			cin >> a[i];
		}
		sort(a, a + n, greater<int>());
		int ans = 0, cur = 0, i = 0;
		while (cur < l && i < n)
		{
			cur += a[i];
			i++;
			ans++;
		}
		if (cur < l)
		{
			cout << "impossible" << endl;
		}
		else
		{
			cout << ans << endl; 
		}
	}
	return 0;
}

问题 E: FatMouse’s Trade
贪心水题。。

#include<cstdio>
#include<algorithm>
using namespace std;
struct room
{
	double j;
	double f;
	double p;
} r[1005];
bool cmp(room a, room b)
{
	return a.p > b.p;
}
int main()
{
	double m;
	int n;
	while (1)
	{
		scanf("%lf%d", &m, &n);
		if (m == -1 && n == -1)
		{
			break;
		}
		for (int i = 0; i < n; i++)
		{
			scanf("%lf%lf", &r[i].j, &r[i].f);
			r[i].p = r[i].j / r[i].f;
		}
		sort(r, r + n, cmp);
		double ans = 0;
		for (int i = 0; i < n; i++)
		{
			if (m >= r[i].f)
			{
				m -= r[i].f;
				ans += r[i].j;
			}
			else
			{
				ans += m * r[i].p;
				break;
			}
		}
		printf("%.3f\n", ans);
	}
	return 0;
}

问题 F: 迷瘴
水题。。

#include <iostream>
#include <algorithm>
using namespace std;
int main() 
{
	int m, n, v, w;
	cin >> m;
	while (m--) 
	{
		scanf("%d%d%d", &n, &v, &w);
		int a[105];
		for (int i = 0; i < n; i++) 
		{
			scanf("%d", &a[i]);
		}
		sort(a, a + n);
		int cnt = 0;
		double cur = 0;
		for (int i = 0; i < n; i++) 
		{
			double now = (cnt * cur + a[i]) / (cnt + 1.0);
			if (now <= w) 
			{
				cur = now;
				cnt++;
			}
			else
			{
				break;
			}
		}
		printf("%d %.2f\n", cnt * v, cur / 100);
	}
	return 0;
}

问题 F: 迷瘴
水。。

#include <iostream>
using namespace std;
int main()
{
	int n;
	int a[5] = {50, 20, 10, 5, 1};
	while (cin >> n)
	{
		int i = 0, b[55] = { 0 };
		while (n)
		{
			if (n >= a[i])
			{
				n -= a[i];
				b[a[i]]++;
			}
			else
			{
				i++;
			}
		}
		int flag = 1;
		for (int i = 55; i >= 0; i--)
		{
			if (b[i] && flag)
			{
				cout << i << "*" << b[i];
				flag = 0;
				continue;
			}
			if (b[i])
			{
				cout << "+" << i << "*" << b[i];
			}
		}
		cout << endl;
	}
	return 0;
}

PAT1023
分析：将数字0、数字1、……数字9的个数分别保存在数组a[i]中，因为0不能做首位，所以⾸首先将i从1到9输出第一个a[i]不为0的数字 i ，并将这个 i 保存在变量量 t 中，接着输出a[0]个0，最后输出a[t]-1个t（因为一个 t 已经被放在首位输出过一次了了），最后 i 从 t+1 到 9 输出 a[i] 个 i

#include <iostream>
#include <string>
using namespace std;
int main()
{
	int a[10];
	int t;
	for (int i = 0; i < 10; i++)
	{
		cin >> a[i];
	}
	for (int i = 1; i < 10; i++)
	{
		if (a[i] != 0)
		{
			cout << i;
			t = i;
			break;
		}
	}
	for (int i = 0; i < a[0]; i++)
	{
		cout << 0;
	}
	for (int i = 0; i < a[t] - 1; i++)
	{
		cout << t;
	}
	for (int i = t + 1; i < 10; i++)
	{
		for (int k = 0; k < a[i]; k++)
		{
			cout << i;
		}
	}
	return 0;
}

PAT1070
水。。

#include <iostream>
#include <algorithm>
#include <vector> 
using namespace std;
struct node{
	double total, price, unit;
};

int cmp(node a, node b)
{
	return a.unit > b.unit;
}
int main()
{
	int n, need;
	cin >> n >> need;
	vector<node> v(n);
	for (int i = 0; i < n; i++)
	{
		cin >> v[i].total;
	}
	for (int i = 0; i < n; i++)
	{
		cin >> v[i].price;
	}
	for (int i = 0; i < n; i++)
	{
		v[i].unit = v[i].price / v[i].total;
	}
	sort(v.begin(), v.end(), cmp);
	double ans = 0;
	for (int i = 0; i < n; i++)
	{
		if (v[i].total <= need)
		{
			ans += v[i].price;
			need -= v[i].total;
		}
		else
		{
			ans += v[i].unit * need;
			break;
		}
		
	}
	printf("%.2f", ans);
	return 0;
}
qq_52051345
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
贪心练习_超市.zip_文章/文档_C/C++_
08-09
贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。
贪心练习 01
Golemon的博客
09-06 96
ac
【经典贪心练习】金银岛
weixin_45741610的博客
12-13 2177
【贪心练习】金银岛 题目描述 某天KID利用飞行器飞到了一个金银岛上，上面有许多珍贵的金属，KID虽然更喜欢各种宝石的艺术品，可是也不拒绝这样珍贵的金属。但是他只带着一个口袋，口袋至多只能装重量为w的物品。岛上金属有s个种类, 每种金属重量不同，分别为n1,n2,…,ns，同时每个种类的金属总的价值也不同，分别为v1,v2, …, vs。KID想一次带走价值尽可能多的金属，问他最多能带走价值多少的金属。注意到金属是可以被任意分割的，并且金属的价值和其重量成正比。 输入 第1行是测试数据的组数k，后面跟着k组
贪心算法练习
xxpr_ybgg的博客
11-17 133
分析：本题可以这样理解,有2n个数,A从开头取的话取第一个,给对手留下的是第2个和第2n个,即对手只能选偶数位的数,A以此法可以取走全部的奇数位的数,同理也可以取走偶数位的数.所以,只要将所有奇数位和偶数位的数比较,大的A选,小的对手选,即可。NOIP2002_T1_均分纸牌。
最长摆动序列[贪心练习]
qq_43164662的博客
07-05 139
贪心/动态规划/单调栈，都是考察逻辑能力的一类高级题目，这些题需要分析，需要较好的变通能力。
跳跃游戏II[贪心练习]
qq_43164662的博客
06-23 606
对于求最小最大问题，一般可与贪心联系起来，比如求最少步数，可以找每步能走的最远距离，以此达到最小步数。
贪心练习之点灯问题
weixin_43923436的博客
07-16 473
题目描述 给一个字符串，字符串中只有.和X两种字符，X表示墙，点表示空地，现在，需要在空地点灯，一盏灯能点亮周围三格的位置，请你求出把所有空地点亮，最少需要几盏灯？ 思路分析 观察题目要求，我的思路是，统计有多少个连续的点，然后除3向上取整，因为最多三格嘛，比如4个连续点，就需要两盏灯，这种思路比较容易想到，代码如下： public static int f2(String str){ if(str.length()==0||str==null){ retur
最小差值平方和[贪心练习 -＞ 基本贪心到优化贪心]
qq_43164662的博客
07-10 364
对贪心的练习，是对逻辑分析考察的一个好方式。考察 脑容量/专注力/逻辑连续性/和编码融汇贯通程度(用编码体现逻辑)/优化方向的思考速度。
装满杯子需要的最短时长[贪心练习]
qq_43164662的博客
07-10 161
刷了500题的经验，感觉要考察分析能力/逻辑能力，绝对不是哪些死知识点，必然是贪心/dp/单调栈等，亦或是死知识点的抽象考察。 果不其然，最近的周赛都开始走高质量路线了，全是考察逻辑分析能力题，第一个easy题都是贪心分析的考察。...
无重叠区间[贪心练习]
qq_43164662的博客
07-18 85
贪心往往代码简单，分析问题比较有难度。尤其是贪心结合单调栈/贪心结合DP都是考察分析能力的好题目。 除此之外，一类时间相关贪心，可以时间为路线；一类是二维数组型的，一般都需要对其中的元素顺序/逆序。当然这些都是套路，训练出自己的抓核心问题的能力，套路不过就是个工具。锻炼寻找核心问题处与如何解答的分析能力，而不是按套路解题，避免迷失刷题。...
贪心_贪心算法_
10-03
大一新手之贪心算法观赏练习，适合初学者使用！内含PPT和例题，请配合食用
贪心算法练习题.doc
10-10
贪心算法练习题.doc
贪心算法习题
01-30
贪心算法练习题， 主要设计算法，不侧重算法实现
贪心算法的C语言实现与运用详解
09-03
主要介绍了贪心算法的C语言实现与运用详解,运用么,就是文中所附的ACM练习题,哈哈:D需要的朋友可以参考下
C++中find()函数用法
热门推荐
qq_52051345的博客
07-25 4万+
algorithm中的find()函数 返回值是目标元素的下标，找不到时返回值为迭代器结尾 string = "hello"; find(s.begin(), s.end(), 'o') == s.end() string中的与find相关函数 ① find() string str1, str2; char c; str1.find(str2);//从串str1中查找时str...
关于n列火车的列车调度问题
qq_52051345的博客
10-25 2031
题目 编号为1，2，3，4的四列火车通过一个栈式的列车调度站，可能得到的调度结果有哪些？如果有n列火车通过调度站，请设计一个算法，输出所有可能的调度结果。 分析 栈具有先进后出、后进先出的特点，任何一个调度结果应该是1，2，3，4全排列中的一个元素。由于进栈的顺序是由小到大的，所以出栈序列应该满足以下条件：对于序列中的任何一个数其后面所有比它小的数应该是倒序的，例如4321是一个有效的出栈序列，1...
bfs经典例题
qq_52051345的博客
07-28 1801
给定一个大小为N x M的迷宫。迷宫由通道和墙壁组成，每一步可以由邻接的上下左右四格的通道移动。请求出从起点到终点所需最小步数。 （’#’、’.’、‘S’、'G’分别表示墙壁、通道、起点、终点） 输入： 10 10 #S######.# ......#..# .#.##.##.# .#........ ##.##.#### ....#....# .#######.# ....#..... .#...
递归判断字符串是否回文
qq_52051345的博客
03-31 1393
bool is_huiwen(char* str, int size) { if (size <= 1) return true; if (str[0] != str[size - 1]) return false; return is_huiwen(++str, size - 2); }
贪心算法练习：数列极差问题
最新发布
05-31
好的，我知道你的问题了。现在来回答你的问题： 题目描述： 给定一个长度为 $n$ 的数列 $a$，请你找到数列的最大值与最小值的差不小于 $k$ 的子段数。 输入格式： - 第一行包含两个整数 n 和 k，表示数列的长度和所求的差值。 - 第二行包含 n 个整数，表示整个数列。 输出格式： - 输出一个整数，表示答案。 输入样例： ``` 5 2 1 3 5 6 9 ``` 输出样例： ``` 5 ``` 算法分析： 这道题目可以使用贪心算法来解决，具体的做法是维护一个滑动窗口，用双指针维护窗口的左右端点，然后判断当前窗口的最大值与最小值的差是否不小于 $k$，如果不小于 $k$，那么就说明当前窗口的所有子段都满足要求，此时将窗口左端点右移，否则将窗口右端点右移，直到右端点越界为止。在这个过程中，需要使用两个单调队列来维护当前窗口内的最大值和最小值。 时间复杂度分析： 使用双指针维护滑动窗口的时间复杂度为 $O(n)$，单调队列的时间复杂度也为 $O(n)$，因此总时间复杂度为 $O(n)$。 参考代码：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值