贪心算法实验报告
实验三-贪心算法
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的一棵最小生成树。
实验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)四、实验总结（心得体会、需要注意的问题等）这次实验，使我受益匪浅。
贪心算法解活动安排实验报告
实验3 贪心算法解活动安排问题一、实验要求1．要求按贪心法求解问题；2．要求读文本文件输入活动安排时间区间数据；3．要求显示结果。
二、实验仪器和软件平台仪器：带usb接口微机软件平台：WIN-XP + VC++6.0三、源程序#include "stdafx.h"#include<stdio.h>#include<stdlib.h>#include<algorithm>#define N 50#define TURE 1#define FALSE 0int s[N];/*开始时间*/int f[N];/*结束时间*/int A[N];/*用A存储所有的*/int Partition(int *b,int *a,int p,int r);void QuickSort(int *b,int *a,int p,int r);void GreedySelector(int n,int *s,int *f,int *A);int main(){int n=0,i;while(n<=0||n>50){printf("\n");printf("请输入活动的个数,n=");scanf("%d",&n);if(n<=0) printf("请输入大于零的数!");else if(n>50) printf("请输入小于50的数!");}printf("\n请分别输入开始时间s[i]和结束时间f[i]:\n\n");for(i=1;i<=n;i++){printf("s[%d]=",i,i);scanf("%d",&s[i]);printf("f[%d]=",i,i);scanf("%d",&f[i]);printf("\n");}QuickSort(s,f,1,n); //按结束时间非减序排列printf("按结束时间非减序排列如下:\n"); /*输出排序结果*/ printf("\n 序号\t开始时间结束时间\n");printf("-------------------------\n");for(i=1;i<=n;i++)printf(" %d\t %d\t %d\n",i,s[i],f[i]);printf("-------------------------\n");GreedySelector(n,s,f,A);//贪心算法实现活动安排printf("安排的活动序号依次为：");for(i=1;i<=n;i++){if(A[i])printf("\n%d %d-->%d",i,s[i],f[i]);}printf("\n");system("pause");return 0;}//快速排序void QuickSort(int *b,int *a,int p,int r){int q;if(p<r)q=Partition(b,a,p,r);QuickSort(b,a,p,q-1);/*对左半段排序*/ QuickSort(b,a,q+1,r);/*对右半段排序*/ }}//产生中间数int Partition(int *b,int *a,int p,int r){int k,m,y,i=p,j=r+1;int x=a[p];y=b[p];while(1){while(a[++i]<x);while(a[--j]>x);if(i>=j)break;else{k=a[i];a[i]=a[j];a[j]=k;m=b[i];b[i]=b[j];b[j]=m;}a[p]=a[j];b[p]=b[j];a[j]=x;b[j]=y;return j;}//贪心算法实现活动安排void GreedySelector(int n,int *s,int *f,int *A){//用集合A来存储所选择的活动A[1]=TURE; //默认从第一次活动开始执行int j=1; //j记录最近一次加入到A中的活动for(int i=2;i<=n;i++){//f[j]为当前集合A中所有活动的最大结束时间//活动i的开始时间不早于最近加入到集合A中的j的时间f[j]if(s[i]>=f[j]){A[i]=TURE; //当A[i]=TURE时，活动i在集合A中j=i;}else A[i]=FALSE; }}四、运行结果五、实验小结贪心算法总是做出在当前看来最好的选择，也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。
贪心算法 实验报告
贪心算法实验报告贪心算法实验报告引言：贪心算法是一种常用的算法设计策略，它通常用于求解最优化问题。
贪心算法的核心思想是在每一步选择中都选择当前最优的解，从而希望最终能够得到全局最优解。
本实验旨在通过实际案例的研究，探索贪心算法的应用和效果。
一、贪心算法的基本原理贪心算法的基本原理是每一步都选择当前最优解，而不考虑整体的最优解。
这种贪婪的选择策略通常是基于局部最优性的假设，即当前的选择对于后续步骤的选择没有影响。
贪心算法的优点是简单高效，但也存在一定的局限性。
二、实验案例：零钱兑换问题在本实验中，我们以零钱兑换问题为例，来说明贪心算法的应用。
问题描述：假设有不同面值的硬币，如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个。
贪心算法实验报告心得
贪心算法实验报告心得前言贪心算法是一种常见且重要的算法设计思想，通过每一步都选择当下最优的解决方案，以期望最终得到全局最优解。
在学习与实践贪心算法的过程中，我有了许多心得与体会。
什么是贪心算法？贪心算法是一种求解问题的算法思想，它的特点是每一步都选择当前最优的解决方案，而不考虑该选择对以后步骤的影响。
贪心算法通常适用于可以将问题分解为若干个子问题，并且通过每次选择当前最优解来得到整体最优解的情况。
贪心算法的基本步骤贪心算法的基本步骤可以总结为以下几个方面：1.确定问题的解空间，并找到问题的最优解。
贪心算法通常通过穷举法或者利用问题的特殊性质来确定解空间。
2.制定贪心策略。
贪心算法的核心是确定每一步选择的贪心策略，即选择当前最优解。
3.确定贪心策略的正确性。
贪心算法的一个关键问题是如何证明贪心策略的正确性。
可以通过数学证明、反证法或者举反例等方式来进行证明。
4.实现贪心算法。
将贪心策略转化为实际可执行的算法步骤，编写代码来求解问题。
贪心算法实验结果分析在本次实验中，我使用贪心算法解决了一个经典问题：找零钱问题（Change-Making Problem）。
给定一定面额的硬币和需找的金额，我们的目标是使用最少的硬币来完成找零钱。
贪心算法的思路是每次选择面额最大的硬币进行找零。
实验设计1.实验输入：我设计了多组输入来测试贪心算法的性能。
每组输入包括一个需找的金额和一个硬币集合。
2.实验输出：对于每组输入，贪心算法输出一个最优的硬币找零方案，以及使用的硬币数量。
3.实验评价：我使用了实际需找金额与贪心算法计算得到的找零金额的差值来评估算法的准确性，并统计了算法的时间复杂度。
实验结果从多组实验结果中可以观察到，贪心算法在大部分情况下给出了正确的找零金额，并且算法的时间复杂度较低。
结果分析贪心算法在找零钱问题中的应用是合理的。
每次选择面额最大的硬币进行找零，可以快速接近最优解，并且相对其他算法具有较低的时间复杂度。
数据优化算法实验报告
数据优化算法实验报告1. 引言数据优化算法是在处理大规模数据时的重要工具。
随着数据量的增大和计算需求的增加，需要寻找更加高效的算法来处理和优化数据。
本实验旨在研究并比较两种常见的数据优化算法：贪心算法和动态规划算法。
通过实验比较它们在不同场景下的优化效果和性能。
2. 贪心算法贪心算法是一种简单而直观的算法。
其基本思想是每次选择局部最优解，并希望通过局部最优解的组合来达到全局最优解。
贪心算法能够在很短的时间内找到一个近似最优解，但不能保证一定得到最优解。
本实验中，我们以背包问题为例，使用贪心算法进行优化。
背包问题是在给定背包容量的情况下，选择一些物品放入背包，使得放入背包的物品总价值最大化。
贪心算法的核心思想是每次选择单位重量价值最大的物品放入背包。
实验结果表明，贪心算法在小规模问题上有着较好的效果，但在大规模问题上有可能得不到最优解。
这是因为贪心算法只考虑了当前局部最优解，没有考虑到全局最优解的可能性。
3. 动态规划算法动态规划算法是一种通过分别解决子问题并将解决方案合并来解决复杂问题的方法。
与贪心算法相比，动态规划算法更加追求全局最优解，但也需要更多的计算时间和空间。
同样以背包问题为例，使用动态规划算法进行优化。
动态规划算法的核心思想是将问题分解为子问题，通过递归地求解子问题的最优解，最后合并子问题的解来获得全局最优解。
在背包问题中，动态规划算法采用二维数组来存储每个子问题的最优解。
实验结果表明，动态规划算法能够在较短的时间内得到全局最优解，但对于大规模问题，算法的时间和空间复杂度会显著增加。
4. 实验对比和讨论通过实验对比，我们可以看到贪心算法和动态规划算法在不同场景下的优化效果和性能有所不同。
对于小规模问题，贪心算法能够快速计算得到一个近似最优解，并能在较短的时间内完成计算。
然而，贪心算法不能保证一定得到全局最优解，可能会得到次优解。
对于大规模问题，动态规划算法能够在较短的时间内得到全局最优解。
《算法设计与分析》课程实验报告 (贪心算法(一))
《算法设计与分析》课程实验报告实验序号：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算法：从任意一个顶点开始，逐步添加边，直到所有顶点都被包含在生成树中。
贪心算法-找零问题 实验报告
实验三课程名称：算法设计与实现实验名称：贪心算法-找零问题实验日期：2019年5月2日仪器编号：007班级：数媒0000班姓名：郝仁学号0000000000实验内容假设零钱系统的币值是{1，p,p^2,……，p^n},p>1,且每个钱币的重量都等于1，设计一个最坏情况下时间复杂度最低的算法，使得对任何钱数y，该算法得到的零钱个数最少，说明算法的主要设计思想，证明它的正确性，并给出最坏情况下的时间复杂度。
实验分析引理1（离散数学其及应用3.1.4）：若n是正整数，则用25美分、10美分、5美分和1美分等尽可能少的硬币找出的n美分零钱中，至多有2个10美分、至多有1个5美分、至多有4个1美分硬币，而不能有2个10美分和1个5美分硬币。
用10美分、5美分和1美分硬币找出的零钱不能超过24美分。
证明如果有超过规定数目的各种类型的硬币，就可以用等值的数目更少的硬币来替换。
注意，如果有3个10美分硬币，就可以换成1个25美分和1个5美分硬币；如果有2个5美分硬币，就可以换成1个10美分硬币；如果有5个1美分硬币，就可以换成1个5美分硬币；如果有2个10美分和1个5美分硬币，就可以换成1个25美分硬币。
由于至多可以有2个10美分、1个5美分和4个1美分硬币，而不能有2个10美分和1个5美分硬币，所以当用尽可能少的硬币找n美分零钱时，24美分就是用10美分、5美分和1美分硬币能找出的最大值。
假设存在正整数n，使得有办法将25美分、10美分、5美分和1美分硬币用少于贪心算法所求出的硬币去找n美分零钱。
首先注意，在这种找n美分零钱的最优方式中使用25美分硬币的个数q′，一定等于贪心算法所用25美分硬币的个数。
为说明这一点，注意贪心算法使用尽可能多的25美分硬币，所以q′≤q。
但是q′也不能小于q。
假如q′小于q，需要在这种最优方式中用10美分、5美分和1美分硬币至少找出25美分零钱。
而根据引理1，这是不可能的。
贪心算法_实验报告
贪心算法_实验报告一、设计分析●问题描述：键盘输入一个高精度的正整数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);三、测试用例四、实验总结加深了对贪心算法的理解与运用。
所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。
这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。
动态规划算法通常以自底向上的方式解各子问题，而贪心算法则通常以自顶向下的方式进行，以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为规模更小的子问题。
贪心算法设计实验报告
A
B
C
D
E
F
G
0
0
0
0
1
0
0
0
对表进行维护（维护后仍同上表，因为还没有两个集合合并）
0
A
B
C
D
E
F
G
0
0
0
0
1
0
0
0
C，选择第二条边 C----E （修改上表）
0
A
B
C
D
E
F
G
0
0
0
0
1
3
0
0
对上表进行维护（任同上表，因为还没有两个集合合并）
0
A
B
C
D
E
F
G
0
0
0
0
1
3
0
0
D，选择第三条边（ D-----F ） (根据条件 DF 两点不再同一集合，改边可选 ) 然后就合并 DF 两点所在的集合 D 的前去是 1，即 A 标记为 0， E 的标记也为 0，合并因为 6>1 所以表修改如下
Edge* selectionsort(Edge *array,int n)// 选择排序（对边按权重由高到低排序） {
int i,j,min,temp; for(i=0;i<n;i++) {
min=i; for(j=i+1;j<n;j++)
if(array[min].weight>array[j].weight) min=j;
在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直至森林中
只有一棵树，也即子图中含有
实验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);}实验结果实验体会本次实验是用贪心法求解哈夫曼编码,其实贪心法和哈夫曼树的原理是一样的,每次将集合中两个权值最小的二叉树合并成一棵新二叉树，每次选择两个权值最小的二叉树时，规定了较小的为左子树。
贪心算法实验报告
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人。
贪心算法实验报告(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）算法源码/**********************单源最短路径问题。
贪心算法实验
实验三贪心算法的应用一、实验目的 (2)二、实验内容 (2)2.1 会场安排问题 (2)2.2 程序存储问题 (2)2.3 汽车加油问题 (2)三．算法设计 (3)3.1会场安排问题 (3)3.1.1算法描述 (3)3.1.2 函数设计 (3)3.2程序存储问题 (4)3.1.1算法描述 (4)3.1.2 函数设计 (4)3.3汽车加油问题 (4)3.1.1算法描述 (4)3.1.2 函数设计 (4)四.程序调试及运行结果分析 (5)4.1会场安排问题 (5)4.2程序存储问题 (5)4.3汽车加油问题 (5)五.实验总结 (6)六．附录 (6)6.1会场安排问题 (6)6.2程序存储问题 (6)6.3汽车加油问题 (7)一、实验目的1．掌握贪心算法的基本概念和两个基本要素2．熟练掌握贪心算法解决问题的基本步骤。
3．学会利用贪心算法解决实际问题。
二、实验内容2.1 会场安排问题假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。
设计一个有效的贪心算法来进行安排。
试编程实现对于给定的k个待安排活动，计算使用的最少会场。
输入数据中，第一行是k的值，接下来的k行中，每行有2个正整数，分别表示k个待安排活动的开始时间和结束时间，时间以0点开始的分钟计。
输出为最少的会场数。
2.2 程序存储问题设有n个程序{1,2,3,…,n}要存放在长度为L的磁带上。
程序i存放在磁带上的长度是li,1≤i≤n。
要求确定这n个程序在磁带上的一个存储方案，使得能够在磁带上存储尽可能多的程序。
输入数据中，第一行是2个正整数，分别表示程序文件个数和磁带长度L。
接下来的1行中，有n个正整数，表示程序存放在磁带上的长度。
输出为最多可以存储的程序个数。
2.3 汽车加油问题一辆汽车加满油后,可行使n千米。
旅途中有若干个加油站。
若要使沿途加油次数最少,设计一个有效算法，对于给定的n和k个加油站位置，指出应在哪些加油站停靠加油才能使加油次数最少。
算法贪婪法实验报告
一、实验背景与目的随着计算机科学的不断发展，算法在解决实际问题中的应用日益广泛。
贪婪法作为一种重要的算法设计方法，在许多领域都得到了广泛应用。
本实验旨在通过实际案例，让学生了解和掌握贪婪法的基本原理、设计方法以及应用场景。
二、实验内容与步骤1. 实验内容本实验选取两个经典问题作为案例，分别是“最小生成树”和“硬币找零问题”，分别使用贪婪法进行求解。
2. 实验步骤（1）最小生成树问题① 确定问题背景：给定一个无向连通图，要求找到一棵包含图中所有顶点的最小生成树。
② 设计贪心算法：以图中的任意一个顶点为根，选择与根顶点距离最短的顶点作为下一个顶点，并添加到最小生成树中。
重复此步骤，直到所有顶点都被包含在最小生成树中。
③ 实现代码：使用C++语言实现贪心算法，计算最小生成树的总权值。
（2）硬币找零问题① 确定问题背景：给定一系列不同面值的硬币和找零金额，要求找出最少硬币数来凑齐该金额。
② 设计贪心算法：从面值最大的硬币开始，尽可能地使用硬币凑齐金额。
若当前硬币面值大于剩余金额，则尝试使用面值较小的硬币，重复此步骤，直到金额为0。
③ 实现代码：使用C++语言实现贪心算法，计算最少硬币数。
三、实验结果与分析1. 最小生成树问题实验结果表明，使用贪心法求解最小生成树问题时，能够得到一棵包含图中所有顶点的最小生成树。
在实验过程中，我们发现贪心法在求解最小生成树问题时，存在一定的局限性。
例如，当图中存在多个顶点距离相同的情况下，贪心法可能会得到次优解。
2. 硬币找零问题实验结果表明，使用贪心法求解硬币找零问题时，能够得到最少硬币数来凑齐给定金额。
在实验过程中，我们发现贪心法在求解硬币找零问题时，具有较好的性能。
四、实验总结与讨论1. 贪婪法的基本原理贪婪法是一种在每一步都选择当前最优解的算法。
它通过在每一步选择局部最优解，期望得到全局最优解。
然而，贪婪法并不保证能够得到全局最优解，因为它的决策过程是基于局部最优解的。
贪心算法实现背包问题算法设计与分析实验报告
算法设计与分析实验报告实验名称 贪心算法实现背包问题 评分 实验日期 年 月 日 指导教师 姓名 专业班级 学号一.实验要求1. 优化问题有n个输入，而它的解就由这n个输入满足某些事先给定的约束条件的某个子集组 成，而把满足约束条件的子集称为该问题的可行解。
可行解一般来说是不唯一的。
那些使目标函数取极值(极大或极小)的可行解，称为最优解。
2.贪心法求优化问题算法思想：在贪心算法中采用逐步构造最优解的方法。
在每个阶段，都作出一个看上去最优的决策（在一定的标准下）。
决策一旦作出，就不可再更改。
作出贪心决策的依据称为贪心准则（greedy criterion）。
3.一般方法1）根据题意，选取一种量度标准。
2）按这种量度标准对这n个输入排序3）依次选择输入量加入部分解中。
如果当前这个输入量的加入，不满足约束条件，则不把此输入加到这部分解中。
procedure GREEDY(A，n) /*贪心法一般控制流程*///A(1：n)包含n个输入//solutions←φ //将解向量solution初始化为空／for i←1 to n dox←SELECT(A)if FEASIBLE(solution，x)then solutions←UNION(solution，x)endifrepeatreturn(solution)end GREEDY4. 实现典型的贪心算法的编程与上机实验，验证算法的时间复杂性函数。
二.实验内容1. 编程实现背包问题贪心算法。
通过具体算法理解如何通过局部最优实现全局最优，并验证算法的时间复杂性。
2.输入5个的图的邻接矩阵，程序加入统计prim算法访问图的节点数和边数的语句。
3.将统计数与复杂性函数所计算比较次数比较，用表格列出比较结果，给出文字分析。
三.程序算法1. 背包问题的贪心算法procedure KNAPSACK(P，W，M，X，n)//P(1：n)和W(1；n)分别含有按P(i)/W(i)≥P(i+1)/W(i+1)排序的n件物品的效益值和重量。
贪心算法实验报告
贪心算法实验报告贪心算法实验报告引言：贪心算法是一种常用的算法设计思想，它在求解最优化问题中具有重要的应用价值。
本实验报告旨在介绍贪心算法的基本原理、应用场景以及实验结果，并通过实例加以说明。
一、贪心算法的基本原理贪心算法是一种以局部最优解为基础，逐步构建全局最优解的算法。
其基本原理是在每一步选择中都采取当前状态下最优的选择，而不考虑之后的结果。
贪心算法通常具备以下特点：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)。
福建工程学院计算机与信息科学系实验报告12345篇二：北邮算法作业贪心算法实验报告第三次算法作业（贪心算法）姓名：吴迪班级：08211312学号：08211488班内序号 15 摘要：本文为完成作业problem1，problem3，problem4，problem5的四道贪心算法题。
备注：所有后缀为_ex的可执行文件为文件输入输出模式的程序，比如problem1_ex.exe （所有算法实现代码承诺为本人自己编写并且截图为实际有效截图，所有程序均通过dev-c++编译器实际测试可以运行）problem 1 特殊的01背包（原算法分析题4-3）问题描述：01背包是在n件物品取出若干件放在空间为c的背包里，每件物品的体积为w1，w2??wn，与之相对应的价值为p1,p2??pn，并取得最大价值。
普通的01背包中物品的重量和价值没有明确的关系，这里定义一种特殊的01背包：向背包中放入的物品的价值和体积成反比，也就是价值越高，体积越小，注意这里物品价值和体积的乘积并不是固定值。
例如：如下的物品满足这个“特殊的01背包”,5件物品: 物品1,价值 v=6,体积w=20 物品2,价值 v=1,体积w=60 物品3,价值 v=20,体积w=3 物品4,价值 v=15,体积w=15 物品5,价值 v=99,体积w=1 假如我有一个容量为c的背包,c=20，那么选择物品3、4、5可以获得最大价值134。
输入：首先是一个整数t,代表测试数据的组数。
每组测试数据首先是两个正整数n和c，n代表物品的个数，c代表背包的最大容积。
然后有n行整数，每行有两个整数，分别代表物品的价值v和体积w。
t的范围是(1-100),n的范围是(1-100000),c、v、w的范围不超过四字节的int型。
输出：首先输出测试数据的组号，例如第一组的组号为“case 1:”，占一行。
然后是一个整数，代表可以取得的最大价值，占一行。
sample input:55 206 201 6020 315 1599 1 1 1100 100 5 1092 17101 1093 18109 387 26 10 2296 1396 1889 17106 171 4086 2783 3178 31106 7 68 46 15 1954 55103 782 3375 3599 1094 2153 5695 1691 2039 6982 2854 54110 242 6765 46 sample output:case 1:134case 2: case 3:109case 4:212case 5:312 问题分析:本题是特殊的01背包问题，由于其价值和重量的反比规律易证明贪婪算法的有效性，故本题可以采用贪心算法求解，即每次优选最轻物品也是最大价值物品。
源代码：（仅附文件输入输出版本，标准输入输出版本见cpp代码文件）#include<iostream>#include<fstream>using namespace std;int greedy_calculate(int* v,int* w,const int n,const int c); int main(){//input int t; //test group num 1-100 int n; //object num 1-100000 int c; //capacityint *v;int *w;fstream in;fstream out;in.open(problem1_input.txt,ios::in); out.open(problem1_output.txt,ios::out); in >> t; if(t>100||t<1)out<<error input of t!<<endl; for(int i=0;i<t;i++){in >> n;if(n>100000||n<1)out<<error input of n!<<endl; in >> c; if(c<=0)out<<error input of c!<<endl; v=new int [n]; w=new int [n];for(int j=0;j<n;j++){in >> v[j];in >> w[j];} //outputout<<case <<i<<:<<endl; out<<greedy_calculate(v,w,n,c)<<endl; //safetydelete v;delete w;}in.close();out.close();system(pause);return 0;}int greedy_calculate(int* v,int* w,const int n,const int c) { unsigned int least_weight=-1; int lw_num=0; int count=0;int total_value=0;int total_weight=0;bool *x;x=new bool [n];for(int i=0;i<n;i++){x[i]=0;}while(total_weight<=c&&count<n){ least_weight=-1;for(int i=0;i<n;i++){if(x[i]==0){if(w[i]<least_weight){least_weight=w[i];lw_num=i; } }}x[lw_num]=1;total_value+=v[lw_num];total_weight+=w[lw_num];count++;}if(total_weight>c){total_value-=v[lw_num];total_weight-=w[lw_num]; } delete x;return total_value;}运行截图篇三：算法实验报告贵州大学计算机科学与技术学院计算机科学与技术系上机实验报告贵州大学计算机科学与技术学院计算机科学与技术系上机实验报告篇四：贪心算法解汽车加油问题实验报告一、实验名称：用贪心算法、回溯算法、动态规划等解决汽车加油次数最少问题。
二、实验目的：课程设计是《计算机算法与设计》课程不可缺少的重要实践性环节。
通过实践教学，要达到以下目的：（1）使学生掌握线性表、栈、队列、串、树、二叉树、图、集合等各种典型抽象数据类型的数学模型及其所支持基本运算的实现方法；（2）使学生掌握以抽象数据类型为模块的面向对象程序设计方法；（3）使学生提高对实际问题的分析、设计和实现能力；（4）为学生后续课程的学习及课程设计打下坚实的实践基础。
三、使用的策略：贪心算法、回溯算法等。
四、实验内容：（一）问题描述一辆汽车加满油后可以行驶n千米。
旅途中有若干个加油站。
指出若要使沿途的加油次数最少，设计一个有效的算法，指出应在那些加油站停靠加油。
给出n，并以数组的形式给出加油站的个数及相邻距离，指出若要使沿途的加油次数最少，设计一个有效的算法，指出应在那些加油站停靠加油。
要求：算法执行的速度越快越好。
（二）问题分析（前提行驶前车里加满油）对于这个问题我们有以下几种情况：设加油次数为k，每个加油站间距离为a[i]；i=0，1，2，3……n1.始点到终点的距离小于ｎ，则加油次数k=0；2.始点到终点的距离大于n，a 加油站间的距离相等，即ａ[i]=a[j]=l=n，则加油次数最少k=n；b 加油站间的距离相等，即ａ[i]=a[j]=l>n，则不可能到达终点；c 加油站间的距离相等，即ａ[i]=a[j]=l<n，则加油次数k=n/n(n%n==0)或k=[n/n]+1(n%n！=0)；d 加油站间的距离不相等，即ａ[i]！=a[j]，则加油次数k通过以下算法求解。
（三）算法描述1.贪心算法解决方案贪心算法的基本思想该题目求加油最少次数，即求最优解的问题，可分成几个步骤，一般来说，每个步骤的最优解不一定是整个问题的最优解，然而对于有些问题，局部贪心可以得到全局的最优解。
贪心算法将问题的求解过程看作是一系列选择，从问题的某一个初始解出发，向给定目标推进。
推进的每一阶段不是依据某一个固定的递推式，而是在每一个阶段都看上去是一个最优的决策（在一定的标准下）。
不断地将问题实例归纳为更小的相似的子问题，并期望做出的局部最优的选择产生一个全局得最优解。
贪心算法的适用的问题贪心算法适用的问题必须满足两个属性：（１）贪心性质：整体的最优解可通过一系列局部最优解达到，并且每次的选择可以依赖以前做出的选择，但不能依赖于以后的选择。
（２）最优子结构：问题的整体最优解包含着它的子问题的最优解。
贪心算法的基本步骤（１）分解：将原问题分解为若干相互独立的阶段。
（２）解决：对于每一个阶段求局部的最优解。
（３）合并：将各个阶段的解合并为原问题的解。
[问题分析] 由于汽车是由始向终点方向开的,我们最大的麻烦就是不知道在哪个加油站加油可以使我们既可以到达终点又可以使我们加油次数最少。
提出问题是解决的开始.为了着手解决遇到的困难,取得最优方案。
我们可以假设不到万不得已我们不加油，即除非我们油箱里的油不足以开到下一个加油站，我们才加一次油。
在局部找到一个最优的解。
却每加一次油我们可以看作是一个新的起点，用相同的递归方法进行下去。
最终将各个阶段的最优解合并为原问题的解得到我们原问题的求解。
加油站贪心算法设计（c）：//肖萌的算法加油站问题贪心算法#include<iostream>using namespace std;int main(){int i,j,n,k,l[10],c=0,m=0; bool a[10];cout<<请输入加满油后可行驶的距离（km）： ; cin>>n;cout<<请输入途中所经的加油站个数： ; cin>>k;cout<<请输入每相邻两个加油站之间的距离： <<endl; for(i=0;i<=k;i++)cin>>l[i];for(i=0;i<=k;i++)a[i]=false;for(j=0;j<=k;j++){m+=l[j];if(m+l[j+1]>=7){a[j+1]=true; m=0;}}cout<<在第 ;for(int s=0;s<=k;s++)if(a[s]==true){c++;cout<<s<< ;}cout<<个加油站加油了! ^_^<<endl; cout<<最少加油次数为： <<c<<endl; return 0; }贪心算法正确性证明：贪心选择性质所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。