贪心应用总结

前言

定义

所谓贪心选择是指应用同一规则，将原问题变为一个相似的但规模更小的子问题，

而后每一步都是当前看似最佳的选择，

且这种选择只依赖于已做出的选择，不依赖于未做出的选择。

依赖于未做出选择的，是 dp。

做题

对于贪心，当然是多刷刷题，知道这一类型的题目和做法。

在比赛考试的时候遇到贪心题目，一般都是问最大最小值。

推的时候，一定要注意排序方式是什么。

例如，在选择不相交区间问题时，是按结束时间早晚进行排序，而不是开始时间。

如果实在没注意到错了，写完之后出样例测试，静下来思考。

如果有 dfs（递归搜索）或 bfs（放入队列搜索），记得想想用记忆化优化。

一、区间选点问题

题干

给定 n 个闭区间，在数轴上选择尽量少的点，

使得每个区间 i 都至少有 $a_i$ 个点（不同区间内的点可以是同一个）。

策略：取最后一个。

P1250 种树

代码

/*
贪心 - 区间选点问题 
1.按照区间结束位置进行排序
2.从 1 到 n 区间进行选择：若
	1.已满足条件，跳过；
	2.若不能满足，选择区间最后的几个点加入集合。 
*/
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;

const int maxn = 30005;
int n, h;
int vis[maxn];
struct node{
	int b, e, t;
}a[maxn];
int ans;

int read ()
{
	int x = 1, s = 0;
	char ch = getchar ();
	while (ch < '0' or ch > '9'){if (ch == '-') x = -1; ch = getchar ();}
	while (ch >= '0' and ch <= '9') s = s * 10 + ch - '0', ch = getchar ();
	return x * s;
}

bool cmp (node a, node b)
{
	if (a.e == b.e) return a.b < b.b;
	return a.e < b.e;//按照结束位置！！！ 
}

int main ()
{
	n = read (), h = read ();
	for (int i = 1; i <= h; i++) a[i].b = read (), a[i].e = read (), a[i].t = read ();
	sort (a + 1, a + h + 1, cmp);
	for (int i = 1; i <= h; i++)
	{
		int cnt = 0;
		for (int j = a[i].b; j <= a[i].e; j++) if (vis[j]) cnt++;
		if (cnt >= a[i].t) continue;
		cnt = a[i].t - cnt;
		for (int j = a[i].e; j >= a[i].b; j--)//选择当前区间最后的几个点！！！ 
		{
			if (!vis[j])
			{
				vis[j] = 1;
				cnt--, ans++;
			}
			if (cnt == 0) break;
		}
	}
	printf ("%d\n", ans);
	return 0;
}

二、选择不相交区间问题

题干

给定 n 个开区间，尽量选择多个区间，使得这些区间两两没有公共点。

策略：优先选择右端点小的区间，这样后面就有更多空间选择。

P2255 [USACO14JAN]Recording the Moolympics S

更详细的题解：8.10 比赛题整理 T2

代码

/*
贪心 - 选择不相交区间问题
1.按照结束时间早晚进行排序
2.每次选择结束时间早的，这样才能让后面有更多选择 
*/
#include<bits/stdc++.h>
using namespace std;

#define int long long
const int maxn = 205;
int n;
int maxf, maxs;
struct node{
	int s, t;
	int vis;
}e[maxn * 2];
int f;

int read ()
{
	int x = 1, s = 0;
	char ch = getchar ();
	while (ch < '0' or ch > '9'){if (ch == '-') x = -1; ch = getchar ();}
	while (ch >= '0' and ch <= '9'){s = s * 10 + ch - '0'; ch = getchar ();}
	return x * s;
}

bool cmp (node a, node b)
{
	if (a.t != b.t) 
	return a.t < b.t;
	return a.s < b.s;//按结束时间早晚进行排序！！！ 
}

signed main ()
{
	n = read ();
	for (int i = 1; i <= n; i++) 
	{
		e[i].s = read ();
		e[i].t = read ();
		e[i].vis = 0;
	}
	sort (e + 1, e + n + 1, cmp);
	int ans = 0, r1 = 0, r2 = 0;
	for (int i = 1; i <= n; i++)//用循环而不是 dfs，可以大大优化时间复杂度 
	{
		if (r1 <= e[i].s)//选择结束早的 
		{
			ans++;
			r1 = e[i].t;
		}
		else if (r2 <= e[i].s)
		{
			ans++;
			r2 = e[i].t;
		}
		if (r1 < r2) swap (r1, r2);//求两个就复杂点 
	}
	printf ("%lld", ans);
	return 0;
}

三、区间覆盖问题

找不到你谷里的例题。。

题干

给 n 个闭区间，选择尽量少的区间覆盖一条指定的线段区间 $[s,t]$。

思路

将所有的区间按左端点从小到大排序，依次处理每个区间。

每次选择覆盖点 s 的区间中右端点坐（下）标最大的一个区间，

并将 s 更新为该区间的右端点坐标，直到选择的区间已包含了 t 为止。

四、流水作业调度问题

题干

有 n 个作业要在两台机器 M1 和 M2 组成的流水线上完成加工。

每个作业 i 都必须先花时间 $a_i$ 在 M1 上加工，

然后花时间 $b_i$ 在 M2 上加工。

给定 n 个作业的加工顺序，

使得从作业 1 在机器 M1 上加工到作业 n 在机器 M2 上加工完为止所用总时间最短。

P1248 加工生产调度

思路

要让加工总时最短，就是要让机器的空闲时间最短。

很明显，在 A 机器第一次开始工作的时候，B 机器在等待；

B 机器在最后一次工作的时候，A 机器也在等待。

所以，我们要让 A 机器上加工时间最短的部件最先加工；

B 机器上加工时间最短的部件最后加工。

---

设 $m_i\leftarrow \min a_i,b_i$。

将 m 按从小到大的顺序排序，然后从第 1 个开始处理，

若 $m_i=a_i$，则将它排在从头开始的作业后面；

若 $m_i=b_i$，则将它排在从尾开始的作业前面。

---

例如：

n = 5
(a1, a2, a3, a4, a5) = (3, 5, 8, 7, 10)
(b1, b2, b3, b4, b5) = (6, 2, 1, 4, 9)
(m1, m2, m3, m4, m5) = (3, 2, 1, 4, 9)
sort 之后 ——> (m3, m2, m1, m4, m5)

处理过程中的 ans 数组（最终处理先后顺序）变化如下：

\ \ \ \ 3
\ \ \ 2 3
1 \ \ 2 3
1 \ 4 2 3
1 5 4 2 3

---

这就是 Johnson 算法 （？？？）。

代码

/*
贪心 - 流水作业调度问题
ps：注意输入！
具体分析看博客吧。。太难说了 
*/
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

const int maxn = 1005;
int n;
int a[maxn], b[maxn];
struct node{
	int id, mi;
}e[maxn];
int ans[maxn];

int read ()
{
	int x = 1, s = 0;
	char ch = getchar ();
	while (ch < '0' or ch > '9'){if (ch == '-') x = -1; ch = getchar ();}
	while (ch >= '0' and ch <= '9'){s = s * 10 + ch - '0'; ch = getchar ();}
	return x * s;
}

bool cmp (node a, node b)
{
	return a.mi < b.mi;
}

int main ()
{
	n = read ();
	for (int i = 1; i <= n; i++) a[i] = read ();
	for (int i = 1; i <= n; i++) b[i] = read ();
	for (int i = 1; i <= n; i++)
	{
		e[i].mi = min (a[i], b[i]);//得出每一个项目较小需要的时间 
		e[i].id = i;
	}
	sort (e + 1, e + n + 1, cmp);
	int l = 0, r = n + 1;
	for (int i = 1; i <= n; i++)
	{
		if (e[i].mi == a[e[i].id]) {l++; ans[l] = e[i].id;}
		else {r--; ans[r] = e[i].id;}//求处理顺序 
	}
	l = r = 0;
	for (int i = 1; i <= n; i++)//求最终需要时间 
	{
		l += a[ans[i]];
		if (r < l) r = l;//每次 M2 都要在 M1 之后处理 
		r += b[ans[i]];
	}
	printf ("%d\n", r);
	for (int i = 1; i <= n; i++) printf ("%d ", ans[i]);
	return 0;	
} 

五、带限期和罚款的单位时间任务调度

题干

有 n 个任务，每个任务都要 1 个时间单位执行，

截止时间 $d_i$ 表示任务 i 必须在 $d_i$ 之前完成，否则扣款 $w_i$。

确认所有任务的执行顺序，使惩罚最少。

这个其实真的不难。。。

按罚款多少从小到大排序，每次越晚执行越好。

P1230 智力大冲浪

代码

/*
贪心 - 带限期和罚款的单位时间任务调度
1.按照罚款数量从大到小排序
2.尽量让每一个任务都在离期限最近的时间完成
  （这样就能在前面安排更多的任务了）
3.如果实在不能满足，就扣掉罚款 
*/
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

const int maxn = 505;
int n, m;
struct node{
	int e, w;
}a[maxn];
int vis[maxn];

int read ()
{
	int x = 1, s = 0;
	char ch = getchar ();
	while (ch < '0' or ch > '9'){if (ch == '-') x = -1; ch = getchar ();}
	while (ch >= '0' and ch <= '9') s = s * 10 + ch - '0', ch = getchar ();
	return x * s;
}

bool cmp (node a, node b)
{
	return a.w > b.w;//按照罚款数量排序！！！ 
}

int main ()
{
	m = read (), n = read ();
	for (int i = 1; i <= n; i++) a[i].e = read ();
	for (int i = 1; i <= n; i++) a[i].w = read ();
	sort (a + 1, a + n + 1, cmp);
	for (int i = 1; i <= n; i++)
	{
		int flag = 0;
		for (int j = a[i].e; j >= 1; j--)//越晚越好 
		{
			if (vis[j]) continue;
			vis[j] = 1;
			flag = 1;
			break;
		}
		if (!flag) m -= a[i].w;//实在不行就罚款 
	}
	printf ("%d\n", m);
	return 0;
}

---

贪心还是要多做题，多找找规律。

平时推题时的重点就是按照什么来排序 （直观反应的排序方式往往都不对），

然后就是好好想想怎么推算出最终答案省时间。

明天比赛 rp++~ —— 21 - 08 - 23

——$End$——