算法设计和分析实验四：贪心算法求解背包问题
实验五：贪心算法求解背包问题
实验内容
应用贪心算法求解离散背包问题，分析时间复杂度。
有一个承重为W的背包和n个物品，它们各自的重量和价值分别是wi和vi（1<=i<=n），设求这些物品中最有价值的一个子集。
如果每次选择某一个物品的时候，只能全部拿走，则这一问题称为离散（0-1）背包问题；如果每次可以拿走某一物品的任意一部分，则这一问题称为连续背包问题。
算法思想
•动态规划的思想：
–对较小的子问题进行一次求解，并把结果记录下来，然后利用较小问题的解，求解出较大问题的解，直到求解出最大问题的解。
–
引进一个二维数组ch[MAX][MAX]，用ch[i][j]记录CH1与CH2的LCS 的长度，b[i][j]记录ch[i][j]是通过哪一个子问题的值求得的，以决定搜索的方向。
我们是自底向上进行递推计算，那么在计算ch[i,j]之前，ch[i-1][j-1]，
ch[i-1][j]与ch[i][j-1]均已计算出来。
此时我们根据CH1 [i] = CH2[j]还是CH1[i] != CH2[j]，就可以计算出ch[i][j]。
算法
length(string CH1,string CH2,int b[MAX][MAX])
//用于构建动态数组
//输入：两字符窜
//输出：最长公共子序列
for(i=1;i<=ch1Len;i++)//二重循环求解
for(int j=1;j<=ch2Len;j++)
{
if(CH1[i-1]==CH2[j-1])//相等字符
{
ch[i][j]=ch[i-1][j-1]+1;
b[i][j]=0;
}
else if(ch[i-1][j]>=ch[i][j-1])//上比较大
{
ch[i][j]=ch[i-1][j];
b[i][j]=1;
}
else//左比较大
{
ch[i][j]=ch[i][j-1];
b[i][j]=-1;
}
}
printCS(int b[MAX][MAX],string x,int i,int j)
//回溯求出最长子序列输出
//输入：标记数组
//输出：最长子序列
if(i == 0 || j == 0)//边界，返回
return;
if(b[i][j] == 0)
{
printCS(b, x, i-1, j-1);//左上
cout<<x[i-1]<<" ";
}
else if(b[i][j] == 1)
printCS(b, x, i-1, j);//上
else
printCS(b, x, i, j-1);//左
源程序
//应用贪心算法求解离散背包问题
#include<iostream>
using namespace std;
#define MAX 100
//结构体
struct Elem
{
double W;
double V;
double P;
int number;
};
//顺序表
struct SqList
{
Elem *elem;
int length;
int listsize;
};
//构造一个空的线性顺序表
void InitList_Sq(SqList &L)
{
L.elem=(Elem *)malloc(100*sizeof(Elem));
L.length=0;
L.listsize=100;
}
//********************************
//构造背包,顺序表
//******************************
void input(SqList &L)
{
cout<<"请输入物品的个数：";
cin>>L.length;
for(int i=0;i<L.length;i++)
{
cout<<"请输入第"<<i+1<<"个物品的重量和价值：";
cin>>L.elem[i].W>>L.elem[i].V;
L.elem[i].P=L.elem[i].V/L.elem[i].W;
cout<<"价值比为："<<L.elem[i].P<<endl;
L.elem[i].number=i+1;
}
}
//*********************************
//插入排序由大到小
//*******************************
void inser(SqList &L)
{
Elem inserter;
int index;//inserter待插入合适位置的元素,index指示插入位置
for(int pass=1;pass<L.length;pass++){ //共比较size-1轮
inserter=L.elem[pass];//第pass轮时,待插入的对象是a[pass]
index=pass-1;
while(index>=0&&inserter.P>L.elem[index].P){ //寻找插入位置L.elem[index+1]=L.elem[index];
index--; //指针前移，再比较
}
L.elem[index+1]=inserter;//跳出while时，找到插入位置
}//end of for
cout<<"按照价值比由大到小排列的顺序为：";
for(pass=0;pass<L.length;pass++)
cout<<L.elem[pass].number<<" ";
cout<<endl;
}
//*************************************************8
//背包程序
//采用贪心算法
//根据价值和重量的比来实现贪心算法
//************************************************
void bag(SqList L)
{
double w,sumV=0,sumW=0;
int list[MAX],a=0;
cout<<"请输入背包承重量W:";
cin>>w;
inser(L);
for(int i=0;i<L.length;i++) {
while(sumW+L.elem[i].W<=w)
{
sumW=sumW+L.elem[i].W;
sumV=sumV+L.elem[i].V;
list[a++]=L.elem[i].number;
}
}
cout<<"最后包里的总重量为："<<sumW<<endl;
cout<<"最后包里的总价值为："<<sumV<<endl;
cout<<"放到背包中的物品的序号列表为：";
for(i=0;i<a;i++)
{
cout<<list[i]<<" ";
}
}
int main()
{
cout<<"贪心算法求解背包问题"<<endl;
SqList L;
InitList_Sq(L);
input(L);
bag(L);
return 0;
}
实验结论
1、运行截图
查找最长公共子序列长度时的动态规划两个for循环，时间复杂度为Ｏ（ｎ＊ｎ）。
在回溯查找时，由于每次调用至少向上或向左（或向上向左同时）移动一步，故最多调用(m + n)次就会遇到i = 0或j = 0的情况，此时开始返回。
返回时与递归调用时方向相反，步数相同，故算法时间复杂度为Θ(m + n)。
【优质】背包问题实验报告-范文word版 (13页)
本文部分内容来自网络整理，本司不为其真实性负责，如有异议或侵权请及时联系，本司将立即删除！== 本文为word格式，下载后可方便编辑和修改！ ==背包问题实验报告篇一：背包问题实验报告课程名称：任课教师：班级:201X姓名：实验报告算法设计与分析实验名称：解0-1背包问题王锦彪专业：计算机应用技术学号：11201X 严焱心完成日期： 201X年11月一、实验目的：掌握动态规划、贪心算法、回溯法、分支限界法的原理，并能够按其原理编程实现解决0-1背包问题，以加深对上述方法的理解。
二、实验内容及要求：1．要求分别用动态规划、贪心算法、回溯法和分支限界法求解0-1背包问题；2．要求显示结果。
三、实验环境和工具：操作系统：Windows7 开发工具：Eclipse3.7.1 jdk6 开发语言：Java四、实验问题描述：0/1背包问题:现有n种物品，对1<=i<=n，第i种物品的重量为正整数Wi，价值为正整数Vi，背包能承受的最大载重量为正整数C，现要求找出这n种物品的一个子集，使得子集中物品的总重量不超过C且总价值尽量大。
动态规划算法描述:根据问题描述，可以将其转化为如下的约束条件和目标函数：nmax?vixi?n??wixi?C?i?1?x?{0,1}(1?i?n)?i寻找一个满足约束条件，并使目标函数式达到最大的解向量nX?(x1,x2,x3,......,xn)wixi，使得?i?1?C，而且?vixii?1n达到最大。
0-1背包问题具有最优子结构性质。
假设(x1,x2,x3,......,xn)是所给的问题的一个最优解，则(x2,x3,......,xn)是下面问题的一个最优解：?n??wixi?C?w1x1max?i?2?x?{0,1}(2?i?n)?i如果不是的话，设(y?vixi。
i?2nn2,y3,......,yn)是这个问题的一个最优解，则?viyi??vixi，且w1x1 i?2i?2n??wiyii?2?C。
贪心算法求连续背包问题
实验项目名称：贪心算法求连续背包问题一、实验目的：明确连续背包问题的概念；利用贪心算法解决连连续续背包问题；并通过本例熟悉贪心算法在程序设计中的应用方法。
二、实验原理： 贪心算法原理：在贪婪算法（greedy method ）中采用逐步构造最优解的方法。
在每个阶段，都作出一个看上去最优的决策（在一定的标准下）。
决策一旦作出，就不可再更改。
作出贪婪决策的依据称为贪婪准则（greedy criterion ）。
三、实验内容与步骤：贪心算法求连续背包问题问题描述：已知n 个物体和1个背包，其中物体i 有重量w i 和价值v i ，背包承重量为W 。
求一装载方案，要求在不超过背包负重的前提下，背包中装入的物品价值最大。
很明显，如果1ni i w W =≤∑，则最优解就是装入全部物体，因此下面假设1n i i w W =>∑。
注：连续背包问题中的物体可以任意分割，即部分装入背包。
分析：连续背包问题可形式化为如下模型：{}11max ..[0,1],1,,ni ii ni ii i x v x w W s t x i n ==⎧≤⎪⎨∈∈⎪⎩∑∑对于连续背包问题，可用贪心技术求得最优解。
贪心策略是单位重量价值高者优先。
例如：所给物体的重量和价值如下，则，程序可以得到如下结果：最大价值为163.0；所选各物体的数量为：1.0 1.0 1.0 0.8参考程序段如下//连续背包问题的贪心算法，最大单位重量价值优先//输入：各物体重量w 、价值v 和背包重量W ，已按v/w 降序排列#include<stdio.h>int knapsack(int n1,float w1[],float v1[],float W1){ int i; float weight; float x[10],s=0; for(i=1;i<=n1;i++) x[i]=0; weight=0; i=1;while(weight<W1) {if(weight+w1[i]<W1){x[i]=1;weight=weight+w1[i];}else{x[i]=(W1-weight)/w1[i];weight=W1;}i++;}for(i=1;i<=n1;i++) s=s+x[i]*v1[i];printf("背包所能容纳商品的最大价值为:%f\n",s);printf("所选择的商品的一个序列为：\n");for(i=1;i<=n1;i++)printf("%8.3f",x[i]);}void main(){int n,i,j;float w[10],v[10],W;clrscr();printf("输入商品数量n 和背包容量W:\n");scanf("%d,%f",&n,&W);printf("输入每件商品的重量,价值:\n");for(i=1;i<=n;i++)scanf("%f,%f",&w[i],&v[i]);knapsack(n,w,v,W);printf("\n");system("pause");}。
C++贪心算法实现部分背包问题
C++贪⼼算法实现部分背包问题问题描述：在部分背包问题中，可以不必拿⾛整个⼀件物品，⽽是可以拿⾛该物品的任意部分。
以此求得在限定背包总重量，从给定的物品中进⾏选择的情况下的最佳（总价值最⾼）的选择⽅案。
细节须知：分别输出到同⽂件夹下两个⽂本⽂件中，名称分别是：“backpack-object.txt”和“backpack-weight.txt”。
算法原理：先求出所有物品的单位重量价值并进⾏由⼤到⼩的排序。
其次从排序处于⾸位的物品开始选择直到⽆法完整装⼊背包的物品，将其部分装⼊背包以填满背包的总重量，从⽽求得价值最⾼的选择⽅案。
1 #include <cstdio>2 #include <iostream>3 #include <ctime>4 #include <windows.h>5 #include <algorithm>6 #include <fstream>7using namespace std;8struct object9{10int no;11double weight;12double value;13double average;14};15bool cmp(const object &x, const object &y)16{17return x.average > y.average;//从⼩到⼤排<，若要从⼤到⼩排则>18}19void greedySelector(int m,int W,int solution[],struct object object[]){20int i = 0,V = 0,j = 0;21while(object[i].weight < W)22 {23 solution[i] = 1;24 W = W - object[i].weight;25 V = V + object[i].value;26 i++;27 }28 V = V + (W/object[i].weight)*object[i].value;29 solution[i] = 1;30 cout << "The corresponding value of the optimal option is:" << V << endl;31/*for( i = 0; i < m; i++)32 {33 if(solution[i] == 1)34 {35 cout << object[i].no << endl;36 }37 }*/38}39int main(void)40{41 LARGE_INTEGER nFreq;42 LARGE_INTEGER nBeginTime;43 LARGE_INTEGER nEndTime;44 ofstream fout1;45 ofstream fout2;46 srand((unsigned int)time(NULL));47int m,i,j,t;48double W;49double cost;50 cout << "Please enter the number of times you want to run the program:";51 cin >> t;52 fout1.open("backpack-object.txt",ios::app);53if(!fout1){54 cerr<<"Can not open file 'backpack-object.txt' "<<endl;55return -1;56 }57 fout1.setf(ios_base::fixed,ios_base::floatfield); //防⽌输出的数字使⽤科学计数法58 fout2.open("backpack-weight.txt",ios::app);59if(!fout2){60 cerr<<"Can not open file 'backpack-weight.txt' "<<endl;61return -1;62 }63 fout2.setf(ios_base::fixed,ios_base::floatfield); //防⽌输出的数字使⽤科学计数法64for (j = 0;j < t;j++)65 {66 cout << "——————————————————The "<< j + 1 << "th test —————————————————"<<endl;67 m = 1 + rand()%100000; //物品个数68 W = 10 + rand()%100000; //背包总重量69 fout1 << m << ",";70 fout2 << (int)W << ",";71int solution[m];72object object[m];73for( i = 0;i < m;i++)74 {75object[i].no = i + 1;76object[i].value = 1 + rand()%10000;77object[i].weight = 1 + rand()%10000;78object[i].average = object[i].value/object[i].weight;79 }80 QueryPerformanceFrequency(&nFreq);81 QueryPerformanceCounter(&nBeginTime);82 sort(object,object + m,cmp);83 greedySelector(m,W,solution,object);84 QueryPerformanceCounter(&nEndTime);85 cost=(double)(nEndTime.QuadPart - nBeginTime.QuadPart) / (double)nFreq.QuadPart;86 fout1 << cost << endl;87 fout2 << cost << endl;88 cout << "The running time is:" << cost << " s" << endl;89 }90 fout1.close();91 fout2.close();92 cout << endl;93 cout << "Success!" << endl;94return0;95 }程序设计思路：① 数据结构：结构体中存储物品序号、物品的重量、物品的价值、物品的单位重量价值；② 利⽤C++⾃带的sort函数对结构体按照物品的单位重量价值进⾏降序排列；③ 从排序处于⾸位的物品开始选择直到⽆法完整装⼊背包的物品，将其部分装⼊背包以填满背包的总重量，从⽽求得价值最⾼的选择⽅案。
贪心法解决背包问题
算法分析实验报告贪心法解决背包问题学生姓名：专业：班级：学号:指导教师：2017年6月12日目录一、实验题目 (2)二、实验目的 (2)三、实验要求 (2)四、实现过程 (3)1、实验设计： (3)2、调试分析 (5)3、运行结果： (6)4、实验总结： (6)五、参考文献 (6)一、实验题目贪心法解决背包问题二、实验目的1）以背包问题为例，掌握贪心法的基本设计策略。
2）熟练掌握各种贪心策略情况下的背包问题的算法并实现；其中：量度标准分别取：效益增量v、物品重量w、v/ w比值；3) 分析实验结果来验证理解贪心法中目标函数设计的重要性。
三、实验要求1.[问题描述]：给定n种物品和一个背包。
物品i的重量是Wi，其价值为Vi，背包的容量为C。
应如何选择装入背包的物品，使得装入背包中物品的总价值最大? 与0-1背包问题类似，所不同的是在选择物品i装入背包时，可以选择物品i的一部分，而不一定要全部装入背包，但不可以重复装入。
2.[算法]：贪心法的基本思路：从问题的某一个初始解出发逐步逼近给定的目标，以尽可能快的地求得更好的解。
当达到某算法中的某一步不能再继续前进时，算法停止。
该算法存在问题：1）不能保证求得的最后解是最佳的；2）不能用来求最大或最小解问题；3）只能求满足某些约束条件的可行解的范围。
四、实现过程1、实验设计：1.用贪心法求解背包问题的关键是如何选定贪心策略，使得按照一定的顺序选择每个物品，并尽可能的装入背包，直至背包装满。
至少有三种看似合理的贪心策略：1）按物品价值v降序装包，因为这可以尽可能快的增加背包的总价值。
但是，虽然每一步选择获得了背包价值的极大增长，但背包容量却可能消耗太快，使得装入背包得物品个数减少，从而不能保证目标函数达到最大。
2）按物品重量w升序装包，因为这可以装入尽可能多的物品，从而增加背包总价值。
但是，虽然每一步选择使背包得容量消耗得慢了，但背包价值却没能保证迅速增长，从而不能保证目标函数达到最大。
贪婪法求解背包问题
贪婪法求解背包问题-CAL-FENGHAI.-(YICAI)-Company One1实验二贪婪法一、实验目的1)理解和掌握贪婪算法的基本思想；2)使用贪婪算法求解背包问题以及最小花费生成树问题。
二、方法原理贪心算法就是做出一系列选择，使原问题达到最优解。
在每一个决策点，都是做出当前看来的最优选择。
三、实验设备PC机一台，C语言、PASCAL语言、Matlab任选四、方法原理贪心算法就是做出一系列选择，使原问题达到最优解。
在每一个决策点，都是做出当前看来的最优选择。
五、实验内容1)利用贪婪法求如下背包问题的最优解：n=5,M=100,价值P={20,30,66,40,60 }，重量为w={10,20,30,40,50}。
六、实验要求1)认真分析题目的条件和要求，复习相关的理论知识，选择适当的解决方案和算法；2)编写上机实验程序，作好上机前的准备工作；3)上机调试程序，并试算各种方案，记录计算的结果（包括必要的中间结果）；4)分析和解释计算结果；5)按照要求书写实验报告；源代码：#include<stdio.h>#include<stdlib.h>#include<iostream>using namespace std;#define n 5#define M 100typedef struct {int s;float p;//价值float w;float t;//价值重量比float x;}OBJECT;OBJECT obj[n];void swap(float &x, float &y) {float t;t = x;x = y;y = t;}float divide_and_conquer(OBJECT obj[], int low, int high) { int k, i = low;float z = obj[low].t;for (k = low + 1; k <= high; k++) {if (obj[k].t>z) {i += 1;if (i != k)swap(obj[i], obj[k]);}}swap(obj[low], obj[i]);return i;}void quick_sort(OBJECT obj[], int low, int high) {int k;if (low < high) {k = divide_and_conquer(obj, low, high);quick_sort(obj, low, k - 1);quick_sort(obj, k + 1, high);}}void sort_recover(OBJECT obj[]) {int i, j,temp;for (i = 0; i < n-1; i++) {for (j = 0; j < n - 1 - i; j++) {if (obj[j].s > obj[j + 1].s)swap(obj[j], obj[j + 1]);}}}float knapsack_greedy(OBJECT obj[]) {int i;float m,r=0;for(i=0;i<n;i++){obj[i].t=obj[i].p/obj[i].w;obj[i].x = 0;}quick_sort(obj,0,4);m = M;printf(" 物体价值重量价值重量比结果\n");printf("=========================================\n");for (i = 0; i < n; i++) {if (obj[i].w <= m) {obj[i].x = 1;m -= obj[i].w;r += obj[i].p;}else {obj[i].x = m / obj[i].w;r += obj[i].x * obj[i].p;break;}}return r;}void main() {int i;float r;//float x[] = { 0 };float s[] = { 1,2,3,4,5 };float p[]={ 20,30,66,40,60 };float w[]={ 10,20,30,40,50 };for (i = 0; i < n; i++) {obj[i].s = s[i];obj[i].p = p[i];obj[i].w = w[i];}r = knapsack_greedy(obj);sort_recover(obj);for (i = 0; i < n; i++) {printf(" %d %2.0f %2.0f %2.1f %1.1f\n", obj[i].s, obj[i].p, obj[i].w, obj[i].t, obj[i].x);}printf("\n最大价值为：%f\n",r );printf("背包问题的解向量：X={");for (i = 0; i < n; i++) {printf("%1.1f",obj[i].x);if(i<4)printf(",");}printf("}");system("pause");}结果：。
matlab中贪婪算法求解背包问题的研究与应用
matlab中贪婪算法求解背包问题的研究与应用背包问题是一种特殊的最优化问题，常见于组合优化中。
在一般情况下，它要求从多种物品中挑选出某种数量的物品，并在总体质量限制下，达到总价值最优化。
背包问题最早由著名的十字军和维特根斯坦于末世纪四十年代被首先提出，他们认为它可以用来解决在野外战斗期间士兵装备配置问题。
在现代，当我们一定时间限制和资源限制的情况下做出最佳选择时，背包问题都会被广泛应用。
同时，它也被用来解决货币准备、电子商务中的物品搭配和货箱装箱等问题。
二、婪算法求解背包问题贪婪算法是一种能够有效解决搜索问题的算法，它总是在当前可行解中选择最优解。
这种算法的贪婪特性会让它比较容易实现，同时它也可以改善大多数最优时间复杂度和空间复杂度。
贪婪算法可以用来解决背包问题。
通过贪婪的决策选择，使得背包中的物品价值最大化。
贪婪算法的计算步骤如下：（1）根据背包容量，按比例选择价值较大且重量较轻的物品；（2）依次将价值最大的物品加入背包，直至规定重量到达为止；（3）检查最终获得的所有物品，保证它们尽可能满足重量限制。
三、lab中贪婪算法求解背包问题对于资源约束来说，lab中贪婪算法可以用来解决最优解问题。
lab中的贪婪算法可以用来求解背包问题，可以提高效率，提高求解的背包问题的精确度。
首先，可以将背包问题转化成一个更容易理解的数学模型：约束条件：质量：W=∑wi价值：V=∑xi其中，W为背包的总质量，V为背包的总价值，wi为第i个物品的质量，xi为第i个物品的价值。
设计算法：（1）根据约束条件取出有效物品，并且计算出每个物品的价值和质量比值；（2）按从大到小的价值比值顺序选择有效物品，并继续计算总的质量和价值；（3）当背包质量达到预定的容量时，停止选择，输出最终获得的最佳物品组合。
四、贪婪算法求解背包问题的实际应用贪婪算法求解背包问题在资源优化中有着很大的应用前景。
它可以用于供应链管理、资本规划、生产计划等领域，提高企业绩效，降低企业花销，从而改善企业生产力。
使用JAVA实现算法——贪心算法解决背包问题
使⽤JAVA实现算法——贪⼼算法解决背包问题解释等全部在代码中，⾃⼰跑了下，是没问题的package BasePart;import java.io.BufferedReader;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStreamReader;/*** 使⽤贪⼼算法解决背包问题* 背包问题：* 旅⾏者有背包容量m公⽄* 现在有重量W1,W2,W3,W4....Wn* 对应的价值V1,V2,V3,V4....Vn* 运⾏重复携带，欲求得最⼤价值* 贪⼼算法：求得最好的选择，但是贪⼼算法不是对于所有的问题都得到整体最优解* 贪⼼算法基本思路：* 1.建⽴数学模型来描述问题* 2.把求解问题分成若⼲个⼦问题* 3.对于每⼀个⾃问题求得局部最优解* 4.把⼦问题的解局部最优解合成原来解问题的⼀个解* 贪⼼算法的实现过程：* 从⼀个初始解出发* while-do朝总⽬标前进* 求出可⾏解的⼀个解元素* 由所有解元素组成合成问题的⼀个可⾏解*/public class Greedy {/*解决背包问题*需要背包容量*背包价值*背包剩余容量*解向量集合*/private double total_weight;private double total_value;private double rest_weight;//储存排序数组private Good[] arrayValue;private Good[] arrayWeight;private Good[] arrayC_P;private int goodsNum;private Good[] goods;private double real_weight;public Greedy() {}public Greedy(int goodsNum,double total_weight) {this.goodsNum=goodsNum;this.total_weight=total_weight;}public void init(String filename) throws IOException {/** 1.初始化程序* 2.从TXT⽂件中得到商品重量和其价值数组* 3.初始化序列数组arrayValue/Weight/C_P*/goods=new Good[goodsNum];BufferedReader data=new BufferedReader(new InputStreamReader(new FileInputStream(filename)));String buff;String[] strs;//循环赋值for(int i=0;i<4;i++){buff=data.readLine();strs=buff.split(" ");//根据位次goods[i]=new Good();//对象数组不仅仅需要初始化数组，对于数组内的每⼀个对象也需要初始化goods[i].setName(strs[0]);goods[i].setValue(Double.parseDouble(strs[1]));goods[i].setWeight(Double.parseDouble(strs[2]));goods[i].figureC_P();}//关闭输⼊流//成员变量初始化arrayValue=new Good[goodsNum];arrayWeight=new Good[goodsNum];arrayC_P=new Good[goodsNum];//初始化数组/** 价值由⼤到⼩数组*/arrayValue=arrayCopy(goods, arrayValue);//按照价值对arrayValue数组进⾏重新排列，使⽤冒泡排序法for(int i=0;i<goodsNum-1;i++){//从⼤到⼩排列for(int j=i+1;j<goodsNum;j++){if(arrayValue[i].getValue()<arrayValue[j].getValue()){Good temp=arrayValue[i];arrayValue[i]=arrayValue[j];arrayValue[j]=temp;}}}/**质量由⼩到⼤数组*/arrayWeight=arrayCopy(goods, arrayWeight);//按照价值对arrayWeight数组进⾏重新排列，使⽤冒泡排序法for(int i=0;i<goodsNum-1;i++){//从⼩到⼤排列for(int j=i+1;j<goodsNum;j++){if(arrayWeight[i].getWeight()>arrayWeight[j].getWeight()){Good temp=arrayWeight[i];arrayWeight[i]=arrayWeight[j];arrayWeight[j]=temp;}}}/** 性价⽐由⼤到⼩排列*/arrayC_P=arrayCopy(goods, arrayC_P);//按照价值对arrayC_P数组进⾏重新排列，使⽤冒泡排序法for(int i=0;i<goodsNum-1;i++){//从⼤到⼩排列for(int j=i+1;j<goodsNum;j++){if(arrayC_P[i].getC_P()<arrayC_P[j].getC_P()){Good temp=arrayC_P[i];arrayC_P[i]=arrayC_P[j];arrayC_P[j]=temp;}}}}//⽤于数组拷贝public Good[] arrayCopy(Good[] goods,Good[] arr2){arr2=goods.clone();return arr2;}private void show(Good[] goodsarr) {for(Good good:goodsarr){System.out.println(good.getName()+"\t"+good.getValue()+"\t"+good.getWeight()+"\t"+good.getC_P()+"\t"+good.getNum()); }}/*三种策略：度量准则* 依次选取价值最⼤填充* 依次选取重量最轻填充* 依次选取⽐价最⼤填充** ⽅法设计：* 按照度量准则* 传递⼀个按照选择优先级排列的对象数组* 迭代计算剩余容量* 返回设计⽅案*/public void strategy(Good[] goodsArray){rest_weight=total_weight;for(Good good:goodsArray){int selectNum=(int)Math.floor(rest_weight/good.getWeight());rest_weight=rest_weight-selectNum*good.getWeight();good.setNum(selectNum);if(rest_weight<arrayWeight[0].getWeight()){continue;}}}public void calculate(Good[] goodsArray,String target){total_value=0;real_weight=0;//处理结果System.out.println("在以"+target+"为准则的情况下");for(Good good:goodsArray){System.out.println(good.getName()+"\t\t数量："+good.getNum());total_value+=good.getValue()*good.getNum();real_weight+=good.getWeight()*good.getNum();}System.out.println("总价值是:\t"+total_value+"\t总重量是:\t"+real_weight); }public void solve() {/** 业务逻辑* 将优先级数组*/strategy(arrayValue);calculate(arrayValue,"价值");strategy(arrayWeight);calculate(arrayWeight,"重量");strategy(arrayC_P);calculate(arrayC_P,"⽐值");}public static void main(String[] args) throws IOException {Greedy greedy=new Greedy(4,50);greedy.init("goods.txt");greedy.solve();}}Txt⽂本为：ad钙奶 12 5ab胶带 6 1电脑 4000 30⾳响 500 15说明：第⼀列：名称第⼆列：价格第三列：重量程序运⾏结果为：待改善。
背包问题的贪心算法
Wi Xi
16.5 20 20 20
Vi X i
24.25 28.2 31 31.5
先检验这四个为可行解*,即满足约束条件(4.2.2),(4.2.3).再比 较目标函数值,∑vixi .知④组解效益值最大.该组解是背包问题的最 优解。(见定理4.2）
6
例4.4 n＝3,c＝20, (V1,V2,V3) (25, 24,15) (W1,W2,W3) (18,15,10)
7
，且物品2的24/15 = v2/w2 较物品3的15/10＝ v3/w3效益值高。按 此选择策略,得②即(1, 2/15, 0),∑vixi=28.2 .此解是一个次优解。 显然，按物品效益值的非增次序装包不能得最优解。
原因：背包可用容量消耗过快。
（2）以容量作为量度。即按物品重量的非降次序将物
—选取最优的量度标准实为用贪心方法求解问题的核心.
16
4.3 贪心算法的基本要素
1.贪心选择性质
所谓贪心选择性质是指所求问题的整体最优解可以 通过一系列局部最优的选择，即贪心选择来达到。这 是贪心算法可行的第一个基本要素，也是贪心算法与 动态规划算法的主要区别。
动态规划算法通常以自底向上的方式解各子问 题，而贪心算法则通常以自顶向下的方式进行，以迭 代的方式作出相继的贪心选择，每作一次贪心选择就 将所求问题简化为规模更小的子问题。
品装包。如例4.4中的解③（让背包尽可能慢被消耗）
排序 : (w3,w2,w1)= (10,15,18)
(V3,V2,V1) (15, 24, 25)
V3=15,x3=1,w3=10,背包剩余C－10＝10;物品2有次大重量(w2＝15), 但包装不下。使用x2＝2/3，刚好装满背包且物品2装入2/3与物品1 装入5/9的容量均为10个单位。但前者的效益值24×2/3=16 >后者
算法设计和分析实验四：贪心算法求解背包问题
实验五：贪心算法求解背包问题实验内容应用贪心算法求解离散背包问题，分析时间复杂度。
有一个承重为W的背包和n个物品，它们各自的重量和价值分别是wi和vi （1<=i<=n），设求这些物品中最有价值的一个子集。
如果每次选择某一个物品的时候，只能全部拿走，则这一问题称为离散（0-1）背包问题；如果每次可以拿走某一物品的任意一部分，则这一问题称为连续背包问题。
算法思想•动态规划的思想：–对较小的子问题进行一次求解，并把结果记录下来，然后利用较小问题的解，求解出较大问题的解，直到求解出最大问题的解。
–引进一个二维数组ch[MAX][MAX]，用ch[i][j]记录CH1与CH2的LCS的长度，b[i][j]记录ch[i][j]是通过哪一个子问题的值求得的，以决定搜索的方向。
我们是自底向上进行递推计算，那么在计算ch[i,j]之前，ch[i-1][j-1]，ch[i-1][j]与ch[i][j-1]均已计算出来。
此时我们根据CH1 [i] = CH2[j]还是CH1[i] !=CH2[j]，就可以计算出ch[i][j]。
算法length(string CH1,string CH2,int b[MAX][MAX])//用于构建动态数组//输入：两字符窜//输出：最长公共子序列for(i=1;i<=ch1Len;i++)//二重循环求解for(int j=1;j<=ch2Len;j++){if(CH1[i-1]==CH2[j-1])//相等字符{ch[i][j]=ch[i-1][j-1]+1;b[i][j]=0;}else if(ch[i-1][j]>=ch[i][j-1])//上比较大{ch[i][j]=ch[i-1][j];b[i][j]=1;}else//左比较大{ch[i][j]=ch[i][j-1];b[i][j]=-1;}}printCS(int b[MAX][MAX],string x,int i,int j) //回溯求出最长子序列输出//输入：标记数组//输出：最长子序列if(i == 0 || j == 0)//边界，返回return;if(b[i][j] == 0){printCS(b, x, i-1, j-1);//左上cout<<x[i-1]<<" ";}else if(b[i][j] == 1)printCS(b, x, i-1, j);//上elseprintCS(b, x, i, j-1);//左源程序//应用贪心算法求解离散背包问题#include<iostream>using namespace std;#define MAX 100//结构体struct Elem{double W;double V;double P;int number;};//顺序表struct SqList{Elem *elem;int length;int listsize;};//构造一个空的线性顺序表void InitList_Sq(SqList &L){L.elem=(Elem *)malloc(100*sizeof(Elem)); L.length=0;L.listsize=100;}//******************************** //构造背包,顺序表//******************************void input(SqList &L){cout<<"请输入物品的个数：";cin>>L.length;for(int i=0;i<L.length;i++){cout<<"请输入第"<<i+1<<"个物品的重量和价值：";cin>>L.elem[i].W>>L.elem[i].V;L.elem[i].P=L.elem[i].V/L.elem[i].W;cout<<"价值比为："<<L.elem[i].P<<endl;L.elem[i].number=i+1;}}//*********************************//插入排序由大到小//*******************************void inser(SqList &L){Elem inserter;int index;//inserter待插入合适位置的元素,index指示插入位置for(int pass=1;pass<L.length;pass++){//共比较size-1轮inserter=L.elem[pass];//第pass轮时,待插入的对象是a[pass] index=pass-1;while(index>=0&&inserter.P>L.elem[index].P){ //寻找插入位置L.elem[index+1]=L.elem[index];index--;//指针前移，再比较}L.elem[index+1]=inserter;//跳出while时，找到插入位置}//end of forcout<<"按照价值比由大到小排列的顺序为：";for(pass=0;pass<L.length;pass++)cout<<L.elem[pass].number<<" ";cout<<endl;}//*************************************************8 //背包程序//采用贪心算法//根据价值和重量的比来实现贪心算法//************************************************ void bag(SqList L){double w,sumV=0,sumW=0;int list[MAX],a=0;cout<<"请输入背包承重量W:";cin>>w;inser(L);for(int i=0;i<L.length;i++){while(sumW+L.elem[i].W<=w){sumW=sumW+L.elem[i].W;sumV=sumV+L.elem[i].V;list[a++]=L.elem[i].number;}}cout<<"最后包里的总重量为："<<sumW<<endl; cout<<"最后包里的总价值为："<<sumV<<endl; cout<<"放到背包中的物品的序号列表为："; for(i=0;i<a;i++){cout<<list[i]<<" ";}}int main(){cout<<"贪心算法求解背包问题"<<endl;SqList L;InitList_Sq(L);input(L);bag(L);return 0;}实验结论1、运行截图查找最长公共子序列长度时的动态规划两个for循环，时间复杂度为Ｏ（ｎ＊ｎ）。
贪心算法背包问题
《算法设计与分析》实验报告2015-2016年第2学期实验班级：学生姓名：学号：指导老师：信息工程学院实验项目名称：贪心算法背包问题实验日期：2016年4月12日一、实验类型：□√验证性□设计性二、实验目的1、掌握背包问题的算法2、初步掌握贪心算法三、实验内容及要求问题描述：与0-1背包问题相似，给定n种物品和一个背包。
物品i的重量是wi，其价值为vi，背包的容量为c。
与0-1背包问题不同的是，在选择物品i装入背包时，背包问题的解决可以选择物品i的一部分，而不一定要全部装入背包，1< i < n。
四、实验步骤#include "iostream.h"#include "stdio.h"#include <cstdlib>struct stone{ int name;int weight;//物品的剩余重量int weight_t;//物品的重量float benefit;//物品的价值//float b;};void sort(stone *data,int num){if(num<1)return;int low=0,high=num;stone key_s=data[low];float key=(float)key_s.benefit/key_s.weight;int empty=low;while(low<high){ if(low==empty){ while((data[high].benefit/data[high].weight<key) &&(high>low)){ high--;}if(data[high].benefit/data[high].weight>=key){ data[low]=data[high];empty=high;}}else if(high==empty) {while((data[low].benefit/data[low].weight>=key)&&(low<h igh)){ low++; }if(data[low].benefit/data[low].weight<key){ data[high]=data[low];empty=low; }}}data[empty]=key_s;if(empty>1)sort(data,empty-1);if(num-empty-1>0)sort(data+empty+1,num-empty-1);}void inputstone(stone *bag,int num){ for(int i=0;i<num;i++){ bag[i].name=i+1;printf("请输入第%d号物品的重量:",i+1); scanf("%d",&bag[i].weight);if (bag[i].weight<=0){printf("物品的重量必须大于0!\n");} printf("请输入第%d号物品的价值:",i+1); scanf("%f",&bag[i].benefit);if (bag[i].benefit<=0){printf("物品的价值必须大于0!\n");}bag[i].weight_t=bag[i].weight;}}int main(int argc, char* argv[]){ int i;int num=0;int weight=0;float benefit=0;stone *bag;do{ printf("请输入背包可容纳的重量:"); scanf("%d",&weight);if (weight<=0)printf("背包可容纳的重量必须大于0!\n"); }while(weight<=0);do{ printf("请输入物品的数量:");scanf("%d",&num);if (num<=0)printf("物品数量必须大于0!\n");}while(num<=0);bag=new stone[num];inputstone(bag,num);sort(bag,num-1);for(i=0;i<num&&weight>0;i++){ stone *temp=bag+i;if(weight>=temp->weight){ weight-=temp->weight;temp->weight=0;benefit+=temp->benefit;continue;}else{ temp->weight-=weight;weight=0;benefit+=(temp->benefit*(1-(float)temp->weight/temp->we ight_t));break;} }printf("物品种类放入的比例每单位效益\n");for(i=0;i<num;i++){ stone *temp=bag+i;printf("%d类物品",temp->name);printf("\t\t%.2f\t\t",(temp->weight_t-temp->weight)/(fl oat)temp->weight_t);printf(" %.4f\n",temp->benefit/(float)temp->weight_t) ;}printf("总效益:%.2f",benefit);delete bag;getchar();system("PAUSE");return EXIT_SUCCESS;return 0;}五、实验结果1、实验图形2、结果分析如上面第一个图所示当输入背包可容纳的重要为21，输入物品的数量为3，输入第1号物品的重量为8，输入第1号物品的价值为12，输入第2号物品的重量为9，输入第2号物品的价值为16，输入第3号物品的重量为4，输入第3号物品的价值为15，则可以得出总效益为43.00。