贪心法例题

最新推荐文章于 2022-11-30 13:50:00 发布
最新推荐文章于 2022-11-30 13:50:00 发布
阅读量285 收藏
点赞数
分类专栏： algurithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42683011/article/details/109182341
版权

今日白嫖 1/∞ 🤣

01背包

//贪心法求解背包问题

/*
7 15
2 10
3 5
5 15
7 7
1 6
4 18
1 3
 */

struct thing{
	int w=0;
	int p=0;
	double wp=0;
};

bool cmp(thing &t1, thing &t2){
	return t1.wp>t2.wp;
}

void pro_1(){
	int n=0, size=0;
	scanf("%d%d",&n, &size);
	vector<thing> things(n);
	for(int i=0;i<n;++i){
		scanf("%d%d",&things.at (i).w,&things.at (i).p);
		things.at (i).wp=things.at (i).p*1.0/things.at (i).w;
	}
	sort(things.begin (), things.end (), cmp);
//	for(auto &temp: things){
//		printf("%d %d %lf\n",temp.w, temp.p, temp.wp);
//	}
	int sizeNow=0;
	int price=0;
	for(int i=0;i<n; ++i){
		if(sizeNow+things.at (i).w<=size){
			sizeNow+=things.at (i).w;
			price+=things.at (i).p;

		}else{
			break;
		}
	}
	printf("%d",price);

	return ;
}

OJのAC代码:

http://acm.cugb.edu.cn/problem_show.php?pid=2331

http://acm.cugb.edu.cn/problem_show.php?pid=1262

#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <map>
#include <vector>
#include <queue>

#define INF 0x3f3f3f3f

using namespace std;



//---------------------------------
//贪心法:

//贪心法求解背包问题

/*
7 15
2 10
3 5
5 15
7 7
1 6
4 18
1 3
 */

struct thing{
	int id=0;
	int w=0;
	int p=0;
	double wp=0;
	int useWeight=0;
};

bool cmp(thing &t1, thing &t2){
	return t1.wp>t2.wp;
}

bool cmp_id(thing &t1, thing &t2){
	return t1.id<t2.id;
}

void pro_1(){
	int n=0, size=0;
	scanf("%d%d",&n, &size);
	vector<thing> things(n);
	for(int i=0;i<n;++i){
		things.at (i).id=i;
		scanf("%d%d",&things.at (i).w,&things.at (i).p);
		things.at (i).wp=things.at (i).p*1.0/things.at (i).w;
	}
	sort(things.begin (), things.end (), cmp);
//	for(auto &temp: things){
//		printf("%d %d %lf\n",temp.w, temp.p, temp.wp);
//	}
	int sizeNow=0;
	double price=0;
//	vector<int> weight;
	for(int i=0;i<n; ++i){
		if(sizeNow+things.at (i).w<=size){
			sizeNow+=things.at (i).w;
			things.at (i).useWeight=things.at (i).w;
			price+=things.at (i).p;

		}else{
			things.at (i).useWeight=size-sizeNow;
			price+=(size-sizeNow)*things.at (i).wp;
			break;
		}
	}
	sort(things.begin (), things.end (), cmp_id );
	printf("%.2lf\n",price);
	printf("%d",things.at (0).useWeight);
	for(int i=1;i<n;++i){
		printf(" %d",things.at (i).useWeight);
	}

	return ;
}

int main() {

	pro_1 ();

	return 0;
}

最小生成树:

OJのAC代码:

http://acm.cugb.edu.cn/problem_show.php?pid=1036

这里用的Kruscal算法

#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <map>
#include <vector>
#include <queue>

#define INF 0x3f3f3f3f

using namespace std;



const int MAX=105;
int graph[MAX][MAX]={0};

struct edge{
	int p1;
	int p2;
	int length=0;
};

bool cmp(edge &e1, edge &e2 ){
	return e1.length<e2.length;
}

void initialize(vector<int> &p){
	int n=p.size ();
	for(int i=0;i<n;++i){
		p.at (i)=i;
	}
	return ;
}

int find(int p, vector<int> &father){
	if(father.at (p)==p){
		return p;
	}else{
		return father.at (p)=find(father.at (p),father);
	}
}

int unionPoints(int p1, int p2, vector<int> &father){
	int father1=find(p1,father);
	int father2=find(p2,father);
	father.at (father2)=father1;
	return father1;
}

void pro_2(){
	int n=0;
	scanf("%d",&n);
	vector<edge> e;
//	for(int i=1;i<3;++i){
//		for(int j=0;j<80;++j){
//			printf("%d ",count++);
//		}
//		putchar('\n');
//	}

	int edgeCount=0;
	for(int i=0;i<n;++i){
		for(int j=0;j<n;++j){
			e.push_back (edge());
			e.at (edgeCount).p1=i;
			e.at (edgeCount).p2=j;
			scanf("%d",&e.at (edgeCount++).length);
		}
	}

//	for(int i=0;i<n;++i){
//		for(int j=0;j<n;++j){
//			printf("%d ",graph[i][j]);
//		}
//		putchar('\n');
//	}

//	for(auto &temp:e){
//		printf("%d--->%d=%d\n",temp.p1, temp.p2, temp.length);
//	}

	sort(e.begin (), e.end (), cmp);
	vector<int> father(n);
	initialize (father);
	int len=0;
	for(int i=0, count=0;i<edgeCount && count<n;++i){
		edge &nowEdge=e.at (i);
		if(find(nowEdge.p1, father)!=find(nowEdge.p2, father)){
			unionPoints (nowEdge.p1, nowEdge.p2, father);
			len+=nowEdge.length;
			++count;
		}
	}
	printf("%d",len);

	return ;
}



int main() {

	pro_2 ();

	return 0;
}

最小生成树进阶

http://acm.cugb.edu.cn/problem_show.php?pid=1191

#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <map>
#include <vector>
#include <queue>

#define INF 0x3f3f3f3f

using namespace std;



const int MAX=105;

struct edge{
	int p1;
	int p2;
	int length=0;
};

bool cmp(edge &e1, edge &e2 ){
	return e1.length<e2.length;
}

void initialize(vector<int> &p){
	int n=p.size ();
	for(int i=0;i<n;++i){
		p.at (i)=i;
	}
	return ;
}

int find(int p, vector<int> &father){
	if(father.at (p)==p){
		return p;
	}else{
		return father.at (p)=find(father.at (p),father);
	}
}

int unionPoints(int p1, int p2, vector<int> &father){
	int father1=find(p1,father);
	int father2=find(p2,father);
	father.at (father2)=father1;
	return father1;
}


vector<edge> e;
void pro_3(){
	int testNum=0;
	scanf("%d",&testNum);
	while(testNum--){
		int n,m,k;
		scanf("%d%d%d",&n,&m,&k);

		const int MAX_P=505;
		vector<int> father(MAX_P);
		initialize (father);

		for(int i=0;i<m;++i){
			e.push_back (edge());
			scanf("%d%d%d", &e.at (i).p1, &e.at (i).p2,&e.at (i).length);
		}
		sort(e.begin (), e.end (), cmp );

		int tempPoint[MAX_P]={0};
		for(int i=0;i<k;++i){
			int pointN=0;
			scanf("%d",&pointN);
			for(int j=0;j<pointN;++j){
				scanf("%d",&tempPoint[j]);
			}
			for(int j=1;j<pointN;++j){
				unionPoints (tempPoint[j-1],tempPoint[j],father);
			}
		}

		int price=0;
		for(int i=0, count=0;i<m && count<n; ++i){
			edge &nowEdge=e.at (i);
			if(find(nowEdge.p1, father)!=find(nowEdge.p2, father)){
				unionPoints (nowEdge.p1, nowEdge.p2, father);
				price+=nowEdge.length;
			}
		}

		//检测所有城市是否都为同一个集合
		int father1=find(1, father);
		bool flag=true;
		for(int i=2;i<=n;++i){
			if(father1!=find(i,father)){
				flag=false;
				break;
			}
		}

		//输出
		if(flag){
			printf("%d\n",price);
		}else{
			printf("-1\n");
		}

	}

	return ;
}



int main() {

	pro_3 ();

	return 0;
}

单源最短路:

http://acm.cugb.edu.cn/problem_show.php?pid=1077

#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <map>
#include <vector>
#include <queue>
#include <stack>

#define INF 0x3f3f3f3f

using namespace std;

/*
6 4
1 2 1
1 3 4
1 4 5
2 3 6
3 4 3
2 4 2

*/

const int MAX=1005;
int graph[MAX][MAX]={0};
int dis[MAX]={0};
bool visited[MAX]={0};

void pro_4(){
	int t, n;
	scanf("%d%d",&t, &n);

	for(int i=1;i<=n;++i){
		for(int j=1;j<=n;++j){
			graph[i][j]=INF;
		}
	}
	for(int i=0;i<=n;++i){
		graph[i][i]=0;
	}
	for(int i=1;i<=n;++i){
		dis[i]=INF;
	}
	dis[n]=0;


	int p1,p2,l;
	for(int i=0;i<t;++i){
		scanf("%d%d%d",&p1, &p2, &l);
		graph[p1][p2]=l;
		graph[p2][p1]=l;
	}

	queue<int> p;
	p.push (n);

	int nodeNow=n;
	while(!p.empty ()){
		nodeNow=p.front ();
		p.pop ();
		for(int i=1;i<=n;++i){
			if(graph[nodeNow][i]!=INF){
				dis[i]=min(dis[i],dis[nodeNow]+graph[nodeNow][i]);
			}
			if(!visited[i]){
				p.push (i);
			}
		}
		visited[nodeNow]=true;
	}

//	for(int i=1;i<=n;++i){
//		printf("%d ", dis[i]);
//	}
	printf("%d",dis[1]);

	return ;
}


int main() {

	pro_4 ();

	return 0;
}
Janus_V
关注
专栏目录
贪心法
Junds0的博客
05-20 634
本关任务：理解并实现Huffman编码树;本关任务：理解并实现无向图的最小生成树;本关任务：理解并实现单源点最短路径;本关任务：完成 乘船问题;
贪心算法例题【Java解法】
qq_45294437的博客
05-09 1143
贪心算法例题【Java解法】一、基本概念二、贪心算法的基本思路三、贪心算法适用的问题四、例题分析 一、基本概念 贪心算法（greedy algorithm），又称贪婪算法，是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致结果是最好或最优的算法。 个人理解:贪心算法从名字上看重点是贪心这个词，贪心即欲望大，不知满足。在算法中贪心体现在将问题划分成多个子问题后，对每个子问题都要求当前子问题的最优解。同时贪心这个词也能很好地体现该算法的适用范围，贪心策略必须具备无后效性，
算法设计与分析—贪心法求解背包问题C++（学习笔记）
zzz111888zzzggg的博客
12-05 2196
#include<iostream> #include <algorithm> using namespace std; typedef struct { //利用结构体联系w和v int w; int v; }act; bool Comp(act a, act b) { return a.v > b.v; //比较排序 } int KnapSack(act *a, int n, int c) { int i; do.
贪心法求解背包问题
arthu6的博客
10-27 3859
问题描述：7个物品，重为{2,3,5,7,1,4,1}，价值为{10,5,15,7,6,18,3}，背包容量W=15,求最优解。 思路：将物品按单重价值降序排列，装满为止。 C++代码： #include&lt;iostream&gt; #include&lt;iomanip&gt; using namespace std; int KnapSack(int w[],int v[],in...
用贪心法求解背包问题
SzMing
10-28 2409
贪心方法：总是对当前的问题作最好的选择，也就是局部寻优。最后得到整体最优。 应用：1：该问题可以通过“局部寻优”逐步过渡到“整体最优”，这是贪心选择性质与“动态规划”的主要差别。 2：最优子结构性质：某个问题的整体最优解包含了“子”问题的最优解。 完整的代码如下： [cpp] view plaincopyprint? #include "iostream"   usi
贪心算法求解背包问题
weixin_30614587的博客
12-06 265
一.贪心算法 　　1.贪心算法概念 　　贪婪算法(Greedy algorithm)是一种对某些求最优解问题的更简单、更迅速的设计技术。用贪婪法设计算法的特点是一步一步地进行，常以当前情况为基础根据某个优化测度作最优选择，而不考虑各种可能的整体情况，它省去了为找最优解要穷尽所有可能而必须耗费的大量时间，它采用自顶向下，以迭代的方法做出相继的贪心选择，每做一次贪心选择就将所求问题简化为一个规模更...
贪心思想及例题
weixin_46438976的博客
01-14 1987
贪心（greedy)思想：一个问题拆解成多个步骤，每个步骤采用最优的解法（叫局部最优），不考虑对别的步骤的影响。 最少硬币问题： 题目描述：某人带着3种面值的硬币去购物，有1元、2元、5元的，硬币数量不限；他需要支付M元，问怎么支付，才能使硬币数量最少？ 思路：根据生活常识，第一步应该先拿出面值最大的5​ 元硬币，第二步拿出面值第二大的2​ 元硬币，最后才拿出面值最小的1​ 元硬币。在这个解决方案中，硬币数量总数是最少的。 #include<bits/stdc++.h> usi...
埃及分数 贪心法——C语言代码r
05-23
【标题】：“埃及分数 贪心法——C语言代码” 在编程领域，尤其是在算法设计中，贪心法是一种常用的技术策略。贪心法的基本思想是，在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致...
贪心算法经典例题.pdf
06-22
例如，找币问题可以用贪心法求解，但如果币值的选择不当，则不能使用贪心法求解。 二是确定了可以用贪心算法之后，如何选择一个贪心标准，才能保证得到问题的最优解。在选择贪心标准时，我们要对所选的贪心标准进行...
用贪心法求解背包问题的解决方法
01-20
贪心方法：总是对当前的问题作最好的选择，也就是局部寻优。最后得到整体最优。应用：1：该问题可以通过“局部寻优”逐步过渡到“整体最优”，这是贪心选择性质与“动态规划”的主要差别。2：最优子结构性质：某个问题的整体最优解包含了“子”问题的最优解。完整的代码如下： 代码如下:#include “iostream”using namespace std;struct goodinfo{ float p; //物品效益 float w; //物品重量 float X; //物品该放的数量 int flag; //物品编号};//物品信息结构体void Insertionsort(goodinfo goo
贪心法---背包问题
qq_38210187的博客
11-01 371
注意这个背包问题不是0/1背包问题    这个可以允许存入部分物品，而后者不允许存入部分物品 算法描述：C++ #include "stdafx.h" #include&lt;iostream&gt; #include&lt;iomanip&gt; using namespace std; int KnapSack(int w[],int v[],int n,int C) {        ...
贪心算法-背包问题
这片海的博客
05-07 1620
贪心算法：当前最优解   例如在删除数的一个例子中，一个长度不大于240位的整数中，随机删除N个数，要求使得剩余的数： 从左到右的，组成一个最小的整数  贪心步骤： 例如 一个数： 1457326      N=4 1).找到当前最大的数： 7 删除；145326 2).找到当前最大的数： 6 删除；14532 3).找到当前最大的数： 5 删除；1432 4).找到当前最大的数：
【贪心算法】背包问题
最新发布
cqn2bd2b的博客
11-30 1604
其实该情况是符合贪心策略的，因为该总情况不管先选哪两个都会把背包塞满，因为该题物品可以分割成任意大小，所以，就算空下一下，也可以将最 　　后一个物品分割，放进去，它们 　　的单位重量的价值是一样的，所以，最后背包最后重量相同，重量相同那么价值也相同。cout
贪心法解部分背包问题
weixin_30276935的博客
12-25 225
[问题]给定n种物品和1个背包，背包允许的最大重量为Capacity。物品i的重量为weight[i]，价值为value[i]。与0-1背包问题(每种物品只有装入背包或不装入背包两种选择)不同的是，在选择物品i装入背包时，可以只装入物品i的一部分。 问应当怎样选择物品装入背包，使背包中的物品的总价值最大？ [解析]该问题可用贪心法解决，所采取的贪心策略如下： ...
背包问题——贪心算法
qq_35424507的博客
09-03 392
// 分别以不同起点开始进行以当前最优的策略选择，直到依次遍历所有的开始点 // An highlighted block #include<stdio.h> #include<stdlib.h> #define MAXSIZE 60 bool HasExist(int Exist[],int len,int flag){ for (int i = 0; i < len; i++) { if(Exist[i]==flag)
贪心法 习题10道
qq_46523755的博客
03-28 602
HDOJ 1009 FatMouse’ Trade 思路 按照J[i]/F[i]排序。从比值大的开始计算。 #include<bits/stdc++.h> using namespace std; struct food{ int j; int f; double rate; }getfood[1001]; bool comp(struct food a,struct food b){ return (a.rate) < (b.rate); } int
贪心算法——2.3背包问题
Geek
08-17 848
问题描述如上，假设山洞有n种宝物，每一种有对应的种类w和价值v，毛驴的运载能力有限，只能运走m质量的宝物，一种宝物只能拿一样，但可以分割，如何使得总价值最大？ 我们可以采用贪心策略，每次挑选单位质量价值最大的宝物，从而达到最优解 ，图解如下：     #include&lt;iostream&gt; #include&lt;algorithm&gt; const int M=...
备战蓝桥——贪心算法（经典背包问题）
SuperYang的博客
01-26 538
一、前言 本人菜鸟一枚，无奈在老师的“坑蒙拐骗”之下报了2020年3月份的蓝桥杯，为了能够让成绩不太难看（主要是因为交了300报名费） 于是发奋图强，修炼内功数据结构与算法 本章介绍 本章内容：我个人对贪心算法的一些认知与理解。为了更生动形象的展现贪心算法，章节内使用了贪心算法的经典问题–背包问题，来理解贪心算法。 二、贪心算法与背包问题介绍 1、贪心算法介绍 贪心算法（又称贪婪算法）是指，在对问...
贪心法与动态规划：例题解析与空间优化
本资源主要针对程序设计基础的第12章，探讨了贪心法与动态规划这两种算法技巧。首先，贪心法是一种求解优化问题的方法，它强调每一步都采取局部最优决策，逐步逼近全局最优解。例如，在编辑距离问题中，通过每次删除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值