第4章 贪心算法实验指导
贪心算法实验报告算法实验贪心法实验报告
贪心算法实验报告算法实验贪心法实验报告西安邮电大学（计算机学院）课内实验报告实验名称：贪心算法专业名称：班级：学生姓名：学号（8指导教师：实验日期：一. 实验目的及实验环境1.练习掌握最有分解问题的规划设计与实现；2.熟练掌握递归算法的设计及应用，怎样才能使算法的空间复杂度和时间复杂度最低；基于Linux系统下的ubuntu或其他的编辑器二. 实验内容1. 设n是一个正整数，现在要求将n分解为若干互不相同的自然数的和，且使这些自然数的乘积最大三．方案设计1.先将这个数分解成以2开始的连续的若干因子，它们的和加起来是n，将此数在后项优先的方式下均匀地分给前面各项。
保证正整数所分解出的因子之差的绝对值最小，即| a – b |最小，可以保证分解乘积越大。
四．测试数据及运行结果1．正常测试数据（3组）及运行结果；A.2.非正常测试数据（2组）及运行结果A.B.五．总结1．实验过程中遇到的问题及解决办法；在实验过程中错误不断地出现，我认真地查阅书籍，研究课本上例题，并且在同学的帮助下纠正了自己的错误，得出了正确的结果。
2．对设计及调试过程的心得体会。
在程序的运行与调试过程中出现了很多错误，但是通过自己复习课本知识、查询资料等，修改后得出了正确的结果。
而且我觉得自己一定要敢于尝试，即使没有结果但是勇于实践就会有意想不到的收获。
所以在以后的学习中我觉得我们一定要集中精力、端正自己态度，提高自己的成绩。
当然我也认识到了自己的薄弱之处，因此我一定争取做的能让自己满意，做的更好。
六．附录：源代码（电子版）#include#includevoid open_file(int n){FILE *fp;if((fp=fopen(“input.txt”,”wt”))==NULL) {printf(“the file write failed.\n”);exit(1);}fprintf(fp,”%2d\n”,n);fclose(fp);}void save_file(int sum){FILE *fp;if((f p=fopen(“output.txt”,”wt”))==NULL) {printf(“ the file save failed!.\n”);exit(1);}fprintf(fp,”%2d\n”,sum);fclose(fp);if((fp=fopen(“output.txt”,”r”))==NULL) {printf(“save file failed!\n”);exit(1);}fscanf(fp,”%2d”,&sum);printf(“\n鏈€澶х?d\n”,sum);fclose(fp);}int MAX(int n){int i=2,j=0,data[n],sum=0,max=1; int lenth; while(sum+i{sum+=i;data[j]=i;i++;j++;}lenth=j;i=n-sum;while(i>0){if(j{data[j+i]+=1;i--;j--;}else{data[j-1]+=1;i--;j--;}}for(i=0;imax*=data[i];return max;}int main(){int n,max;srand((unsigned)time(NULL)); n=rand()%100; open_file(n);printf(“ 杩欎釜鏁版槸%d:\n”,n); max=MAX(n); save_file(max);return 0; }百度搜索“就爱阅读”,专业资料,生活学习,尽在就爱阅读网,您的在线图书馆。
贪心算法实验(求解背包问题)
算法分析与设计实验报告第四次实验
}
}
输入较小的结果：
测试结
果
输入较大的结果：
附录：
完整代码（贪心法）
;
cout<<endl;
cout<<"待装物品的价值为："<<endl;
for (i=0;i<n;i++)
cin>>item[i].v;
cout<<endl;
erval=item[i].v/item[i].w;
clock_t start,end,over; ;
实验心
得
首先这个实验，需要注意的点是背包问题与0-1背包不同，物品可以部分的放入背包中，所以思路也不一样，首先就是将物品按照单位质量价值排序，只这一点就有一点难度。
难度在于要是排序后物品的编号就会发生改变，输出的就不是之前的编号的物品，导致错误，后来发现如果为每一个物品保存一个副本，然后将它们的编号进行对比，就可以进行正确的输出了。
其中这个实验
让我学到了两点：一是结构体的使用，之前一直没有怎么用过，现在才发现自己其实不会用；二十对于库函数sort 函数的使用。
感觉每一次实验都有学到东西，很开心。
实验得
分 助教签名
sort(item,item+n,comparison); >c)
break;
tem[i]=1;
c-=item[i].w;
}
if(i<n) ;
for(i=0;i<n;i++) ==tmp[j])
x[j]=tem[i];
}
}
}。
贪心算法 实验报告
贪心算法实验报告贪心算法实验报告引言：贪心算法是一种常用的算法设计策略，它通常用于求解最优化问题。
贪心算法的核心思想是在每一步选择中都选择当前最优的解，从而希望最终能够得到全局最优解。
本实验旨在通过实际案例的研究，探索贪心算法的应用和效果。
一、贪心算法的基本原理贪心算法的基本原理是每一步都选择当前最优解，而不考虑整体的最优解。
这种贪婪的选择策略通常是基于局部最优性的假设，即当前的选择对于后续步骤的选择没有影响。
贪心算法的优点是简单高效，但也存在一定的局限性。
二、实验案例：零钱兑换问题在本实验中，我们以零钱兑换问题为例，来说明贪心算法的应用。
问题描述：假设有不同面值的硬币，如1元、5元、10元、50元和100元，现在需要支付给客户x元，如何用最少的硬币数完成支付？解决思路：贪心算法可以通过每次选择当前面值最大的硬币来求解。
具体步骤如下：1. 初始化一个空的硬币集合，用于存放选出的硬币。
2. 从面值最大的硬币开始，如果当前硬币的面值小于等于待支付金额，则将该硬币放入集合中，并将待支付金额减去该硬币的面值。
3. 重复步骤2，直到待支付金额为0。
实验过程：以支付金额为36元为例，我们可以通过贪心算法求解最少硬币数。
首先，面值最大的硬币为100元，但36元不足以支付100元硬币，因此我们选择50元硬币。
此时，剩余待支付金额为36-50=-14元。
接下来，面值最大的硬币为50元，但待支付金额为负数，因此我们选择下一个面值最大的硬币，即10元硬币。
此时，剩余待支付金额为-14-10=-24元。
继续选择10元硬币，剩余待支付金额为-24-10=-34元。
再次选择10元硬币，剩余待支付金额为-34-10=-44元。
最后，选择5元硬币，剩余待支付金额为-44-5=-49元。
由于待支付金额已经为负数，我们无法继续选择硬币。
此时，集合中的硬币数为1个50元和3个10元，总共4个硬币。
实验结果：通过贪心算法，我们得到了36元支付所需的最少硬币数为4个。
算法设计与分析：第4章 贪心法
& 7
i 1 2 3 4 5 6 7 8 9 10 11 si 1 3 0 5 3 5 6 8 8 2 12 fi 4 5 6 7 8 9 10 11 12 13 14
3 1 0 1 Pa2ge 263 4
4 4
7 6
• +HJ-solution
– D5+>&S?F#6+
• '9J-select
– G CAKG !E – 30':4$F#+ – ")28J-
• +HJ-feasible
– D5+>& ':? K,+>& I;?.7=@%
贪心法的一般过程
7 (*)906 42:
– 6 "#3 – -,!*);&'4"# – !. ;&6 +/ ( –
/ (#
8 "# ( 5%( ()
– (#$1 (#
4.1.4 贪心法的求解过程
三个步骤
3
•
建立模型（问题抽象化）
ō 冇㩀㩂⇗
%
! &"'" = )
(1. 3)
"#$
0 ≤ '" ≤ 1, 1 ≤ . ≤ /
ō 䧏㫨ⓞ㡑
%
max ! 8"'"
(1. 9)
"#$
ō 厭◦棏歹㈳冴ℛ⻜㕟⃡ℋ䇂悔冇㩀㩂⇗ㇰ猾ㅗ≠䧏㫨ⓞ
㡑ㇰ抟┑㧡Ⰸ䥥峄⛲撰 : = ('1, '2, … , '/)
QPNX:E
算法实验报告贪心
一、实验背景贪心算法是一种在每一步选择中都采取当前状态下最好或最优的选择，从而希望导致结果是全局最好或最优的算法策略。
贪心算法并不保证能获得最优解，但往往能获得较好的近似解。
在许多实际应用中，贪心算法因其简单、高效的特点而被广泛应用。
本实验旨在通过编写贪心算法程序，解决经典的最小生成树问题，并分析贪心算法的优缺点。
二、实验目的1. 理解贪心算法的基本原理和应用场景；2. 掌握贪心算法的编程实现方法；3. 分析贪心算法的优缺点，并尝试改进；4. 比较贪心算法与其他算法在解决最小生成树问题上的性能。
三、实验内容1. 最小生成树问题最小生成树问题是指：给定一个加权无向图，找到一棵树，使得这棵树包含所有顶点，且树的总权值最小。
2. 贪心算法求解最小生成树贪心算法求解最小生成树的方法是：从任意一个顶点开始，每次选择与当前已选顶点距离最近的顶点，将其加入生成树中，直到所有顶点都被包含在生成树中。
3. 算法实现（1）数据结构- 图的表示：邻接矩阵- 顶点集合：V- 边集合：E- 已选顶点集合：selected- 最小生成树集合：mst（2）贪心算法实现```def greedy_mst(graph):V = set(graph.keys()) # 顶点集合selected = set() # 已选顶点集合mst = set() # 最小生成树集合for i in V:selected.add(i)mst.add((i, graph[i]))while len(selected) < len(V):min_edge = Nonefor edge in mst:u, v = edgeif v not in selected and (min_edge is None or graph[u][v] < graph[min_edge[0]][min_edge[1]]):min_edge = edgeselected.add(min_edge[1])mst.add(min_edge)return mst```4. 性能分析为了比较贪心算法与其他算法在解决最小生成树问题上的性能，我们可以采用以下两种算法：（1）Prim算法：从任意一个顶点开始，逐步添加边，直到所有顶点都被包含在生成树中。
贪心算法
贪心算法实验报告一．实验目的：1.加深对贪心算法思想的理解，实现背包问题、活动安排问题的求解算法；2.通过本次实验掌握将算法转换为上机操作；3.加深对动态规划思想的理解，并利用其解决生活中的问题。
二．实验内容：1.编写算法：实现背包问题、活动安排问题的求解；2.将输出数据保存到文件之中，包括运行时间和运行结果；3.对实验结果进行分析。
三．实验操作：1.背包问题：给定一个容器，即背包，有若干的物品，有重量和价值两个属性，要将背包填满并且价值最大。
共有三种方式，以重量优先、价值优先和单位价值优先对背包进行填充，对三种结果进行比较分析，得到最优解。
代码实现：class knapsack{//背包属性public:float weight,value,unitValue;knapsack();void QsortWeight(knapsack bag[],int low,int high);void QsortValue(knapsack bag[],int low,int high);void QsortUnitValue(knapsack bag[],int low,int high); void GreedyKnapsack(knapsack bag[],float volume,int amount);};void knapsack::GreedyKnapsack(knapsack bag[],floatvolume,int amount){//贪心解决背包问题float surplusCapacity=volume,totalValue=0;int j=0;float* select=new float[amount];for(int i=0;i<amount;i++) select[i]=0;for(j=0;j<amount;j++){if(bag[j].weight>surplusCapacity) break;select[j]=1.0;surplusCapacity-=bag[j].weight;totalValue+=bag[j].value;cout<<bag[j].weight<<" "<<bag[j].value<<""<<bag[j].unitValue<<endl;outFile<<bag[j].weight<<" "<<bag[j].value<<""<<bag[j].unitValue<<"\n";}if(j<amount) select[j]=surplusCapacity/bag[j].weight;totalValue+=bag[j].value*select[j];outFile<<bag[j].weight<<" "<<bag[j].value<<""<<bag[j].unitValue<<"\n"<<"总价值为："<<totalValue<<"\n";cout<<bag[j].weight<<" "<<bag[j].value<<""<<bag[j].unitValue<<endl;cout<<"总价值为："<<totalValue<<endl;}2.活动安排：在一天之中最大限度得安排活动，给定一系列活动的开始时间和结束时间，对结束时间按照非递减顺序排列，判断当前活动的开始时最后时间与上个活动的结束时间是否有冲突，如果没有，将当前活动放入活动安排表中，直到判断到最后一个活动或者结束时间到头为止。
贪心算法_实验报告
贪心算法_实验报告一、设计分析●问题描述：键盘输入一个高精度的正整数N（N不超过240位），去掉其中任意S个数字后剩下的数字按原左右次序将组成一个新的正整数。
编程对给定的N和S，寻找一种方案使得剩下的数字组成的新数最小。
●设计思路：在位数固定的前提下，让高位的数字尽量小其值就较小，依据此贪心策略解决此问题。
删除高位较大的数字。
具体：相邻两位比较若高位比低位大则删除高位。
删除字符的方法：1）物理删除，用后面的字符覆盖已删除的字符。
有比较多字符移动操作，算法效率不高。
2）用数组记录字符的状态，“1”表示对应数字存在，“0”表示对应数字已删除。
3）利用数组，记录未删除字符的下标：n=“1 2 4 3 5 8 3 3”0 0 0 0 0 04比3大删除“1 2 3 5 8 3 3” 1 2 4 5 0 08比3大删除“1 2 3 5 3 3” 1 2 4 5 05比3大删除“1 2 3 3 3” 1 2 4 7 8二、程序代码c语言实现#include<stdio.h>#include<string.h>#define N 10000int main(void){char a[N];int i,j,k,n;printf("输入要处理的数据：\n");gets(a);printf("输入要删除的数字个数：\n");scanf("%d",&n);三、测试用例四、实验总结加深了对贪心算法的理解与运用。
所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。
这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。
动态规划算法通常以自底向上的方式解各子问题，而贪心算法则通常以自顶向下的方式进行，以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为规模更小的子问题。
实验四 贪心算法
实验四贪心算法一、实验目的进一步理解贪心算法的基本思想，学会根据具体问题设计贪心选择策略，会使用贪心算法解决一些实际问题。
二、实验要求1、上机前的准备工作根据实验内容中所给题目，利用所学贪心算法的基本设计思想设计算法并编写好上机程序，以提高上机效率；2、独立上机，输入、调试所编程序；3、上机结束后，写出实验报告。
4、上机时间：2学时三、实验内容1、4-1 会场安排问题#include<iostream>using namespace std;const int MAX=100;struct sport{int start;//开始时间int end;//结束时间};int m[MAX];void sort(struct sport t[],int n)// 由小到大排序{int i,j;for(i=1;i<n;i++)for(j=1;j<n-i+1;j++)if(t[j].start>t[j+1].start){struct sport temp;temp=t[j];t[j]=t[j+1];t[j+1]=temp;}}void main(){int max=1,count=1,n;cout<<"请输入活动的个数：";cin>>n;sport t[MAX];for(int k=1;k<=n;k++){cout<<"请输入第"<<k<<"个活动的开始时间和结束时间：";cin>>t[k].start;cin>>t[k].end;}m[0]=t[1].end;sort(t,n);for(int i=2;i<=n;i++){int j=0;while(j<max&&t[i].start<m[j]){j++;}m[j]=t[i].end;count=j+1;if(count>max)max=count;}cout<<"活动场所共需个数："<<max<<endl;}运行结果：2、4-2 最优合并问题#include <iostream>using namespace std;const int MAX=100;void sort(int r[],int n){int j;for(int i=2;i<=n;i++){r[0]=r[i];j=i-1;while(r[0]<r[j]){r[j+1]=r[j];j=j-1;}r[j+1]=r[0];}}int max(int r[],int n){int sum=0;for(int i=n;i>1;i--){sum+=r[i]+r[i-1]-1;r[i-1]=r[i]+r[i-1];}return sum;}int min(int r[],int n){int sum=0;for(int i=1;i<n;i++){sum+=r[i]+r[i+1]-1;r[i+1]=r[i]+r[i+1];}return sum;}void main(){int n,a[MAX],b[MAX];cout<<"请输入序列的个数:";cin>>n;cout<<"请输入各个序列的长度："<<endl;for(int i=1;i<=n;i++)cin>>a[i];sort(a,n);for(int j=1;j<=n;j++)b[j]=a[j];cout<<"最多比较次数："<<max(a,n)<<endl;cout<<"最少比较次数："<<min(b,n)<<endl; }运行结果：3、数列极差问题在黑板上写了N个正整数组成的一个数列，进行如下操作：每一次擦去其中的两个数a和b，然后在数列中加入一个数a×b+3，如此下去直至黑板上剩下一个数，在所有按这种操作方式最后得到的数中，最大的记作max，最小的记作min，则该数列的极差定义为M=max-min。
第4章 贪心算法实验指导
第4章贪心算法实验4.1 贪心算法的实现与时间复杂度测试1. 实验目的编程实现经典的贪心算法，理解贪心算法设计的基本思想、程序实现的相关技巧，加深对贪心算法设计与分析思想的理解。
通过程序的执行时间测试结果，与理论上的时间复杂度结论进行对比、分析和验证。
2. 原理解析贪心算法的基本思想贪心算法求解优化问题的基本思想是：采用逐步构造最优解的方法。
在每个阶段，都做出一个当前最优的决策（在一定的标准下）。
决策一旦做出，就不可再更改（做出贪心决策的依据称为贪心准则）。
贪心算法的一般步骤如下：(1) 根据拟解决问题选取一种贪心准则；(2) 按贪心准则标准对n个候选输入排序（以这一方法为代表，仍可基于堆来存储候选）；(3) 依次选择输入量加入部分解中：如果当前这个输入量的加入，不满足约束条件，则不把此输入加到这部分解中。
贪心算法的基本设计范式如下：Greedy(A,n)A: include n inputsSolution=Фfor i=1 to n dox=Select(A)if Feasible(solution,x) thensolution=Union(solution,x)end ifend forreturn solution测试算法背包问题是使用贪心算法求解的代表问题，算法如下：KnapsackGreedy(p，w，m，x，n)//v[1..n]和w[1..n]分别含有按vi/wi v(i+1)/v(i+1)排序的n 件物品的价值和重量。
M是背包的容量大小，而x[1..n]是解向量// for i=1 to n doxi=0 //将解向量初始化为零//end forcu=m //cu是背包剩余容量//for i=1 to n doif wi>cu thenexitend ifxi=1cu=cu-wirepeatif i≤n thenxi=cu/wiend if算法的时间复杂度取决于对v i/w i排序的时间复杂度，例如，若选择MergeSort 排序算法，则以上算法的时间复杂度为O(n log n)。
贪心算法实验报告
typedef struct node{
int id ,time;//作业所需时间
}jobnode;
typedef struct Node{
int id ,avail;//id机器编号、avail每次作业的初始时间
}manode;
manode machine[N];
jobnode job[N];
scanf("%d",&n);
printf("请输入加油站的个数:");
scanf("%d",&k);
for(i=0;i<=k;i++)
scanf("%d",&d[i]);
greedy(d,n,k);
}
实验结果截图:
（3）实验代码：设有n个正整数，将它们连接成一排，组成一个最大的多位整数
#include<stdio.h>
return;
}
}
for(i=0,s=0;i<=k;i++){
if(s<n)
s+=d[i];
else if(s>n){
n=s-d[i];
num++;
}
}
printf("%d\n",num);
}
void main(){
int i,n,k;
int d[1000];
printf("请输入汽车可行驶公里数:");
/*找出下一个作业执行机器*/
manode *Find_min(manode a[],int m){
manode *temp=&a[0];
贪心算法实验报告
一、实验目的通过本次实验，使学生对贪心算法的概念、基本要素、设计步骤和策略有更深入的理解，掌握贪心算法的原理和应用，并能够运用贪心算法解决实际问题。
二、实验内容本次实验主要涉及以下两个问题：1. 使用贪心算法解决单起点最短路径问题；2. 使用贪心算法解决小船过河问题。
三、实验原理1. 贪心算法贪心算法（又称贪婪算法）是一种在每一步选择中都采取当前最优的选择，从而希望导致结果是全局最优的算法。
贪心算法在每一步只考虑当前的最优解，不保证最终结果是最优的，但很多情况下可以得到最优解。
2. 单起点最短路径问题单起点最短路径问题是指在一个有向无环图中，从某个顶点出发，找到到达其他所有顶点的最短路径。
3. 小船过河问题小船过河问题是指一群人需要划船过河，船只能容纳两个人，过河后需要一人将船开回，问最少需要多久让所有人过河。
四、实验步骤及说明1. 创建图结构，包括顶点数组和边信息。
2. 使用Dijkstra算法求解单起点最短路径问题，得到最短路径和前驱顶点。
3. 使用贪心算法找到两点之间的最短距离，并更新距离和前驱顶点信息。
4. 遍历所有顶点，找到未纳入已找到点集合的距离最小的顶点，并更新其距离和前驱顶点。
5. 最终输出从源顶点到达其余所有点的最短路径。
6. 使用贪心算法解决小船过河问题，按照以下步骤进行：（1）计算所有人过河所需的总时间；（2）计算每次划船往返所需时间；（3）计算剩余人数；（4）重复（2）和（3）步骤，直到所有人过河。
五、实验结果与分析1. 单起点最短路径问题实验中，我们选取了有向无环图G，其中包含6个顶点和8条边。
使用贪心算法和Dijkstra算法求解单起点最短路径问题，得到的实验结果如下：- 贪心算法求解单起点最短路径问题的时间复杂度为O(V^2)，其中V为顶点数；- Dijkstra算法求解单起点最短路径问题的时间复杂度为O(V^2)，其中V为顶点数。
2. 小船过河问题实验中，我们选取了一群人数为10的人过河，船每次只能容纳2人。
算法设计和分析实验四：贪心算法求解背包问题
实验五：贪心算法求解背包问题实验内容应用贪心算法求解离散背包问题，分析时间复杂度。
有一个承重为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循环，时间复杂度为Ｏ（ｎ＊ｎ）。
贪心算法实验报告(C语言)
实验2、《贪心算法实验》一、实验目的1. 了解贪心算法思想2. 掌握贪心法典型问题，如背包问题、作业调度问题等。
二、实验内容1. 编写一个简单的程序，实现单源最短路径问题。
2. 编写一段程序，实现找零。
【问题描述】当前有面值分别为2角5分，1角，5分，1分的硬币，请给出找n分钱的最佳方案（要求找出的硬币数目最少）。
3. 编写程序实现多机调度问题【问题描述】要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m 台机器加工处理完成。
约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。
作业不能拆分成更小的子作业。
三、算法思想分析1.初始化将源点设计为红点集，其余点设计为蓝点，重复选择蓝点集中与源点路径最短的点加入红点集，更新剩余的蓝点集路径，直至蓝点集为空或者只剩下没有连通的点，那么源点到其余所有点的最短路径就出来了。
2.找零问题是典型的贪心问题，但是并不代表所有的找零都能用贪心算法找到最优解。
只有满足贪心选择性质的找零才能找到最优解，本题满足贪心选择性质，直接先一直选面值最大的硬币，再一次减小即可。
3.先对作业按时长进行重排序，再依次找目前用时最短的机器安排工作并加上对应时长，最后总时长为机器中用时最长的那个时长。
四、实验过程分析1.单源最短路径的算法思想并不难，但是在实际编码过程中还是有很多小问题需要注意，首先，一定要新建数组存储路径变化，因为后面计算路径时会用到原数组，如果直接在原数组上更改后面就找不到原数据了，那么就会出现偏差。
其次就是建议先写个伪代码，判断的if-else语句比较多，容易搞混，在代码中一定要及时备注，某些代码的功能是什么，不然再次看代码时需要思考很久甚至忘记。
2.找零问题直接用while循环或者不断取余取模即可解决。
3.作业调度问题大致分为三步，一是排序，二是不断找最短时长的机器安排作业，三是找最长时间为作业完成时间。
五、算法源代码及用户屏幕1.（1）算法源码/**********************单源最短路径问题。
贪心算法实验报告
贪心算法实验报告实验报告题目实验四贪心算法开课实验室:数学实验室指导老师:韩逢庆时间:2011.12 学院:理学院专业:信息与计算科学班级:2009级2班姓名:古月学号:09180230一、实验目的1(加深学生对贪心算法设计方法的基本思想、基本步骤、基本方法的理解与掌握;2(提高学生利用课堂所学知识解决实际问题的能力;3(提高学生综合应用所学知识解决实际问题的能力。
二、实验内容题目见P143:4-16,4-23.三、实验要求(1)用分治法求解最少加油次数和最少硬币个数问题;(2 )再选择自己熟悉的其它方法求解本问题;(3)上机实现所设计的所有算法;四、实验过程设计(算法设计过程)(1) 最少加油次数实验题目一辆汽车加满油以后可以行使n公里，旅途中有若干个加油站，设计一个有效算法，指出应在哪些加油站停靠加油，使沿路加油次数最少。
并证明算法能产生一个最优解。
过程设计贪心算法总是作出在当前看来最好的选择。
也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。
当然，希望贪心算法得到的最终结果也是整体最优的。
虽然贪心算法不能对所有问题都得到整体最优解，但对许多问题它能产生整体最优解。
比如说最少加油次数的问题。
在这个算法中，我采用的贪心算法的策略。
首先人机互动的设定加满油以后最长能够行使的距离，然后输入了各个站点之间的距离，在程序的设计中，首先检查了程序的可行性。
要是遇到当某两个站点之间的距离大于汽车一次加油以后所能够行使的最大距离时，我们认为此问题是不可行的。
这个在实际情况中也是很容易理解的。
然后在满足可行性条件下，依次采用贪心算法对问题得以实现。
采用s这个来保存现在车里面留下的油，当此时留下的有能够行驶完这一站点到下一站点之间的距离是，在这一站点的时候就不加油。
但是若不能行使完这一段路程的时候，就加满油。
核心算法如下:for(i=0,s=0;i<n;i++){s=s+a[i];if(s>n){sum++;s=a[i];}}(2) 最少硬币个数问题实验题目考虑下面的用最少硬币个数找出n分钱的问题:当使用2角5分，1角，5分和1分四种硬币面值时，设计一个找n分钱的贪心算法，并证明算法能产生最优解。
第四章贪心算法实验报告
第四章贪⼼算法实验报告《贪⼼算法实验报告》计科2001 陈梓聪 20201003024贪⼼算法的思想：通过第四章学习了贪⼼算法，我们知道，贪⼼算法总是做出在当下看来最好的选择，通过每个最优的选择来得出原问题的最优解。
贪⼼算法的使⽤条件：贪⼼算法有的时候并不能得出最优解，只有在满⾜⼀下两个条件的时候才能使⽤：1.贪⼼性质：整体的最优解可通过⼀系列局部最优解达到，并且每次的选择可以依赖以前做出的选择，但不能依赖于以后的选择。
2.最优⼦结构：问题整体的最优解包括⼦问题的最优解。
贪⼼算法的局限性：贪⼼算法有他的局限性，有的时候我们选择局部的最优解，但是它对与全局并⾮最优解，就⽐如硬币找零问题。
但是我们依然可以⽤我们上⼀章所学的动态规划思想来解决。
贪⼼算法的分析过程：⾸先，我们需要确定我们的贪⼼策略，只有正确的贪⼼策略才能得出我们的结论。
下⾯是我们的实验题。
4-1程序储存问题：设有n 个程序{1,2,…, n }要存放在长度为L的磁带上。
程序i存放在磁带上的长度是 li，1≤i≤n。
程序存储问题要求确定这n 个程序在磁带上的⼀个存储⽅案，使得能够在磁带上存储尽可能多的程序。
对于给定的n个程序存放在磁带上的长度，计算磁带上最多可以存储的程序数。
输⼊格式：第⼀⾏是2 个正整数，分别表⽰⽂件个数n和磁带的长度L。
接下来的1⾏中，有n个正整数，表⽰程序存放在磁带上的长度。
输出格式：输出最多可以存储的程序数。
输⼊：6 50 输出： 52 3 13 8 80 20#include <iostream>#include <algorithm>using namespace std;int main() {int n, l, res;cin >> n >> l;int *a = new int [n];for(int i = 0; i < n; i ++) {cin >> a[i];}sort(a, a + n);for(int i = 0; i < n; i ++) {l -= a[i];if(l < 0) {res = i;break;}}cout << res;return0;}贪⼼策略：我的贪⼼策略是将还未存⼊磁带中最⼩的程序放⼊磁带，直到放⼊⼀个程序后，再放⼊下⼀个程序时程序的总长度>L，此时能存下最多程序数。
贪心算法实验报告
贪心算法实验报告贪心算法实验报告引言：贪心算法是一种常用的算法设计思想，它在求解最优化问题中具有重要的应用价值。
本实验报告旨在介绍贪心算法的基本原理、应用场景以及实验结果，并通过实例加以说明。
一、贪心算法的基本原理贪心算法是一种以局部最优解为基础，逐步构建全局最优解的算法。
其基本原理是在每一步选择中都采取当前状态下最优的选择，而不考虑之后的结果。
贪心算法通常具备以下特点：1. 贪心选择性质：当前状态下的最优选择一定是全局最优解的一部分。
2. 最优子结构性质：问题的最优解可以通过子问题的最优解来构造。
3. 无后效性：当前的选择不会影响以后的选择。
二、贪心算法的应用场景贪心算法适用于一些具有最优子结构性质的问题，例如：1. 路径选择问题：如Dijkstra算法中的最短路径问题，每次选择当前距离最短的节点进行扩展。
2. 区间调度问题：如活动选择问题，每次选择结束时间最早的活动进行安排。
3. 零钱找零问题：给定一些面额不同的硬币，如何用最少的硬币凑出指定的金额。
三、实验设计与实现本次实验选择了一个经典的贪心算法问题——零钱找零问题，旨在验证贪心算法的有效性。
具体实现步骤如下：1. 输入硬币面额和需要凑出的金额。
2. 对硬币面额进行排序，从大到小。
3. 从面额最大的硬币开始，尽可能多地选择该面额的硬币，直到不能再选择为止。
4. 重复步骤3，直到凑出的金额等于需要凑出的金额。
四、实验结果与分析我们通过对不同金额的零钱找零问题进行实验，得到了如下结果：1. 当需要凑出的金额为25元时，贪心算法的结果为1个25元硬币。
2. 当需要凑出的金额为42元时，贪心算法的结果为1个25元硬币、1个10元硬币、1个5元硬币、2个1元硬币。
3. 当需要凑出的金额为63元时，贪心算法的结果为2个25元硬币、1个10元硬币、1个1元硬币。
通过实验结果可以看出，贪心算法在零钱找零问题中取得了较好的效果。
然而，贪心算法并不是适用于所有问题的万能算法，它的有效性取决于问题的特性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第4章贪心算法
实验4.1 贪心算法的实现与时间复杂度测试
1. 实验目的
编程实现经典的贪心算法，理解贪心算法设计的基本思想、程序实现的相关技巧，加深对贪心算法设计与分析思想的理解。
通过程序的执行时间测试结果，与理论上的时间复杂度结论进行对比、分析和验证。
2. 原理解析
贪心算法的基本思想
贪心算法求解优化问题的基本思想是：采用逐步构造最优解的方法。
在每个阶段，都做出一个当前最优的决策（在一定的标准下）。
决策一旦做出，就不可再更改（做出贪心决策的依据称为贪心准则）。
贪心算法的一般步骤如下：
(1) 根据拟解决问题选取一种贪心准则；
(2) 按贪心准则标准对n个候选输入排序（以这一方法为代表，仍可基于堆来存储候选）；
(3) 依次选择输入量加入部分解中：如果当前这个输入量的加入，不满足约束条件，则不把此输入加到这部分解中。
贪心算法的基本设计范式如下：
Greedy(A,n)
A: include n inputs
Solution=Ф
for i=1 to n do
x=Select(A)
if Feasible(solution,x) then
solution=Union(solution,x)
end if
end for
return solution
测试算法
背包问题是使用贪心算法求解的代表问题，算法如下：
KnapsackGreedy(p，w，m，x，n)
//v[1..n]和w[1..n]分别含有按vi/wi v(i+1)/v(i+1)排序的n 件物品的价值和重量。
M是背包的容量大小，而x[1..n]是解向量// for i=1 to n do
xi=0 //将解向量初始化为零//
end for
cu=m //cu是背包剩余容量//
for i=1 to n do
if wi>cu then
exit
end if
xi=1
cu=cu-wi
repeat
if i≤n then
xi=cu/wi
end if
算法的时间复杂度取决于对v i/w i排序的时间复杂度，例如，若选择MergeSort 排序算法，则以上算法的时间复杂度为O(n log n)。
3. 实验内容
（1）编程实现以上求解背包问题的贪心算法，并通过手动设置、生成随机数获得实验数据。
记录随着输入规模增加算法的执行时间，分析并以图形方式展现增长率；测试、验证、对比算法的时间复杂度。
（2）利用贪心算法思想，设计实现单源最短路径问题的算法，并编程实现。
4. 实验步骤和要求
实验内容（1）步骤：
(1) 编程实现以上KnapsackGreedy算法，并进行测试，保证程序正确无误。
其中，分别在程序开始和结束处设置记录系统当前时间的变量、用于计算程序执行的时间（以毫秒(ms)作为时间的计数单位）。
(2) 设定一个m值（背包容量），测试随着n增加、程序执行时间增加的趋势。
分别使用实验1中的随机数生成算法生成n个随机数作为n个物品的重量，再生成n个随机数作为n个物品的价值（n=10, 20, 40, 100, 200, 400, 800, 2000）。
记录随着n增加程序的执行时间，并使用MS Excel图表绘制工具生成程序执行时间的对比曲线图。
(3) 与理论上的时间复杂度结论进行对比分析，完成实验报告。
实验内容（2）步骤：
（1）分析该问题的贪心选择性质；
（2）分析该问题的最优子结构性质；
（3）算法的设计与实现；。