贪心入门（洛谷题单）

P2240 部分背包问题

金币分割问题，按性价比排列后取满，第一次提交代码RE了一个用例，原因是要把相同性价比的金币按重量大小再进行排序。以下是AC代码

#include <iostream>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
	

struct ans {
	int w, v;
}c[105];
bool cmp(ans a, ans b) {
	return a.v * b.w > a.w * b.v;
}
int main()
{
	
		int N, T;
		cin >> N >> T;
		double solve = 0;
		
		for (int i = 1; i <= N; i++)
		{
			cin >> c[i].w >> c[i].v;
		}
		sort(c+1, c + N+1, cmp);
		for (int i = 1; i <= N; i++)
		{
			if (c[i].w <= T) solve += c[i].v, T-= c[i].w;
			else {
				solve += c[i].v * T * 1.0 / (c[i].w * 1.0);
				break;
			}
		}
		printf("%.2f", solve);
	return 0;
}

 P1223 排队接水

与前一题类似，这个问题依然要用到结构体排序，有一点不同的是要把后面每一个人的等待前面人的时间全部累加。以下是AC代码：

#include <iostream>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
struct solve
{
	double time;
	int id;
}a[1005];
bool cmp(solve a, solve b)
{
	return a.time < b.time;
}
int main()
{
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i].time;
		a[i].id = i;
	}
	sort(a + 1, a + n + 1, cmp);
	double ans=0;
	for (int i = 1; i <= n; i++)
	{
		cout << a[i].id<<" ";
	}
	for (int i = n - 1; i >= 1; i--)
	{
		int j = n - i;
		ans += a[j].time * i;
	}
	cout << endl;
	printf("%.2f", ans/n);
}

P1803 线段覆盖

这道题是经典的贪心问题，把结束时间全排序，开始时间小于前一个的结束时间，并且结束时间越早的加入。以下是AC代码：

#include <iostream>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
struct node
{
	int s, e;
}a[1000006];
bool cmp(node a,node b)
{
	return a.e <= b.e;
}
int main()
{
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin>>a[i].s>>a[i].e;
	}
	sort(a + 1, a + 1 + n, cmp);
	int st = 0; int en = 0; int ans = 0;
	for (int i = 1; i <= n; i++)
	{
		if (a[i].s < en)continue;
		else
		{
			ans++; en = a[i].e;
		}
	}
	cout << ans << endl;
}

P3817 小A的糖果

这道题贪心策略是遍历每两个相邻的数相加，如果大于给定数就把后面的吃掉一些，前提是保证第一个数要小于给定数。

#include <iostream>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
ll a[100005];
int main()
{
	int n, x;
	cin >> n>> x;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}
	ll ans = 0;
	if (a[1] > x) { ans += a[1] - x; a[1] -= ans; }
	for (int i = 1; i <= n-1; i++)
	{
		if (a[i] + a[i + 1] <=x)continue;
		else {
			int temp = a[i + 1] + a[i] - x;
			a[i + 1] -=temp; 
			ans += temp;
		}
	}
	cout << ans<<endl;
}

P1497 小陶摘苹果

按力气排序，高度够得直接加，不够的继续走，加完为止，比原来未升级版的版本简单很多

以下是AC代码：

#include <iostream>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
struct node {
	int x, y;
}a[5005];
bool cmp(node aa,node bb)
{
	return aa.y < bb.y;
}
int main()
{
	int n,s;
	cin >> n >> s;
	int  b,c;
	cin >> c >> b;
	int ans = 0;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i].x >> a[i].y;
	}
	sort(a + 1, a + 1 + n, cmp);
	for (int i = 1; i <= n; i++)
	{
		if (a[i].x > b + c)continue;
		if (a[i].y <= s) { ans++; s -= a[i].y; }
		else break;
	}
	cout << ans << endl;
}

P5019 铺设道路

这道题相比于前面几道题难一些，难在论证，我这里假设这是几段路，在除第一段路的每一段路都是前一个的深度小于后一个的深度，每一段都先孤立去看，那么我在填大坑的时候就一定会把小坑填上，换个角度就是我填完这个小坑那么我的大坑只能自己去填，那么他的差值就是一定无法避免去填的，那么只剩下第一条路了，这条路我一定会在填第一个坑的同时利用最后一段路径，把第一段路全部填平。以下是AC代码：

#include <iostream>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
int a[100005];
int main()
{
	ll ans = 0;
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}
	for (int i = 2; i <= n; i++)
	{
		if (a[i - 1] < a[i])ans += a[i] - a[i - 1];
	}
	cout << ans + a[1] << endl;
}

P1208 混合牛奶

与小陶的苹果类似，这里不再赘述。以下是AC代码：

#include <iostream>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
struct node {
	int  pi, ai;
}a[500050];
bool cmp(node aa, node bb)
{
	if (aa.pi != bb.pi)return aa.pi < bb.pi;
	else return aa.ai > bb.ai;
}
int main() 
{
	int ans = 0;
	int n, m;
	cin >> n >> m;
	for (int i = 1; i <= m; i++)
	{
		cin >> a[i].pi >> a[i].ai;
	}
	sort(a + 1, a + 1 + m, cmp);
	for (int i = 1; i <= m; i++)
	{
		if (a[i].ai < n) { ans += a[i].ai * a[i].pi; n -= a[i].ai; }
		if (a[i].ai >= n) { ans += a[i].pi * n; break; }
	}
	cout << ans << endl;
}

P1094 纪念品分配

这道题也是证明稍稍难一些，但很好理解，先排序，小的在前，大的在后，给两个指针分别指向小的和大的，看死不连续，实际还是连续的，一个小的匹配一个大的，匹配不成功大的单独成盒，大的数和最小的数都匹配不了，那么这个大的数只能单独一组，按这个思路，这个贪心成立。以下是AC代码：

#include <iostream>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
int w;
int a[30005];
int ans = 0;
int main()
{
	cin >> w;
	int n;
	cin >> n;
	int j = n;
	int m = 1;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}
	sort(a + 1,a + 1 + n);
	while(1)
	{
		if (m > j)break;
		if (m == j) { ans++; break; }
		if (a[m] + a[j] <= w) { m++; j--; ans++; }
		else { j--; ans++; }
	}
	cout << ans << endl;
	return 0;
}

P4995 跳跳！

这道题考的是一个平方的和被平方的数之间的关系，1+2=3,1的平方加2的平方小于3的平方，这道题也是按照这个道理，要尽可能的把差值变大，这样平方就会越大，贪心成立。以下是AC代码：

#include <iostream>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
ll ans = 0;
ll a[305];
int main()
{
	int n;
	cin >> n;
	int l = 1; 
	int r = n;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}
	sort(a + 1, a + 1 + n);
	for (int i = 1; i <= n - 1; i++)
	{
		if (i % 2 == 0) {  ans += (a[r] - a[l]) * (a[r] - a[l]); l++;}
		else { ans += (a[r] - a[l]) * (a[r] - a[l]); r--; }
	}
	cout << ans + a[n] * a[n]<<endl;
}