贪心算法(汽车加油问题、多元Huffman编码问题、装船问题、活动选择、最优合并问题、区间覆盖问题)

Fare-well

已于 2023-02-21 11:27:16 修改

阅读量1.1k

点赞数 1

分类专栏：数据结构与基础算法文章标签：贪心算法算法数据结构 c++

于 2022-10-25 19:19:46 首次发布

本文链接：https://blog.csdn.net/qq_51774501/article/details/127519518

版权

数据结构与基础算法专栏收录该内容

8 篇文章 6 订阅

订阅专栏

1.汽车加油问题

题目描述:
一辆汽车加满油后可行驶n公里。旅途中有若干个加油站。设计一个有效算法，指出应在哪些加油站停靠加油，使沿途加油次数最少。并证明算法能产生一个最优解。
对于给定的n和k个加油站位置，计算最少加油次数。

输入格式：
输入数据的第一行有2 个正整数n和k（n≤5000，k≤1000），表示汽车加满油后可行驶n公里，且旅途中有k个加油站。接下来的1 行中，有k+1 个整数，表示第k个加油站与第k-1 个加油站之间的距离。第0 个加油站表示出发地，汽车已加满油。第k+1 个加油站表示目的地。

输出格式：
将计算出的最少加油次数输出。如果无法到达目的地，则输出“No Solution!”。

样例
输入

7 7
1 2 3 4 5 1 6 6

输出

代码一（C++）：

#include<bits/stdtr1c++.h>
using namespace std;
int main() {
	int n, k, dis[1005];
	cin >> n >> k;
	int cnt = 0, s = n;
	for (int i = 0; i <= k; i++) {
		cin >> dis[i];
	}
	for (int i = 0; i <= k; i++) {
		if (dis[i] > n) {
			cout << "No Solution!";
			return 0;
		}
		if (s - dis[i] >= 0) {
			s -= dis[i];
		} else {
			cnt++;
			s = n - dis[i];
		}
	}
	cout << cnt;
	return 0;
}

代码二（Python）：

n, k = map(int, input().split())
ls = list(map(int, input().split()))
cnt, s = 0, n
for it in ls:
    if it > n:
        print("No Solution!")
        exit(0)
    if s - it >= 0:
        s -= it
    else:
        cnt += 1
        s = n - it
print(cnt)

2.多元Huffman编码问题

题目描述：
在一个操场的四周摆放着n堆石子。现要将石子有次序地合并成一堆。规定每次至少选2 堆最多选k堆石子合并成新的一堆，合并的费用为新的一堆的石子数。试设计一个算法，计算出将n堆石子合并成一堆的最大总费用和最小总费用。
对于给定n堆石子,计算合并成一堆的最大总费用和最小总费用。

输入：
输入数据的第1 行有2 个正整数n和k（n≤100000，k≤10000），表示有n堆石子，每次至少选2 堆最多选k堆石子合并。第2 行有n个数（每个数均不超过 100），分别表示每堆石子的个数。

输出：
将计算出的最大总费用和最小总费用输出，两个整数之间用空格分开。

样例
输入

7 3
45 13 12 16 9 5 22

输出

593 199

提示：
请注意数据范围是否可能爆int。

代码：

#include<bits/stdtr1c++.h>
using namespace std;
int main() {
	priority_queue<long long int> q1; //优先队列(大顶堆)
	priority_queue<long long int, vector<long long int>, greater<long long int>> q2; //优先队列(小顶堆)
	long long int n, k, t;
	cin >> n >> k;
	for (int i = 0; i < n; i++) {
		cin >> t;
		q1.emplace(t);
		q2.emplace(t);
	}
	long long int sum1 = 0, sum2 = 0;
	while (q1.size() > 1) { //在大顶堆中让合并次数最多则可计算出最大费用
		int x = q1.top();
		q1.pop();
		int y = q1.top();
		q1.pop();
		q1.emplace(x + y); //将当前合并结果再次入队
		sum1 += (x + y);
	}
	while (q2.size() % (k - 1) != 1) {
		q2.emplace(0); //因为石子堆的个数不一定正好整除k,所以需要进行补0操作直到堆的个数可以整除k
	}
	while (q2.size() > 1) { //在小顶堆中让合并次数最少则可计算出最小费用
		int ans = 0; //记录k次合并的值
		for (int i = 0; i < k; i++) {
			ans += q2.top();
			q2.pop();
		}
		q2.emplace(ans); //将当前合并结果再次入队
		sum2 += ans;
	}
	cout << sum1 << " " << sum2;
	return 0;
}

3.装船问题

题目描述：
王小二毕业后从事船运规划工作，吉祥号货轮的最大载重量为M吨，有10种货物可以装船。第i种货物有wi吨，总价值是pi。王小二的任务是从10种货物中挑选若干吨上船，在满足货物总重量小于等于M的前提下，运走的货物的价重比最大。

输入：
输入数据的第一行有一个正整数M(0 < M < 10000)，表示所有货物最大载重量。在接下来的10行中，每行有若干个数（中间用空格分开），第i行表示的是第i种货物的货物的总价值pi ,总重量wi。(pi是wi的整数倍，0 < pi , wi < 1000)

输出：
输出一个整数，表示可以得到的最大价值。

样例
输入

输出

提示：
价重比：计算其价值与重量之比

代码一（C++）：

#include<bits/stdtr1c++.h>
using namespace std;
struct node {
	int pi, wi;
	double per;
} goods[10];
bool cmp(node x, node y) {
	return x.per > y.per;
}
int main() {
	int M;
	cin >> M;
	for (int i = 0; i < 10; i++) {
		cin >> goods[i].pi >> goods[i].wi;
		goods[i].per = goods[i].pi / goods[i].wi * 1.0;
	}
	sort(goods, goods + 10, cmp);
	int sum = 0;
	for (int i = 0; i < 10; i++) {
		if (M >= goods[i].wi) {
			sum += goods[i].pi;
			M -= goods[i].wi;
		} else {
			sum += goods[i].per * M;
			break;
		}
	}
	cout << sum;
	return 0;
}

代码二（Python）：

class g:
    def __init__(self, pi, wi, per):
        self.pi, self.wi, self.per = pi, wi, pi / wi

ls = []
m = int(input())
for i in range(10):
    pi, wi = map(float, input().split())
    ls.append(g(pi, wi, pi / wi * 1.0))
ls = sorted(ls, key=lambda x: -x.per)
sum = 0
for it in ls:
    if m >= it.wi:
        sum += it.pi
        m -= it.wi
    else:
        sum += m * it.per
        break
print(int(sum))

4.活动选择

题目描述：
学校的大学生艺术中心周日将面向全校各个学院的学生社团开放，但活动中心同时只能供一个社团活动使用，并且每一个社团活动开始后都不能中断。现在各个社团都提交了他们使用该中心的活动计划（即活动的开始时刻和截止时刻）。请设计一个算法来找到一个最佳的分配序列，以能够在大学生艺术中心安排不冲突的尽可能多的社团活动。
比如有5个活动，开始与截止时刻分别为：

最佳安排序列为：1,4,5。

输入：
第一行输入活动数目ｎ（0<ｎ<100）；
以后输入ｎ行，分别输入序号为1到ｎ的活动使用中心的开始时刻ａ与截止时刻ｂ（a,b为整数且0<=a,b<24，a,b输入以空格分隔）。

输出：
输出最佳安排序列所包含的各个活动（按照活动被安排的次序，两个活动之间用逗号分隔），如果有多个活动安排序列符合要求输出字典序最小的序列。

样例
输入

输出

1,5,4

代码一（C++）：

#include <bits/stdtr1c++.h>
using namespace std;
struct node {
	int id, begin, end;
} act[1005];
bool cmp(node x, node y) {
	return x.end == y.end ? x.id < y.id : x.end < y.end;
}
int main() {
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> act[i].begin >> act[i].end;
		act[i].id = i + 1;
	}
	sort(act, act + n, cmp);
	int now = -1;
	for (int i = 0; i < n; i++) {
		if (act[i].begin >= now) {
			if (i == 0) cout << act[i].id;
			else cout << ',' << act[i].id;
			now = act[i].end;
		}
	}
	return 0;
}

代码二（Python）：

class act:
    def __init__(self, id, b, e):
        self.id, self.b, self.e = id, b, e

n, ls1, ls2 = int(input()), [], []
for i in range(n):
    b, e = map(int, input().split())
    ls1.append(act(i + 1, b, e))
ls1 = sorted(ls1, key=lambda x: (x.e, x.id))
now = -1
for it in ls1:
    if it.b >= now:
        ls2.append(it.id)
        now = it.e
print(*ls2, sep=',')

5.最优合并问题

题目描述：
给定k 个排好序的序列s1 , s2,……, sk , 用2 路合并算法将这k 个序列合并成一个序列。假设所采用的2 路合并算法合并2 个长度分别为m和n的序列需要m + n -1次比较。试设计一个算法确定合并这个序列的最优合并顺序，使所需的总比较次数最少。
为了进行比较，还需要确定合并这个序列的最差合并顺序，使所需的总比较次数最多。
对于给定的k个待合并序列，计算最多比较次数和最少比较次数合并方案。

输入：
输入数据的第一行有1 个正整数k（k≤1000），表示有k个待合并序列。接下来的1 行中，有k个正整数，表示k个待合并序列的长度。

输出：
输出两个整数，中间用空格隔开，表示计算出的最多比较次数和最少比较次数。

样例
输入

4
5 12 11 2

输出

78 52

代码一（C++）：

#include<bits/stdtr1c++.h>
using namespace std;
//获得最多比较次数
int getMax(vector<int> v1) {
	int sum1 = 0;  //sum记录次数
	sort(v1.begin(), v1.end(), greater<int>()); //按照从大到小排序
	//合并的时候，当size=1时，说明只剩下1个数了，合并完毕
	while (v1.size() > 1) {
		int t = 0; //t为临时变量，用来记录 两个序列合并之后的长度
		t += (v1[0] + v1[1]);
		v1[1] = t;  //让第二个先变成合并之后的长度，两个最大的相加之后赋给第二个值，可以保证还是有序的
		sum1 += (t - 1);
		v1.erase(v1.begin()); //把开头第一个数删掉
	}
	return sum1;
}
//获得最小比较次数，稍微麻烦些，需要每合并两个就要进行排序一次，因为合并完的需要重新放到vector中，但是无论是放到开头还是放到末尾，都不能保证有序，所以需要重新排序。
int getMin(vector<int> v2) {
	int sum2 = 0;
	sort(v2.begin(), v2.end());
	while (v2.size() > 1) {
		int t = 0;
		t += (v2[0] + v2[1]);
		v2.emplace_back(t);
		sum2 += (t - 1);
		v2.erase(v2.begin(), v2.begin() + 2);
		sort(v2.begin(), v2.end());
	}
	return sum2;
}
int main() {
	int n;
	vector<int> v;
	cin >> n;
	int num;
	for (int i = 0; i < n; i++) {
		cin >> num;
		v.emplace_back(num);
	}
	cout << getMax(v) << " " << getMin(v);
	return 0;
}

代码二（Python）：

n = int(input())
ls = list(map(int, input().split()))
sum1, sum2 = 0, 0  # sum1为最多次,sum2为最少次
ls1 = sorted(ls, reverse=True)  # 降序排列
while len(ls1) > 1:
    sum1 += ls1[0] + ls1[1] - 1
    ls1[1] += ls1[0]
    del ls1[0]  # 删除第一个数
ls2 = sorted(ls)  # 升序排列
while len(ls2) > 1:
    sum2 += ls2[0] + ls2[1] - 1
    ls2.append(ls2[0] + ls2[1])  # 将合并后的数暂时放在末尾
    del ls2[0:2]
    ls2 = sorted(ls2)  # 因为最小的两个数合并之后的数大小不确定,需要重新排序
print(sum1, sum2)

6.区间覆盖问题

题目描述：
设x1 , x2 ,…… , xn 是实直线上的n 个点。用固定长度的闭区间覆盖这n 个点，至少需要多少个这样的固定长度闭区间?
对于给定的实直线上的n个点和闭区间的长度k，设计解此问题的有效算法，计算覆盖点集的最少区间数，并证明算法的正确性。

输入：
输入数据的第一行有2 个正整数n和k（n≤10000，k≤100），表示有n个点，且固定长度闭区间的长度为k。接下来的1 行中，有n个整数，表示n个点在实直线上的坐标（可能相同）。

输出：
输出一个整数，表示计算出的最少区间数输出

样例
输入

7 3
1 2 3 4 5 -2 6

输出

代码一（C++）：

#include<bits/stdtr1c++.h>
using namespace std;
int main() {
	int n, k, t, cnt = 0;
	set<int> st1; //利用集合中元素的唯一性、有序性储存数据
	cin >> n >> k;
	for (int i = 0; i < n; i++) {
		cin >> t;
		st1.insert(t);
	}
	t = INT_MIN; //用于记录当前放入的固定区间可覆盖的最大坐标
	//贪心算法进行处理
	for (auto it : st1) {
		if (t < it) { //说明不能覆盖
			cnt += 1; //添加固定区间的个数
			t = it + k; //更新当前放入的固定区间可覆盖的最大坐标
		}
	}
	cout << cnt;
	return 0;
}

代码二（Python）：

n, k = map(int, input().split())
st = sorted(set(map(int, input().split())))
cnt, t = 0, -float('inf')
for it in st:
    if t < it:
        cnt += 1
        t = it + k
print(cnt)

Fare-well

关注

1
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
贪心算法(汽车加油问题、多元Huffman编码问题、装船问题、活动选择、最优合并问题、区间覆盖问题)

输入数据的第一行有2 个正整数n和k（n≤5000，k≤1000），表示汽车加满油后可行驶n公里，且旅途中有k个加油站。输入数据的第1 行有2 个正整数n和k（n≤100000，k≤10000），表示有n堆石子，每次至少选2 堆最多选k堆石子合并。输入数据的第一行有2 个正整数n和k（n≤10000，k≤100），表示有n个点，且固定长度闭区间的长度为k。, xn 是实直线上的n 个点。对于给定的实直线上的n个点和闭区间的长度k，设计解此问题的有效算法，计算覆盖点集的最少区间数，并证明算法的正确性。
复制链接

扫一扫

专栏目录