c++—0/1背包问题--贪心算法(详解)

此算法用冒泡排序和选择排序实现的!!

贪心算法的基本思想

•贪心算法的特点是每个阶段所作的选择都是局部最优的,它期望通过所作的局部最优选择产生出一个全局最优解。

贪心与动态规划:与动态规划不同的是,贪心是鼠目寸光动态规划是统揽全局

贪心:每个阶段产生的都是局部最优解

贪心算法的基本要素

•贪心选择性质:所求问题的全局最优解可以通过一系列局部最优的选择(即贪心选择)来达到。

–这是贪心算法与动态规划算法的主要区别。

•最优子结构性质:当原问题的最优解包含子问题的最优解时,称此问题具有最优子结构性质。

最优子结构性质是该问题可用动态规划算法或贪心算法求解的关键特征

贪心算法:

完整代码:

运行:

3 50

10 20 30

60 100 120

3 50

30 10 20

120 60 100

#include<bits/stdc++.h>
using namespace std;
//冒泡排序 
//void Sort(int n,double w[],double v[])
//{
//    int i,j;
//    float temp1,temp2;
//    for(i=1;i<=n;i++){
//    	for(j=1;j<=n-i;j++)//冒泡排序
//    	{
//    	    temp1=v[j]/w[j];
//    	    temp2=v[j+1]/w[j+1];
//    	    if(temp1<temp2)
//    	    {
//    	        swap(w[j],w[j+1]);
//    	        swap(v[j],v[j+1]);
//    	    }
//    	}
//	}
//}

//插入排序 
void Sort1(int n,double w[],double v[]){
	int max1;
	double t[20];
	for(int i=1;i<=n;i++){
		t[i]=v[i]/w[i];
		//cout<<t[i]<<endl;
	}
	for(int i=1;i<=n;i++){
		max1=i;
		for(int j=i+1;j<=n;j++){
			if(t[j]>t[max1]){
				max1=j;
			}
		}
		swap(t[i],t[max1]);
		swap(w[i],w[max1]);
		swap(v[i],v[max1]);
	}
	for(int i=1;i<=n;i++){
		cout<<t[i]<<endl;
	}
}
//n为物品数量,c为背包最大容量,w[]为物品重量,v[]为物品价值,b[]为背包存放 
void knapsack_greedy(int n,double c,double w[],double v[],double b[]){
	int j;
    //Sort1(n,w,v);
	Sort1(n,w,v);
	for(int i=1;i<=n;i++)//初始化背包b[]
		b[i]=0;
	for(j=1;j<=n;j++){
		if(c<w[j]) break;
		b[j]=1;
		c=c-w[j];
	} 
	if(j<=n)
		b[j]=c/w[j];
	cout<<"输出:"<<endl;
	for(int i=1;i<=n;i++){
		cout<<"物品重量为:"<<w[i]<<" "<<"物品比例"<<b[i]<<endl;
	}
}
int main(){
	int n,c;
	double b[20],w[20],v[20];
	cout<<"输入物品数量和背包容量:";
	cin>>n>>c;
	cout<<"输入物品重量(如:30 10 20):"; 
	for(int i=1;i<=n;i++)
		cin>>w[i];
	cout<<"输入物品的价值(如:120 60 100):"; 
	for(int i=1;i<=n;i++)
		cin>>v[i];
	knapsack_greedy(n,c,w,v,b);	
	return 0;
}

代码解析:

//Sort1(n,w,v);
	Sort1(n,w,v);

1.此函数用来在计算单位价值后排序,使得按照最大单位价值来从大到小排序(然后依次装入背包)

for(int i=0;i<n;i++)//初始化背包b[]
		b[i]=0;
for(j=0;j<n;j++){
		if(c<w[j]) break;
		b[j]=1;
		c=c-w[j];
} 

2.首先这是0/1背包问题,在数组b[]中存放的就是0或者1。第一个循环语句初始化为0,表示还没有装物品。

0或1表示的是:物品一整个全部装进去物品比例为1,完全没有装进去物品比例为0,如果背包容量未满,还能装下一个物品的一部分,那么就用剩余的背包容量/这个物品的重量(装进去的物品比例 :c/w[i] )---为小数(标红句子看下述代码)。

if(j<=n)
	b[j]=c/w[j];

在退出循环后,继续判断,物品还未装完,用剩余的背包容量/这个物品的重量(c/w[i])---为小数,也可能为0。

代码结果:

 

 

 

 请指教!!

  • 16
    点赞
  • 191
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
0-1背包问题是一个经典的动态规划问题,但是也可以使用贪心算法来求解。以下是使用贪心算法求解0-1背包问题的思路: 1. 将物品按照单位重量的价值从大到小排序。 2. 依次将物品放入背包中,如果能放下就放入,直到背包装满为止。 以下是使用C++实现贪心算法求解0-1背包问题的代码: ```c++ #include <iostream> #include <algorithm> using namespace std; struct item { int weight; // 物品重量 int value; // 物品价值 double unitValue; // 物品单位重量价值 }; bool cmp(item a, item b) { return a.unitValue > b.unitValue; } int knapsack(item items[], int n, int capacity) { // 将物品按照单位重量价值从大到小排序 sort(items, items+n, cmp); int ans = 0; // 最大价值 // 依次将物品放入背包中 for (int i = 0; i < n; i++) { if (items[i].weight <= capacity) { ans += items[i].value; capacity -= items[i].weight; } else { ans += items[i].unitValue * capacity; break; } } return ans; } int main() { int n = 5; int capacity = 10; item items[n] = {{2, 6}, {2, 3}, {6, 5}, {5, 4}, {4, 6}}; for (int i = 0; i < n; i++) { items[i].unitValue = items[i].value * 1.0 / items[i].weight; } int ans = knapsack(items, n, capacity); cout << "最大价值:" << ans << endl; return 0; } ``` 以上代码的输出结果为: ``` 最大价值:19 ``` 其中,物品的重量和价值分别存储在`item`结构体的`weight`和`value`成员变量中,`unitValue`成员变量表示单位重量的价值。使用`sort()`函数将物品按照单位重量价值从大到小排序,然后依次将物品放入背包中,直到背包装满为止。最后返回背包中物品的总价值即为最大价值。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值