算法基础课-贪心

最新推荐文章于 2024-07-13 23:05:26 发布

Andantex

最新推荐文章于 2024-07-13 23:05:26 发布

阅读量124

点赞数

分类专栏： ACwing算法课笔记文章标签：算法

本文链接：https://blog.csdn.net/Crescenx/article/details/128116621

版权

ACwing算法课笔记专栏收录该内容

6 篇文章 6 订阅

订阅专栏

贪心

贪心

贪心

贪心能解决的问题是动态规划能解决的问题的子集

贪心的正确性证明在校内应该是作为一个重难点讲解的

贪心的试做：先按照某个特征进行排序，然后按照顺序进行操作

有关区间的贪心

区间选点

请添加图片描述

贪心思路

首先对所有区间按照右端点从小到大排序
按顺序遍历所有区间：
- 如果该区间内包含至少一个点了
  - pass
- 如果该区间还没有包含任何点
  - 将该区间的右端点加入点集

正确性证明

首先设按照贪心思路得到的答案是 $c n t$ ，真正的答案是 $a n s$
首先证明 $\leq cnt$
- 按照贪心思路进行选择，可以知道选择的点至少能满足“每个区间都包含点”
- 由于 $a n s$ 是所有选点的数量的下界，所以有 $\leq cnt$
证明 $\leq ans$
- 考察所有没被pass掉的区间
  - 由于每次都是从小到大选择右端点
  - 所以每次没被pass的区间与之前所有区间都没有交集
- 于是 $c n t$ 至多被所有区间的一个子集所包含：即那些没有交集的区间所组成的子集
- 由于 $a n s$ 的要求是让所有区间包含，由于有限子集的势至少小于等于全集
- 所以 $\leq ans$

代码思路：

由于点集是递增的
所以当且仅当，当前区间的左端点比点集里最右端的点还右，加入新点
所以只需要记录一下点集里最右边的端点即可

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010;
int n;
struct Range {
	int l, r;
	bool operator< (const Range &W)const {
		return r < W.r;
	}
} range[N];

int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; i ++ ) scanf("%d%d", &range[i].l, &range[i].r);

	sort(range, range + n);

	int res = 0, ed = -2e9;//ed是当前最右端点
	for (int i = 0; i < n; i ++ )
		if (ed < range[i].l) {
			res ++ ;
			ed = range[i].r;
		}

	printf("%d\n", res);

	return 0;
}

最大不相交区间数量

请添加图片描述本题和上一题是同一答案

区间分组

请添加图片描述

贪心思路：

将所有区间按照左端点从小到大排序
从前往后遍历每个区间
- 遍历当前已有的所有组
  - 如果当前区间能放进某个组，放
- 如果遍历完发现不存在这样的组，开辟一个新租

正确性证明

首先设按照贪心思路得到的答案是 $c n t$ ，真正的答案是 $a n s$
首先证明 $\leq cnt$
- 按照贪心思路进行选择，可知至少是个合法方案
- 由于 $a n s$ 是所有选点的数量的下界，所以有 $\leq cnt$
证明 $\leq ans$
- 在 $c n t$ 组中，一定能找到至少 $c n t$ 个区间，使得其两两相交都不为空
- 所以这 $c n t$ 个区间至少要被分配到 $c n t$ 个组里面去

代码思路

判断某个区间能不能放进某个组：
- 判断当前区间的左端点是不是比这个组的最右端还左
- 所以每个组只需要储存一个最右端端点值作为代表点即可
快速判断要不要开新组：
- 用小根堆维护所有组最右端点的最小值

#include <bits/stdc++.h>
using namespace std;
const int N = 100010;

int n;
struct Range {
	int l, r;
	bool operator< (const Range &W)const {
		return l < W.l;
	}
} range[N];

int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; i ++ ) {
		int l, r;
		scanf("%d%d", &l, &r);
		range[i] = {l, r};
	}

	sort(range, range + n);

	priority_queue<int, vector<int>, greater<int>> heap;
	for (int i = 0; i < n; i ++ ) {
		auto r = range[i];
		if (heap.empty() || heap.top() >= r.l) heap.push(r.r);//开新组
		else {//把当前区间放到最小值所在的组
			heap.pop();
			heap.push(r.r);
		}
	}

	printf("%d\n", heap.size());

	return 0;
}

区间覆盖

请添加图片描述
贪心思路：

将所有区间按照左端点从小到大排序
从前往后遍历每个区间
- 在所有能够覆盖 $s$ 区间之中，选择右端点最大的区间，加入覆盖集
- 将 $s$ 更新为该右端点

#include <bits/stdc++.h>
using namespace std;

const int N = 100010;

int n;
struct Range {
	int l, r;
	bool operator< (const Range &W)const {
		return l < W.l;
	}
} range[N];

int main() {
	int st, ed;
	scanf("%d%d", &st, &ed);
	scanf("%d", &n);
	for (int i = 0; i < n; i ++ ) {
		int l, r;
		scanf("%d%d", &l, &r);
		range[i] = {l, r};
	}

	sort(range, range + n);

	int res = 0;//记数
	bool success = false;//表示是否有方案
	for (int i = 0; i < n; i ++ ) {//双指针
		//慢指针：先找到可能覆盖的右端点的最大值
		int j = i, r = -2e9;
		while (j < n && range[j].l <= st) { //左端点比st小
			r = max(r, range[j].r);
			j ++ ;
		}

		if (r < st) {//最大值都比st小，不存在解
			res = -1;
			break;
		}

		res ++ ;//记录
		if (r >= ed) {
			success = true;
			break;
		}

		st = r;//更新
		i = j - 1;//更新快指针
	}

	if (!success) res = -1;
	printf("%d\n", res);

	return 0;
}

Huffman树

典
请添加图片描述

贪心策略：

每次选择最小的两堆果子合并，然后把新堆加入

#include <bits/stdc++.h>
using namespace std;

int main() {
	int n;
	scanf("%d", &n);

	priority_queue<int, vector<int>, greater<int>> heap;
	while (n -- ) {
		int x;
		scanf("%d", &x);
		heap.push(x);
	}

	int res = 0;
	while (heap.size() > 1) {
		int a = heap.top();
		heap.pop();
		int b = heap.top();
		heap.pop();
		res += a + b;
		heap.push(a + b);
	}

	printf("%d\n", res);
	return 0;
}