计算机算法与分析贪心算法实验报告
实验三-贪心算法
for(inti=0;i<s.length();i++){
buf.append(getEachCode(s.substring(i,i+1)));
}
returnbuf.toString();
}
publicString getEachCode(String name){
for(inti=0;i<buffer.length();i++){
if(name.equals(codes[i].name)){
returnhuffstring[i];
}
}
return"";
}
publicvoidgetCode(intn,String[] thecodes,String thebuffer){
importjava.util.Scanner;
classHuffmanCode{
Stringname;
doubleweight;
intlc,rc,pa;
publicHuffmanCode(){
name="";
weight=0;
lc=-1;rc=-1;pa=-1;
}
}
publicclassHuffman1 {
dist[j]=newdist;prev[j]=u;}}}}
(3)运行结果
3、题目三
(1)问题分析
设G=（V，E）是连通带权图，V={1，2，…,n}。构造G的最小生成树的Prim算法的基本思想是：首先置S{1}，然后，只要S是V的真子集，就进行如下的贪心选择：选取满足条件i∈S，j∈V-S，且c[i][j]最小的边，将顶点j添加到S中。这个过程一直进行到S=V时为止。过程中所取到的边恰好构成G的一棵最小生成树。
贪心算法实验报告算法实验贪心法实验报告
贪心算法实验报告算法实验贪心法实验报告西安邮电大学（计算机学院）课内实验报告实验名称：贪心算法专业名称：班级：学生姓名：学号（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; }百度搜索“就爱阅读”,专业资料,生活学习,尽在就爱阅读网,您的在线图书馆。
实验3贪心算法（定稿）
实验3贪心算法（定稿）第一篇：实验3 贪心算法（定稿）《算法设计与分析》实验报告实验3贪心算法姓名学号班级实验日期实验地点一、实验目的1、掌握贪心算法的设计思想。
2、理解最小生成树的相关概念。
二、实验环境1、硬件环境 CPU：酷睿i5 内存：4GB 硬盘：1T2、软件环境操作系统：Windows10 编程环境：jdk 编程语言：Java三、实验内容：在Prim算法与Kruskal算法中任选一种求解最小生成树问题。
1、你选择的是：Prim算法2、数据结构（1）图的数据结构——图结构是研究数据元素之间的多对多的关系。
在这种结构中，任意两个元素之间可能存在关系，即结点之间的关系可以是任意的，图中任意元素之间都可能相关。
图形结构——多个对多个，如（2）树的数据结构——树结构是研究数据元素之间的一对多的关系。
在这种结构中，每个元素对下(层)可以有0个或多个元素相联系，对上(层)只有唯一的一个元素相关，数据元素之间有明显的层次关系。
树形结构——一个对多个，如3、算法伪代码 Prim(G,E,W)输入：连通图G 输出：G的最小生成树T 1.S←{1};T=∅ 2.While V-S ≠∅ do3.从V-S中选择j使得j到S中顶点的边e的权最小；T←T∪{e}4.S←S∪{j}3、算法分析时间复杂度：O(n)空间复杂度：O(n^2)4、关键代码（含注释）package Prim;import java.util.*;publicclass Main { staticintMAXCOST=Integer.MAX_VALUE;staticint Prim(intgraph[][], intn){ /* lowcost[i]记录以i为终点的边的最小权值，当lowcost[i]=0时表示终点i加入生成树 */ intlowcost[]=newint[n+1];/* mst[i]记录对应lowcost[i]的起点，当mst[i]=0时表示起点i加入生成树 */ intmst[]=newint[n+1];intmin, minid, sum = 0;/* 默认选择1号节点加入生成树，从2号节点开始初始化*/ for(inti = 2;i<= n;i++){/* 标记1号节点加入生成树 */ mst[1] = 0;/* n个节点至少需要n-1条边构成最小生成树 */ for(inti = 2;i<= n;i++){/* 找满足条件的最小权值边的节点minid */ for(intj = 2;j<= n;j++){/* 输出生成树边的信息:起点，终点，权值 */System.out.printf(“%c1, minid + 'A''A' + 1;intj = chy-'A' + 1;graph[i][j] = cost;graph[j][i] = cost;for(intj = 1;j<= n;j++){ } graph[i][j] = MAXCOST;} } System.out.println(”Total:"+cost);} }5、实验结果（1）输入（2）输出最小生成树的权值为：生成过程：(a)(b)(d)(e)(c)四、实验总结（心得体会、需要注意的问题等）这次实验，使我受益匪浅。
贪心算法 实验报告
贪心算法实验报告贪心算法实验报告引言：贪心算法是一种常用的算法设计策略，它通常用于求解最优化问题。
贪心算法的核心思想是在每一步选择中都选择当前最优的解，从而希望最终能够得到全局最优解。
本实验旨在通过实际案例的研究，探索贪心算法的应用和效果。
一、贪心算法的基本原理贪心算法的基本原理是每一步都选择当前最优解，而不考虑整体的最优解。
这种贪婪的选择策略通常是基于局部最优性的假设，即当前的选择对于后续步骤的选择没有影响。
贪心算法的优点是简单高效，但也存在一定的局限性。
二、实验案例：零钱兑换问题在本实验中，我们以零钱兑换问题为例，来说明贪心算法的应用。
问题描述：假设有不同面值的硬币，如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个。
算法分析与设计实验二贪心算法
算法分析与设计实验二贪心算法实验二：贪心算法【实验目的】应用贪心算法求解活动安排问题。
【实验性质】验证性实验。
【实验要求】活动安排问题是可以用贪心算法有效求解的很好的例子。
问题：有n个活动的集合A={1,2,…,n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。
求解：安排尽量多项活动在该场地进行，即求A的最大相容子集。
设待安排的11个活动的开始时间和结束时间按结束时间的升序排列如下： i 1 2 35 3 06 4 57 5 38 6 59 7 6 10 8 8 11 9 8 12 10 2 13 11 12 14 s[i] 1 f[i] 4将此表数据作为实现该算法的测试数据。
【算法思想及采用的数据结构】【程序代码】【运行结果】【算法分析和心得体会】附加题：【实验要求】需要在某个城市的n个居民区之间铺设煤气管道，则在这n个居民区之间只要铺设n-1条管道即可。
假设任意两个居民区之间都可以架设管道，但由于地理环境的不同，所需经费不同。
选择最优的施工方案能使总投资尽可能少，这个问题即为求网的“最小生成树”问题。
参照以下居民区示意图，使得求解算法为：在可能架设的m条管道中选取n-1条，既能连通n-1个居民区，有使总投资达到“最小”。
网可采用邻接矩阵为存储结构，以定点对（i,j）的形式输出最小生成树的边。
D 23.1 675.9 C 41.1 56B A 38.2 441218.2 I 8.7 H 52.5 G 10.5E 98.7 居民区示意图 85F 79应用贪心算法策略，采用普里姆算法或Kruskal算法来求解居民区示意图的最小生成树，采用合适的数据结构。
用C语言或C++语言编写程序代码，选上述居民区示意图中的数据作为测试数据。
并调试输出正确结果。
【算法思想及采用的数据结构】【程序代码】【运行结果】【算法分析和心得体会】感谢您的阅读，祝您生活愉快。
算法设计与分析实验报告
算法设计与分析实验报告算法设计与分析实验报告引言：算法设计与分析是计算机科学中的重要课程，它旨在培养学生解决实际问题的能力。
本次实验旨在通过设计和分析不同类型的算法，加深对算法的理解，并探索其在实际应用中的效果。
一、实验背景算法是解决问题的步骤和方法的描述，是计算机程序的核心。
在本次实验中，我们将重点研究几种经典的算法，包括贪心算法、动态规划算法和分治算法。
通过对这些算法的设计和分析，我们可以更好地理解它们的原理和应用场景。
二、贪心算法贪心算法是一种基于局部最优选择的算法，它每一步都选择当前状态下的最优解，最终得到全局最优解。
在实验中，我们以背包问题为例，通过贪心算法求解背包能够装下的最大价值物品。
我们首先将物品按照单位重量的价值从大到小排序，然后依次将能够装入背包的物品放入，直到背包无法再装下物品为止。
三、动态规划算法动态规划算法是一种通过将问题分解为子问题，并记录子问题的解来求解整体问题的算法。
在实验中，我们以斐波那契数列为例，通过动态规划算法计算斐波那契数列的第n项。
我们定义一个数组来保存已经计算过的斐波那契数列的值，然后通过递推公式将前两项的值相加得到后一项的值，最终得到第n项的值。
四、分治算法分治算法是一种将问题分解为更小的子问题，并通过递归求解子问题的算法。
在实验中，我们以归并排序为例，通过分治算法对一个无序数组进行排序。
我们首先将数组分成两个子数组，然后对子数组进行递归排序，最后将两个有序的子数组合并成一个有序的数组。
五、实验结果与分析通过对以上三种算法的设计和分析，我们得到了以下实验结果。
在贪心算法中，我们发现该算法能够在有限的时间内得到一个近似最优解，但并不能保证一定得到全局最优解。
在动态规划算法中，我们发现该算法能够通过记忆化搜索的方式得到准确的结果，但在问题规模较大时，其时间复杂度较高。
在分治算法中，我们发现该算法能够将问题分解为更小的子问题，并通过递归求解子问题，最终得到整体问题的解。
《算法设计与分析》课程实验报告 (贪心算法(一))
《算法设计与分析》课程实验报告实验序号：07实验项目名称：实验8 贪心算法（一）一、实验题目1.删数问题问题描述：键盘输入一个高精度的正整数N（不超过250 位），去掉其中任意k个数字后剩下的数字按原左右次序将组成一个新的非负整数。
编程对给定的N 和k，寻找一种方案使得剩下的数字组成的新数最小。
若输出前有0则舍去2.区间覆盖问题问题描述：设x1,x2,...xn是实轴上的n个点。
用固定长度为k的闭区间覆盖n个点，至少需要多少个这样的固定长度的闭区间？请你设计一个有效的算法解决此问题。
3.会场安排问题问题描述：假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。
设计一个有效的贪心算法进行安排。
（这个问题实际上是著名的图着色问题。
若将每一个活动作为图的一个顶点，不相容活动间用边相连。
使相邻顶点着有不同颜色的最小着色数，相应于要找的最小会场数。
）4.导弹拦截问题问题描述：某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。
但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。
某天，雷达捕捉到敌国的导弹来袭。
由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。
给定导弹依次飞来的高度（雷达给出的高度数据是≤50000的正整数），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。
二、实验目的（1）通过实现算法，进一步体会具体问题中的贪心选择性质，从而加强对贪心算法找最优解步骤的理解。
（2）掌握通过迭代求最优的程序实现技巧。
（3）体会将具体问题的原始数据预处理后（特别是以某种次序排序后），常能用贪心求最优解的解决问题方法。
三、实验要求（1）写出题1的最优子结构性质、贪心选择性质及相应的子问题。
（2）给出题1的贪心选择性质的证明。
（3）（选做题）：写出你的算法的贪心选择性质及相应的子问题，并描述算法思想。
算法实验报告贪心
一、实验背景贪心算法是一种在每一步选择中都采取当前状态下最好或最优的选择，从而希望导致结果是全局最好或最优的算法策略。
贪心算法并不保证能获得最优解，但往往能获得较好的近似解。
在许多实际应用中，贪心算法因其简单、高效的特点而被广泛应用。
本实验旨在通过编写贪心算法程序，解决经典的最小生成树问题，并分析贪心算法的优缺点。
二、实验目的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算法：从任意一个顶点开始，逐步添加边，直到所有顶点都被包含在生成树中。
贪心算法_实验报告
贪心算法_实验报告一、设计分析●问题描述：键盘输入一个高精度的正整数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 s
空间限制: 256000 KB
题目等级 : 钻石 Diamond
题目描述 Description
一条街的一边有几座房子。因为环保原因居民想要在路边种些树。路边的地区被分割成块，并被编号为1…n。每个块的大小为一个单位尺寸并最多可种一裸树。每个居民想在门前种些树并指定了三个号码b，e，t。这三个数表示该居民想在b和e之间最少种t棵树。当然，b≤e，居民必须保证在指定地区不能种多于地区被分割成块数的树，即要求T≤ e-b+1。允许居民想种树的各自区域可以交叉。出于资金短缺的原因，环保部门请你求出能够满足所有居民的要求，需要种树的最少数量。
9
4
1 4 2
4 6 2
8 9 2
3 5 2
样例输出 Sample Output
5
数据范围及提示 Data Size & Hint
【数据规模】
30％的数据满足0＜n ≤1000，0＜h ≤ 500；100%的数据满足n ≤30000，h ≤5000。
时间限制: 1 s
空间限制: 128000 KB
题目等级 : 黄金 Gold
错了以后想了一下，发现本题解法要改一下。首先肯定是按照损失第一降序排序，然后才是时间第二增序排序。但是贪心过程也不能直接数数。样例有一个例子就是损失多的排序后在前面，损失少的排序在后面。看起来不能兼得，但是实际上，前面那个损失大的游戏的时间不是那么急迫，是允许晚一点去执行的。这样却可以兼得。如何解决这个问题？
种树题，要求的是最少的种树的数量。也就是说，如果一个人种了一棵树，为了使得种的树最少，那就要使得这颗树尽量种在大家都想种的区域之中。每一次针对一个要种树的居民来说，如何种树才能使得以后种树的人能够尽力的享受到“我”种的树带来的好处呢？
实验3 贪心算法
淮海工学院计算机工程学院实验报告书课程名：《算法分析与设计》题目：实验3 贪心算法班级：学号：姓名：实验3 贪心算法实验目的和要求（1）了解前缀编码的概念，理解数据压缩的基本方法；（2）掌握最优子结构性质的证明方法；（3）掌握贪心法的设计思想并能熟练运用（4）证明哈夫曼树满足最优子结构性质；（5）设计贪心算法求解哈夫曼编码方案；（6）设计测试数据，写出程序文档。
实验内容设需要编码的字符集为{d 1, d 2, …, dn }，它们出现的频率为{w 1, w 2, …, wn }，应用哈夫曼树构造最短的不等长编码方案。
实验环境Turbo C 或VC++实验学时2学时，必做实验数据结构与算法//构造哈夫曼结构体struct huffman{double weight; //用来存放各个结点的权值int lchild,rchild,parent; //指向双亲、孩子结点的指针 };核心源代码#include<iostream>#include <string>using namespace std;#include <stdio.h>//构造哈夫曼结构体struct huffman{double weight;∑=j i k k aint lchild,rchild,parent;};static int i1=0,i2=0;//选择权值较小的节点int Select(huffman huff[],int i){int min=11000;int min1;for(int k=0;k<i;k++){if(huff[k].weight<min && huff[k].parent==-1){min=huff[k].weight;min1=k;}}huff[min1].parent=1;return min1;}//定义哈夫曼树，并对各个节点进行赋权值void HuffmanTree(huffman huff[],int weight[],int n) {for(int i=0;i<2*n-1;i++){huff[i].lchild=-1;huff[i].parent=-1;huff[i].rchild=-1;}for(int l=0;l<n;l++){huff[l].weight=weight[l];}for(int k=n;k<2*n-1;k++){int i1=Select(huff,k);int i2=Select(huff,k);huff[i1].parent=k;huff[i2].parent=k;huff[k].weight= huff[i1].weight+huff[i2].weight;huff[k].lchild=i1;huff[k].rchild=i2;}}//哈夫曼编码，左0右1void huffmancode(huffman huff[],int n){string s;int j;for(int i=0;i<n;i++){s="";j=i;while(huff[j].parent!=-1){if(huff[huff[j].parent].lchild==j)s=s+"0";else s=s+"1";j=huff[j].parent;}cout<<"第"<<i+1<<"个节点的哈夫曼编码为：";for(int j=s.length();j>=0;j--){cout<<s[j];}cout<<endl;}}void main(){huffman huff[20];int n,w[20];printf("请输入节点的个数:");scanf("%d",&n);for(int i=0;i<n;i++){printf("请输入第%d个节点的权值:",i+1);scanf("%d",&w[i]);}printf("\n");HuffmanTree(huff,w,n);huffmancode(huff,n);}实验结果实验体会本次实验是用贪心法求解哈夫曼编码,其实贪心法和哈夫曼树的原理是一样的,每次将集合中两个权值最小的二叉树合并成一棵新二叉树，每次选择两个权值最小的二叉树时，规定了较小的为左子树。
算法设计与分析实验报告贪心算法
算法设计与分析实验报告贪心算法班级：2013156 学号：201315614 ：春阳哈夫曼编码代码#include<stdio.h>float small1,small2;int flag1,flag2,count;typedef struct HuffmanTree{float weight;int lchild,rchild,parent;}huffman;huffman huffmantree[100];void CreatHuffmanTree(int n,int m){int i;void select();printf("请输入%d个节点的权值:",n);for(i=0;i<n;i++)scanf("%f",&huffmantree[i].weight);printf("\n");for(i=0;i<m;i++){huffmantree[i].lchild=-1;huffmantree[i].rchild=-1;huffmantree[i].parent=-1;}for(count=n;count<m;count++){select();huffmantree[flag1].parent=count;huffmantree[flag2].parent=count;huffmantree[count].weight=small1+small2;huffmantree[count].lchild=flag1;huffmantree[count].rchild=flag2;}}void select(){int i,a,b;float stemp;int ftemp;a=0;b=0;for(i=0;i<count;i++){if(huffmantree[i].parent==-1){if(a==0){small1=huffmantree[i].weight;flag1=i;a=a+1;}elseif(b==0){small2=huffmantree[i].weight;flag2=i;b=b+1;}}if((a==1)&&(b==1))break;}if(small1>small2){stemp=small1;small1=small2;small2=stemp;ftemp=flag1;flag1=flag2;flag2=ftemp;}for(i=0;i<count;i++)if(huffmantree[i].parent==-1)if((flag1!=i)&&(flag2!=i))if(huffmantree[i].weight<small2){small2=huffmantree[i].weight;flag2=i;if(small1>small2){stemp=small1;small1=small2;small2=stemp;ftemp=flag1;flag1=flag2;flag2=ftemp;}}}void huffmancode(int n){int a[100];int j,k,i,c;for(i=0;i<n;i++){j=i;c=0;while(huffmantree[j].parent!=-1){k=huffmantree[j].parent;if(huffmantree[k].lchild==j)a[c]=0;if(huffmantree[k].rchild==j)a[c]=1;c=c+1;j=k;}printf("节点%d的哈夫曼编码为：",i);for(c=c-1;c>-1;c--)printf("%d",a[c]);printf("\n");}}void main(){int n,m;printf("请输入一共有几个节点:");scanf("%d",&n);m=2*n-1;CreatHuffmanTree(n,m);huffmancode(n);}截图。
贪心算法实验报告
一、实验目的通过本次实验，使学生对贪心算法的概念、基本要素、设计步骤和策略有更深入的理解，掌握贪心算法的原理和应用，并能够运用贪心算法解决实际问题。
二、实验内容本次实验主要涉及以下两个问题：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人。
贪心算法实验报告(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）算法源码/**********************单源最短路径问题。
计算机算法实验报告
计算机算法实验报告计算机算法实验报告一、引言计算机算法是计算机科学中的核心概念之一，它是解决问题的一种方法或步骤。
在本次实验中，我们将探讨两种常见的计算机算法：贪心算法和动态规划算法。
通过实验，我们将分析这两种算法的优劣势，并比较它们在不同场景下的应用。
二、贪心算法贪心算法是一种简单而直观的算法，它在每一步选择中都采取当前状态下的最优解，从而希望最终得到全局最优解。
在实验中，我们选择了背包问题作为贪心算法的应用场景。
背包问题是一个经典的组合优化问题，在限定总重量的情况下，如何选择物品使得总价值最大化。
贪心算法在背包问题中的应用是将物品按照单位价值进行排序，然后依次将单位价值最高的物品放入背包中，直到背包无法再放入物品为止。
通过实验，我们发现贪心算法在背包问题中的表现良好。
它的时间复杂度较低，而且在大多数情况下能够找到接近最优解的解决方案。
然而，贪心算法也有其局限性，当问题的子问题之间存在相互依赖关系时，贪心算法可能无法得到最优解。
三、动态规划算法动态规划算法是一种通过将问题分解为子问题来求解的算法。
与贪心算法不同，动态规划算法会保存已经解决过的子问题的解，避免重复计算，从而提高效率。
在实验中，我们选择了最长公共子序列问题作为动态规划算法的应用场景。
最长公共子序列问题是求解两个序列中最长的共同子序列的问题。
动态规划算法通过构建一个二维数组，将问题划分为多个子问题，并逐步求解子问题的最优解。
最终，我们可以通过查找二维数组的最后一个元素，得到最长公共子序列的长度。
实验结果显示，动态规划算法在最长公共子序列问题中表现出色。
它能够高效地求解问题，并且可以得到最优解。
然而，动态规划算法的时间复杂度较高，当问题规模较大时，可能会导致计算时间过长。
四、算法比较与总结通过对贪心算法和动态规划算法的实验比较，我们可以得出以下结论：1. 贪心算法适用于那些子问题之间相互独立，且每个子问题的最优解能够推导出全局最优解的问题。
算法贪婪法实验报告
一、实验背景与目的随着计算机科学的不断发展，算法在解决实际问题中的应用日益广泛。
贪婪法作为一种重要的算法设计方法，在许多领域都得到了广泛应用。
本实验旨在通过实际案例，让学生了解和掌握贪婪法的基本原理、设计方法以及应用场景。
二、实验内容与步骤1. 实验内容本实验选取两个经典问题作为案例，分别是“最小生成树”和“硬币找零问题”，分别使用贪婪法进行求解。
2. 实验步骤（1）最小生成树问题① 确定问题背景：给定一个无向连通图，要求找到一棵包含图中所有顶点的最小生成树。
② 设计贪心算法：以图中的任意一个顶点为根，选择与根顶点距离最短的顶点作为下一个顶点，并添加到最小生成树中。
重复此步骤，直到所有顶点都被包含在最小生成树中。
③ 实现代码：使用C++语言实现贪心算法，计算最小生成树的总权值。
（2）硬币找零问题① 确定问题背景：给定一系列不同面值的硬币和找零金额，要求找出最少硬币数来凑齐该金额。
② 设计贪心算法：从面值最大的硬币开始，尽可能地使用硬币凑齐金额。
若当前硬币面值大于剩余金额，则尝试使用面值较小的硬币，重复此步骤，直到金额为0。
③ 实现代码：使用C++语言实现贪心算法，计算最少硬币数。
三、实验结果与分析1. 最小生成树问题实验结果表明，使用贪心法求解最小生成树问题时，能够得到一棵包含图中所有顶点的最小生成树。
在实验过程中，我们发现贪心法在求解最小生成树问题时，存在一定的局限性。
例如，当图中存在多个顶点距离相同的情况下，贪心法可能会得到次优解。
2. 硬币找零问题实验结果表明，使用贪心法求解硬币找零问题时，能够得到最少硬币数来凑齐给定金额。
在实验过程中，我们发现贪心法在求解硬币找零问题时，具有较好的性能。
四、实验总结与讨论1. 贪婪法的基本原理贪婪法是一种在每一步都选择当前最优解的算法。
它通过在每一步选择局部最优解，期望得到全局最优解。
然而，贪婪法并不保证能够得到全局最优解，因为它的决策过程是基于局部最优解的。
算法分析与设计实验二贪心算法
算法分析与设计实验二贪心算法贪心算法（Greedy Algorithm）是一种常用的算法设计方法，其核心思想是在每一步都做出当前情况下最优选择，以期望最终得到全局最优解。
本实验主要介绍贪心算法的原理、应用和分析。
一、贪心算法的原理贪心算法的基本思路是在每一步都做出当前情况下最优选择，并且不考虑当前选择对后续选择的影响。
贪心算法通常采用贪心选择策略和最优子结构两个基本要素。
1.贪心选择策略贪心选择策略是指在每一步都选择当前情况下最优解的策略。
这种策略要求我们能够证明，通过选择当前最优解，可以使得问题的规模减小到原问题的一个子问题，并且该子问题的最优解一定包含在全局最优解中。
2.最优子结构最优子结构是指问题的最优解包含其子问题的最优解。
贪心算法求解问题的过程通常包括两个步骤，选择最优子结构和利用最优子结构得到最优解。
二、贪心算法的应用1.集合覆盖问题集合覆盖问题是指在给定的一组集合中，找出最小的子集合，使得这些子集合的并集包含所有的元素。
贪心算法可以通过每一步选择包含最多未覆盖元素的集合，直到覆盖所有元素为止。
2.挑选活动问题挑选活动问题是指在给定一组活动的起始时间和结束时间，找出最大的相容活动子集合。
贪心算法可以通过每一步选择结束时间最早的活动，之后将该活动与其他相容的活动进行比较，从而得到最大的相容活动子集合。
3.分数背包问题分数背包问题是指在给定一组物品和一个背包容量的情况下，选择部分物品放入背包，使得放入背包的物品总价值最大。
贪心算法可以通过每一步选择单位重量价值最高的物品，直到背包容量不足为止。
三、贪心算法的分析贪心算法通常具有高效性和近似最优性的特点。
由于贪心算法每一步都选择当前最优解，不进行回溯和剪枝的操作，因此贪心算法的时间复杂度较低。
然而，贪心算法并不总能得到问题的最优解，它通常只能得到近似最优解。
贪心算法的近似性证明可以分为两步。
首先，我们需要证明贪心选择策略的正确性，即每一步选择的最优解一定包含在全局最优解中。
贪心算法实验报告
贪心算法实验报告贪心算法实验报告引言：贪心算法是一种常用的算法设计思想，它在求解最优化问题中具有重要的应用价值。
本实验报告旨在介绍贪心算法的基本原理、应用场景以及实验结果，并通过实例加以说明。
一、贪心算法的基本原理贪心算法是一种以局部最优解为基础，逐步构建全局最优解的算法。
其基本原理是在每一步选择中都采取当前状态下最优的选择，而不考虑之后的结果。
贪心算法通常具备以下特点：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元硬币。
通过实验结果可以看出，贪心算法在零钱找零问题中取得了较好的效果。
然而，贪心算法并不是适用于所有问题的万能算法，它的有效性取决于问题的特性。
算法分析与设计实验报告--贪心法 (2)
Dijkstra方法的基本思想是从vs出发，逐步地向外探寻最短路。执行过程中，与每个点对应，记录下一个数(称为这个点的标号)，它或者表示从vs到该点的最短路的权(称为P标号)、或者是从vs到该点的最短路的权的上界(称为T标号)，方法的每一步是去修改T标号，并且把某一个具T标号的改变为具P标号的点，从而使G中具P标号的顶点数多一个，这样至多经过n-1(n为图G的顶点数)步，就可以求出从vs到各点的最短路。
if(D[j]>D[min]+graph[min][j]||D[j]==-1)
{D[j]=D[min]+graph[min][j]; //每次迭代求最小值，最后一次即为到源点的最短路径
P[j]=min;
}
}
}
void main()
{instital(R, B, D, P);
theshortestway(R, B, D, P);
using namespace std;
int const ZUSHU = 5;
int Ling[] = {50,20,10,5,1};
int GeShu[ZUSHU];
void ZhaoLing(int n)
{for(int i=0;i<ZUSHU;i++)
{GeShu[i] = n / Ling[i];n = n % Ling[i];}
（1）初始时，S中仅含有源节点。
（2）设u是G的某一个顶点，把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径，用数组D[i]记录顶点i当前所对应的最短特殊路径长度。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验03 贪心算法
一、实验目的
1.掌握贪心算法的基本思想
2.掌握贪心算法中贪心选择性质和最优子结构性质的分析与证明
3.掌握贪心算法求解问题的方法
二、实验内容
1.认真阅读算法设计教材,了解贪心算法思想及方法;
2.设计用贪心算法求解最优装载哈夫曼编码、单源最短路径、最小生成树的
java程序
三、求解的问题
1.哈夫曼编码是广泛地用于数据文件压缩的十分有效的编码方法。
给出文件中
各个字符出现的频率，求各个字符的哈夫曼编码方案。
2.给定带权有向图G =(V,E)，其中每条边的权是非负实数。
另外，还给定V
中的一个顶点，称为源。
现在要计算从源到所有其他各顶点的最短路长度。
这里路的长度是指路上各边权之和。
3.设G =(V,E)是无向连通带权图，即一个网络。
E中每条边(v,w)的权为
c[v][w]。
如果G的子图G’是一棵包含G的所有顶点的树，则称G’为G的生成树。
生成树上各边权的总和称为该生成树的耗费。
在G的所有生成树中，耗费最小的生成树称为G的最小生成树。
求G的最小生成树。
四、实验程序
1．哈夫曼编码
哈夫曼算法以自底向上的方式构造表示最优前缀码的二叉树T。
算法以|C|个叶结点开始，执行|C|-1次的“合并”运算后产生最终所要求的树T。
下面所给出的算法huffmanTree中，编码字符集中的每一字符c的频率是f（c）。
以f 为键值的优先队列Q用在贪心选择时有效地确定算法当前要合并的两棵具有最小频率的树。
一旦两棵具有最小频率的树合并后，产生一棵新的树，其频率为合并两棵树的频率之和，并将新树插入优先队列Q。
private static class Huffman implements Comparable{
Bintree tree; float weight;
private Huffman(Bintree tt,float ww) {
tree=tt;weight=ww; }
public int compareTo(Object x){
float xw=((Huffman) x).weight; if(weight<xw)return -1;
if(weight==xw) return 0;return 1;}}
public static Bintree huffmanTree(float []f){
int n=f.length; Huffman []w=new Huffman [n+1];
Bintree zero=new Bintree(); for(int i=0;i<n;i++)
{ Bintree x=new Bintree();
x.makeTree(new MyInterger(i),zero,zero);
w[i+1]=new Huffman(x,f[i]); }
MinHeap H =new MinHeap();H.initialize(w,n);
for(int i=0;i<n;i++){
Huffman x=(Huffman) H.removeMin(); HUffman y=(Huffman) H.removeMin();
Bintree z=new Bintree();z.makeTree(null,x.tree,y.tree);
HUffman t=new Huffman(z,x.weight+y.weight); H.put(t);}
return ((HUffman) H.removeMin()).tree;}
算法huffmanTree首先用字符集C中每一字符c的频率f（c）初始化优先队列Q。
然后不断地从优先队列Q中取出具有最小频率的两棵树x和y，将它们合并为一棵新树z。
z的频率是x和y的频率之和。
新树z以x为其左儿子，y 为其右儿子。
经过n-1次的合并后，优先队列中只剩下一棵树，即所要求的树T。
2．单源最短路径问题
Dijkstra算法的基本思想是，设置顶点集合S并不断地做贪心算法来扩充这个集合。
一个顶点属于集合S当且仅当从源到u且中间只经过S中顶点的路称为从源到u的特殊路径，并用数组dist记录当前每个顶点所对应的最短路径长度。
Dijkstra算法每次从V-S中取出具有最短特殊路长度的顶点u，将u添加到S中，同时对数组dist进行必要的修改。
一旦S包含了所有V中顶点，dist 就记录了从源到所有其他顶点之间的最短路径长度。
public static void dijkstra(int v,float[][]a,float []dist,int []prev){ int n=dist.length-1;if(v<1||v>n)return;boolean []s=new boolean [n+1];
for(int i=1;i<=n;i++){
dist[i]a[v][i]; s[i]=false; if(dist[i]==Float.MAX_VALUE) prev[i]=0;
else prev[i]=v;}
dise[v]=0;s[v]=true;for(int i=1;i<n;i++){
float temp=Float.MAX_VALUE; int u=v;for(int j=1;j<=n;j++)
if((! s[j])&&(dist[j]<temp)){u=j;temp=dist[j];}
s[u]=true; for(intj=1;j<=n;j++)
if((! s[j])&&(a[u][j]<Float.MAX_VALUE)){
float newdist=dist[u]+a[u][j]; if(newdist<dist[j]{
dist[j]=newdist;prev[j]=u;}}}}
3．最小生成树问题
设G=（V，E）是连通带权图，V={1，2，…,n}。
构造G的最小生成树的Prim 算法的基本思想是：首先置S{1}，然后，只要S是V的真子集，就进行如下的贪心选择：选取满足条件i∈S，j∈V-S，且c[i][j]最小的边，将顶点j添加到S中。
这个过程一直进行到S=V时为止。
过程中所取到的边恰好构成G的一棵最小生成树。
public static void prim(int n,float [][]c){
float []lowcost=new float[n+1]; int[]closest=new int[n+1];
boolean []s=new boolean[n+1];s[1]=true;
for(int i=2;i<=n;i++){ lowcost[i]=c[1][i]; losest[i]=1;s[i]=false; }
for(int i=1;i<n;i++){ float min=Float.MAX_VALUE; int j=1;
for(int k=2;k<=n;k++) if((lowcost[k]<min)&&(! s[k])){
min=lowcost[k]; j=k;}
System.out.println(j+", "+closest[j]);
s[j]=true; for(int k=2;k<=n;k++)
if((c[j][k]<lowcost[k])&&(! s[k])){
lowcost[k]=c[j][k]; closest[k]=j;}}}
五、测试数据
1．哈夫曼编码
请输入一组数据（用空格分隔）
0.13 0.19 0.26 0.03 0.07 0.01 0.31
输出结果：
0.13：011 长度：3
0.19：00 长度：2
0.26：10 长度：2
0.03：01001 长度：5
0.07：0101 长度：4
0.01：01000 长度：5
0.31：11 长度：2
2．单源最短路径
请输入顶点个数：
4
请输入顶点的权重：
2 4 -2 -4
2 4 6 -1
5 8 -3 5
-2 9 5 -7
4-2 -4
3.最小生成树
请输入结点个数：
4
输入图结点（输入-1，-1，-1退出）
1 3 5 2
2 3 5 1
3 2 5 3
3 2 1 4
-1 -1 -1 -1
第一边：2---3
第二边：1---3
第三边：0---0。