实验三贪心算法应用

实验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个。

贪心算法在优化问题中的运用

贪心算法在优化问题中的运用贪心算法（Greedy Algorithm）是一种常用的算法思想，它在解决一些优化问题时具有很高的效率和实用性。

贪心算法的核心思想是每一步都选择当前状态下最优的解决方案，以期望最终能够得到全局最优解。

在实际应用中，贪心算法常常被用来解决一些最优化问题，如最短路径问题、背包问题、任务调度等。

本文将介绍贪心算法在优化问题中的运用，并通过具体案例来说明其应用场景和解决方法。

一、贪心算法的基本原理贪心算法是一种在每一步选择当前状态下最优解决方案的算法思想。

它与动态规划不同，贪心算法并不会保存之前的计算结果，而是根据当前状态做出最优选择。

贪心算法的优势在于简单、高效，适用于一些特定类型的问题。

贪心算法的基本原理可以总结为以下几点：1. 每一步都选择当前状态下的最优解决方案；2. 不考虑未来的结果，只关注当前状态的最优选择；3. 最终期望通过每一步的最优选择达到全局最优解。

二、贪心算法在优化问题中的应用1. 最短路径问题最短路径问题是图论中的经典问题，贪心算法可以用来解决一些简单的最短路径问题。

例如，在无权图中，从起点到终点的最短路径可以通过贪心算法来求解，每次选择距离最近的节点作为下一步的目标节点，直到到达终点为止。

2. 背包问题背包问题是一个经典的优化问题，贪心算法可以用来解决一些特定类型的背包问题。

例如，在分数背包问题中，每种物品可以取任意比例，贪心算法可以按照单位价值最高的顺序选择物品放入背包，直到背包装满为止。

3. 任务调度问题任务调度问题是一个常见的优化问题，贪心算法可以用来解决一些简单的任务调度问题。

例如，在单处理器任务调度中，每个任务有一个开始时间和结束时间，贪心算法可以按照结束时间的先后顺序对任务进行调度，以最大化处理器的利用率。

三、案例分析：活动选择问题活动选择问题是一个经典的优化问题，通过贪心算法可以高效地解决。

问题描述如下：假设有n个活动，每个活动都有一个开始时间和结束时间，活动之间不能交叉进行，问如何安排活动才能使参加的活动数量最多。

贪心算法原理及应用

贪心算法原理及应用随着人工智能技术的不断发展，算法的种类也越来越多，其中贪心算法作为一种最基础的算法，也在不断优化和升级。

本文将简要介绍贪心算法原理及其应用，探讨贪心算法的优劣和适用场景。

一、贪心算法原理贪心算法是一种常见的优化算法，它的基本思想是：在每一步选择中都采取当前状态下最优的选择，从而希望最终得到全局最优的解。

贪心算法在每一步选择中都依赖于以前的选择结果，但不依赖于将来的选择结果。

这种贪心选择性质是该算法能达到最终全局最优解的保证。

然而，即使每个局部最优的选择都是正确的，但最终的全局最优解并不一定会得到，因此贪心算法不一定能得到全局最优解，但是在实际问题中，贪心算法通常可以得到非常接近最优解的结果。

二、贪心算法应用1.最小生成树最小生成树是图论中的一个经典算法问题，它可以用贪心算法来解决。

在给定一个带权无向图时，我们需要找到一棵生成树，使得生成树所有边的权值之和最小。

Prim算法和Kruskal算法都是基于这一思想建立的。

2.背包问题背包问题是一种经典的动态规划问题，也可以用贪心算法来解决。

在背包问题中，我们需要找到一种最佳的方案，使得放入背包的物品的总价值最大。

3.活动安排在一组活动中，每个活动都有一个开始时间和结束时间。

如何安排这些活动，使得可以安排的最多？可以用贪心算法进行解决。

三、贪心算法的优劣1.优点优点是：简单，易于实现；对于一些问题可以快速得到答案。

2.缺点缺点是：贪心算法不能保证得到全局最优解，只能得到最终结果接近最优解的结果。

在一些问题中会出现无解的情况。

此外，贪心算法需要根据实际问题进行调整，否则可能会得到错误的答案。

3.适用场景对于一些特殊的问题，贪心算法通常可以得到非常好的效果。

例如上文提到的最小生成树、背包问题和活动安排等等。

在这些问题中，贪心算法可以得到接近最优解的结果。

但是，在一些问题中，贪心算法的结果会偏离真实结果。

四、结语贪心算法是一种简单而实用的算法，它在很多实际问题中都有广泛的应用。

贪心算法设计与应用

实验报告课程算法设计与分析实验实验名称贪心算法设计与应用第 1 页一、实验目的理解贪心算法的基本原理，掌握贪心算法设计的基本方法及其应用；二、实验内容(一)Huffman编码和译码问题：1．问题描述给定n个字符在文件中的出现频率，利用Huffman树进行Huffman编码和译码。

设计一个程序实现：1.输入含n(n<=10)个字符的字符集S以及S中各个字符在文件中的出现频率，建立相应的Huffman树，求出S中各个字符的Huffman编码。

2.输入一个由S中的字符组成的序列L，求L的Huffman 编码。

3. 输入一个二进制位串B，对B进行Huffman译码，输出对应的字符序列；若不能译码，则输出无解信息。

提示：对应10 个字符的Huffman树的节点个数<211。

2．测试数据Inputn=5字符集合S={a, b, c, d, e},对应的频率分别为a: 20b: 7c: 10d: 4e: 18字符序列L=ebcca二进制位串B=01100111010010OutputS中各个字符的Huffman编码：（设Huffman树中左孩子的权<=右孩子的权）a: 11b: 010c: 00d: 011e: 10L的Huffman 编码：10010000011B对应的字符序列： dcaeeb若输入的B=01111101001，则无解(二) 加油问题（Problem Set 1702）：1.问题描述一个旅行家想驾驶汽车从城市A到城市B（设出发时油箱是空的）。

给定两个城市之间的距离dis、汽车油箱的容量c、每升汽油能行驶的距离d、沿途油站数n、油站i离出发点的距离d[i]以及该站每升汽油的价格p[i],i=1,2,…,n。

设d[1]=0<d[2]<…<d[n]。

要花最少的油费从城市A到城市B，在每个加油站应加多少油，最少花费为多少？2.具体要求Input输入的第一行是一个正整数k，表示测试例个数。

中原工学院贪心算法的应用

实验三贪心算法的应用一、实验目的1．掌握贪心算法的基本概念和两个基本要素2．熟练掌握贪心算法解决问题的基本步骤。

3．学会利用贪心算法解决实际问题。

二、实验内容1.问题描述：题目三：程序存储问题设有n个程序{1,2,3,…,n}要存放在长度为L的磁带上。

程序i存放在磁带,1≤i≤n。

要求确定这n个程序在磁带上的一个存储方案，使得能上的长度是li够在磁带上存储尽可能多的程序。

输入数据中，第一行是2个正整数，分别表示程序文件个数和磁带长度L。

接下来的1行中，有n个正整数，表示程序存放在磁带上的长度。

输出为最多可以存储的程序个数。

输入数据示例6 502 3 13 8 80 20输出数据5题目四：汽车加油问题一辆汽车加满油后,可行使n千米。

旅途中有若干个加油站。

若要使沿途加油次数最少,设计一个有效算法，对于给定的n和k个加油站位置，指出应在哪些加油站停靠加油才能使加油次数最少。

输入数据中，第一行有2个正整数，分别表示汽车加满油后可行驶n千米，且旅途中有k个加油站。

接下来的1行中，有k+1个整数，表示第k个加油站与第k-1个加油站之间的距离。

第0个加油站表示出发地，汽车已加满油。

第k+1个加油站表示目的地。

输出为最少的加油次数，如果无法到达目的地，则输出“No Solution”。

实验提示：把两加油站的距离放在数组中，a[1..k]表示从起始位置开始跑，经过k个加油站，a[i]表示第i－1个加油站到第i个加油站的距离。

汽车在运行的过程中如果能跑到下一个站则不加油，否则要加油。

输入数据示例7 71 2 3 4 5 1 6 6输出数据42.算法设计：题目三：程序存储问题n为程序个数，L为磁带的长度，定义数组len[n]存储n个程序的长度；调用库函数sort（len，len+n）对程序的长度从小到大排序；函数Calculate（）计算磁带最多可存储的程序数，采用while循环依次对排序后的程序长度进行累加，用count计算程序个数，用sum计算程序累加长度（初始count=0，sum=0）：sum=sum+len[i]；若sum<=L，count加1，否则count为所求；count=n时循环结束；若while循环结束时仍有sum<=L，则n为所求。

算法实验报告贪心

一、实验背景贪心算法是一种在每一步选择中都采取当前状态下最好或最优的选择，从而希望导致结果是全局最好或最优的算法策略。

贪心算法并不保证能获得最优解，但往往能获得较好的近似解。

在许多实际应用中，贪心算法因其简单、高效的特点而被广泛应用。

本实验旨在通过编写贪心算法程序，解决经典的最小生成树问题，并分析贪心算法的优缺点。

二、实验目的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. 认真听讲，服从安排，独立思考并完成实验。

实验设备与器材硬件：PC机软件：C++或Java等编程环境实验原理有一类问题是要从所有的允许解中求出最优解，其策略之一是“贪心法”，即逐次实施“贪心选择”：在每个选择步骤上做出的选择都是当前状态下最优的。

贪心选择依赖于在此之前所做出的选择，但不依赖于后续步骤所需要的选择，即不依赖于后续待求解子问题。

显然，这种选择方法是局部最优的，但不是从问题求解的整体考虑进行选择，因此不能保证最后所得一定是最优解。

贪心法是求解问题的一种有效方法，所得到的结果如果不是最优的，通常也是近似最优的。

实验内容以下几个问题选做一项：1. 用贪心法实现带有期限作业排序的快速算法应用贪心设计策略来解决操作系统中单机、无资源约束且每个作业可在等量时间内完成的作业调度问题。

假定只能在一台机器上处理N个作业，每个作业均可在单位时间内完成；又假定每个作业i都有一个截止期限di>0（它是整数），当且仅当作业i在它的期限截止以前被完成时，则获得pi的效益。

这个问题的一个可行解是这N个作业的一个子集合J，J中的每个作业都能在各自的截止期限之前完成。

可行解的效益值是J中这些作业的效益之和，即Σp。

具有最大效益值的可行解就是最优解。

2. 实现K元归并树贪心算法两个分别包含n个和m个记录的已分类文件可以在O（n+m）时间内归并在一起而得到一个分类文件。

当要把两个以上的已分类文件归并在一起时，可以通过成对地重复归并已分类的文件来完成。

例如：假定X1,X2,X3,X4是要归并的文件，则可以首先把X1和X2归并成文件Y1，然后将Y1和X3归并成Y2，最后将Y2和X4归并，从而得到想要的分类文件；也可以先把X1和X2归并成Y1，然后将X3和X4归并成Y2，最后归并Y1和Y2而得到想要的分类文件。

实验项目名称∶用贪心算法解单源最短路径问题

实验项目名称：用贪心算法解单源最短路径问题一、实验目的：明确单源最短路径问题的概念；利用贪心算法解决单源最短路径问题；并通过本例熟悉贪心算法在程序设计中的应用方法。

二、实验原理：贪心算法原理：在贪婪算法（greedy method）中采用逐步构造最优解的方法。

在每个阶段，都作出一个看上去最优的决策（在一定的标准下）。

决策一旦作出，就不可再更改。

作出贪婪决策的依据称为贪婪准则（greedy criterion）。

三、实验内容与步骤：问题描述：求网（带权有向图）中从一个顶点到其余各顶点间的最短路径。

一个有向图G，它的每条边都有一个非负的权值c[i,j]，“路径长度”就是所经过的所有边的权值之和。

对于源点需要找出从源点出发到达其他所有结点的最短路径。

基本思想分步求出最短路径，每一步产生一个到达新目的顶点的最短路径。

下一步所能达到的目的顶点通过如下贪婪准则选取：在未产生最短路径的顶点中，选择路径最短的目的顶点。

设置顶点集合S并不断作贪心选择来扩充这个集合。

当且仅当顶点到该顶点的最短路径已知时该顶点属于集合S。

初始时S中只含源。

设u为G中一顶点，我们把从源点到u 且中间仅经过集合S中的顶点的路称为从源到u特殊路径，并把这个特殊路径记录下来（例如程序中的dist[i]）。

每次从V-S选出具有最短特殊路径长度的顶点u，将u添加到S中，同时对特殊路径长度进行必要的修改。

一旦V=S，就得到从源到其他所有顶点的最短路径，也就得到问题的解。

如上图所示，编程实现求从任一顶点出发到其它顶点的最短路径长度。

如下：please input the first number:00->0:00->1:450->2:100->3:250->4:450->5:50please input the first number:11->0:351->1:01->2:151->3:181->4:101->5:15please input the first number:22->0:202->1:352->2:02->3:152->4:452->5:50please input the first number:33->0:553->1:203->2:353->3:03->4:303->5:35please input the first number:44->0:634->1:284->2:434->3:84->4:04->5:5please input the first number:55->0:585->1:235->2:385->3:35->4:335->5:0四实验结果与结论自己总结五实验中遇到的问题及解决办法自己总结六实验结论自己总结参考程序段如下#include<stdio.h>#define MAX 10000int main(){int cost[6][6]={{0,50,10,MAX,45,MAX},{MAX,0,15,MAX,10,MAX},{20,MAX,0,15,MAX,MAX},{MAX,20,MAX,0,35,MAX},{MAX,MAX,MAX,30,0,5},{MAX,MAX,MAX,3,MAX,0}};int s[6],dist[6];int n;int i,j,k,m,min;clrscr();printf("please input the first number:");while(scanf("%d",&n)&&n>=0&&n<6){for(i=0;i<6;i++){s[i]=0;dist[i]=cost[n][i];}s[n]=1,dist[n]=0;for(j=1;j<6;j++){min=MAX;for(k=0;k<6;k++){if(s[k]==0&&min>dist[k]){min=dist[k];m=k;}}if(min==MAX)break;s[m]=1,dist[m]=min;for(k=0;k<6;k++){if(s[k]==0)dist[k]=(dist[k]<(dist[m]+cost[m][k]))?dist[k]:(dist[m]+cost[m ][k]);}}for(i=0;i<6;i++){if(dist[i]<MAX)printf("%d->%d:%d\n",n,i,dist[i]);}printf("please input the first number:");}}。

贪心算法实验报告

一、实验目的通过本次实验，使学生对贪心算法的概念、基本要素、设计步骤和策略有更深入的理解，掌握贪心算法的原理和应用，并能够运用贪心算法解决实际问题。

二、实验内容本次实验主要涉及以下两个问题：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人。

贪心算法的应用

贪心算法的应用贪心算法是一种经典的算法思想，它在解决一些优化问题时具有很高的效率和实用性。

本文将介绍贪心算法的原理和应用，并以实际场景为例，详细讲解贪心算法的实施过程。

一、贪心算法简介贪心算法是一种基于贪心策略的算法思想，即每一步都选择当前最优解，以期望最终能够达到全局最优解。

它的核心思想是通过不断地做出局部最优选择，从而达到全局最优。

贪心算法通常适用于满足“最有子结构性质”的问题，即通过局部最优解来推导出全局最优解。

二、贪心算法的应用场景贪心算法的应用非常广泛，以下将介绍几个常见的应用场景。

1. 零钱找零问题假设我们需要找零n元，而手上只有面额为1元、2元、5元的硬币若干。

为了找零的硬币数量最少，我们可以采用贪心算法的思想：每一步选择面额最大的硬币，再找零，直到找够n元为止。

2. 区间调度问题给定一个由n个区间组成的集合，每个区间都有一个起始时间和结束时间，我们的目标是在不重叠的前提下，尽量多地选择区间。

解决这个问题的贪心策略是选择结束时间最早的区间，再继续选择剩余区间中结束时间最早的区间，依次类推。

3. 最优装载问题假设有一批货物和一个固定容积的仓库，每个货物有自己的体积和价值。

我们的目标是在仓库容积有限的情况下，选择部分货物使得总价值最大化。

贪心算法可以通过按单位价值排序，每次选择价值最高的货物进行装载，直到仓库容量不足为止。

三、贪心算法的实施过程以区间调度问题为例，介绍贪心算法的实施过程。

1. 首先，将所有区间按照结束时间进行排序。

2. 初始化一个空的结果集res，将第一个区间加入res中。

3. 从第二个区间开始遍历，若当前区间的起始时间大于等于res中最后一个区间的结束时间，则将该区间加入res中。

4. 遍历完所有区间后，res中存放的就是最优解。

通过上述过程，我们可以得到最大化选择的不重叠区间集合，从而解决了区间调度问题。

四、贪心算法的优缺点贪心算法的优点是简单、高效，可以快速地得到一个近似最优解。

实验三贪心算法

实验三贪心算法一、实验目的与要求1、熟悉多机调度问题的算法；2、初步掌握贪心算法；二、实验题要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。

约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。

作业不能拆分成更小的子作业。

三、实验提示1、把作业按加工所用的时间从大到小排序2、如果作业数目比机器的数目少或相等，则直接把作业分配下去3、如果作业数目比机器的数目多，则每台机器上先分配一个作业，如下的作业分配时，是选那个表头上s最小的链表加入新作业。

# include <iostream># include <iomanip>using namespace std;typedef struct Job //作业{int ID;int time;}Job;typedef struct JobNode //作业链表的节点{int ID;int time;JobNode *next;}JobNode,*pJobNode;typedef struct Header //链表的表头{int s; //处理机上的时间；JobNode *next;}Header,pHeader;int main(){void QuickSort(Job *job,int left,int right); //将job时间排序void outSort(Job *job,int n); //输出排序void display(Header *M,int m); //输出每个每台机器处理的工作序号数int SelectMin(Header *M,int m); //分配作业时选取机器函数；void solve(Header *head,Job*job,int n,int m); //作业分配函数；int m,n;cout<<"\t\t《多机调度问题》\n";cout<<"请输入机器台数m:";cin>>m;Header *head=new Header [m]; //动态构建数组结构体，用于记录机器的作业时间；cout<<"请输入作业个数n:";cin>>n;Job *job=new Job [n]; //动态构建作业的数组结构体；cout<<"\n请按序号输入每个作业调度所需时间time：";for(int i=0;i<n;i++){cin>>job[i].time;job[i].ID=i;}QuickSort(job,0,n-1); //作业排序outSort(job,n); //输出排序solve(head,job,n,m); //作业分配display(head,m); //输出分配cout<<endl<<endl;return 0;}int SelectMin(Header* M,int m) //选择s最小的机器序号k;{int k=0;for(int i=1;i<m;i++){if(M[i].s<M[k].s)k=i; //k记录S最小的序号；}return k;}void QuickSort(Job *job,int left,int right) //小到大，排序{int middle=0,i=left,j=right;Job itemp;middle=job[(left+right)/2].time;do{while((job[i].time>middle)&&(i<right))i++;while((job[j].time<middle)&&(j>left))j--;if(i<=j){itemp=job[j];job[j]=job[i];job[i]=itemp;i++;j--;}}while(i<=j);if(left<j)QuickSort(job,left,j);if(right>i)QuickSort(job,i,right);}void display(Header *M,int m) //作业分配输出函数；{JobNode *p;for(int i=0;i<m;i++){cout<<"\n第"<<i<<"台机器上处理的工作序号：";if(M[i].next==0)continue;p=M[i].next;do{cout<<p->ID<<' ';p=p->next;}while(p!=0);}}void outSort(Job *job,int n) //作业时间由大到小排序后输出函数；{cout<<"\n按工作时间由大到小为:\n时间：\t";for(int i=0;i<n;i++)cout<<setw(4)<<job[i].time;cout<<"\n序号：\t";for( i=0;i<n;i++)cout<<setw(4)<<job[i].ID;}void solve(Header *head,Job*job,int n,int m) //作业分配函数；{int k;for(int i=0;i<m&&i<n;i++){JobNode *jobnode=new JobNode;jobnode->time=job[i].time;jobnode->ID=job[i].ID;jobnode->next=0;head[i].s=jobnode->time;head[i].next=jobnode;}if(i<=m) //n<m的情况续处理；{for(i;i<m;i++){head[i].s=0;head[i].next=0;}}if(n>m){for(i;i<n;i++){JobNode *p;JobNode *jobnode=new JobNode;jobnode->time=job[i].time;jobnode->ID=job[i].ID;jobnode->next=0;k=SelectMin(head,m);p=head[k].next;head[k].s+=jobnode->time;while(p->next!=0)p=p->next;p->next=jobnode;}}}运行结果：提高题一：用贪心算法求解最小生成树一、实验要求与目的1、熟悉贪心算法的基本原理与适用范围。

贪心算法实验报告(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）算法源码/**********************单源最短路径问题。

贪心算法及其应用doc资料

贪心算法及其应用湖州师范学院实验报告课程名称：算法实验三：贪心算法一、实验目的1、理解贪心算法的概念，掌握贪心算法的基本要素。

2、掌握设计贪心算法的一般步骤，针对具体问题，能应用贪心算法求解。

二、实验内容1、问题描述活动安排问题设有n个活动的集合E={1,2,…,n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。

每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi,且si <fi 。

如果选择了活动i，则它在半开时间区间[si, fi)内占用资源。

若区间[si, fi)与区间[sj, fj)不相交，则称活动i与活动j是相容的。

也就是说，当si≥fj或sj≥fi时，活动i与活动j相容。

2、数据输入：文件输入或键盘输入。

3、要求：1）完成上述两个问题中1个或全部，时间为 1 次课。

2）独立完成实验及实验报告。

三、实验步骤1、理解方法思想和问题要求。

2、采用编程语言实现题目要求。

3、上机输入和调试自己所写的程序。

4、附程序主要代码：2、活动规划问题#include<stdio.h>#include<iostream>#include<algorithm>using namespace std;struct node{int start;int end;} a[11111];bool cmp(node x,node y){if(x.end<y.end) return true;else if(x.end==y.end && x.start>y.start) return true; return false;}int main(){int n,i,j,ans,end;cin>>n;for(i=0;i<n;i++) cin>>a[i].start>>a[i].end;sort(a,a+n,cmp);ans=0;end=-1e9-100;for(i=0;i<n;i++) {if(a[i].start>=end) {ans++;end=a[i].end;}}cout<<ans<<endl;return 0;}5、实验结果：四、实验分析活动安排问题：结束时间越早的活动优先。

实验三贪心算法

实验三：贪心算法一、实验目的（1）理解贪心算法的基本思想；（2）熟悉多机调度问题的算法；（3）初步掌握贪心算法的应用。

二、实验环境微型计算机，WindowXP ， Visual C++6.0三、实验内容要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。

约定每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。

作业不能拆分成更小的子作业。

四、实验结果五、源代码#include <stdio.h>#define M 100void main(){int i,j,k,temp,m,n;int t[M]={2,14,4,16,6,5,3},p[M]={1,2,3,4,5,6,7},s[M],d[M]={0};m=3;n=7;for(i=0;i<7;i++)for(j=0;j<7-i;j++)if(t[j]<t[j+1]) //排序使t[]由大到小{temp=t[j];t[j]=t[j+1];t[j+1]=temp;temp=p[j]; //p[]始终和t[]一一对应p[j]=p[j+1];p[j+1]=temp;}for(i=0;i<m;i++) //求时间。

{s[i]=p[i];d[i]=t[i];}for(k=0;k<m;k++)printf(" %d",d[k]);printf("\n");for(i=m;i<n;i++){for(k=0;k<m-1;k++) //求最小。

{temp=d[k];if(temp>d[k+1]){temp=d[k+1];j=k+1;}}printf("这是最小下标的：%d\n",j);printf("最小的值：%d\n",temp);for(k=0;k<m;k++)printf(" %d",d[k]);printf("\n");//j=temp;s[j]=s[j]+p[i];d[j]=d[j]+t[i];}printf("\n");for(k=0;k<7;k++)printf(" %d",t[k]);printf("\n");for(k=0;k<7;k++)printf(" %d",p[k]);printf("\n");for(k=0;k<m;k++)printf(" %d",s[k]);printf("\n");for(k=0;k<m;k++)printf(" %d",d[k]);printf("\n");}。

贪心算法实验

贪心算法实验实验三贪心算法的应用 (1)一、实验目的 (1)二、实验内容 (1)三、实验步骤 (2)实验三贪心算法的应用一、实验目的1．掌握贪心算法的基本概念和两个基本要素2．熟练掌握贪心算法解决问题的基本步骤。

3．学会利用贪心算法解决实际问题。

二、实验内容1.问题描述：题目一：找钱问题一个顾客买了价值x元的商品（不考虑角、分），并将y元的钱交给售货员。

售货员希望用张数最少的钱币找给顾客。

要求：键盘输入x与y输出找钱总数，各种钱币的张数，若张数为0不必输出。

输入输出实例：题目二：删数问题键盘输入一个高精度的正整数N，去掉其中任意S个数字后剩下的数字按原左右次序将组成一个新的正整数。

编程对给定的N和S，寻找一种方案使得剩下的数字组成的新数最小。

输出应包括所去掉的数字的位置和组成的新的正整数(N不超过100位)。

要求：键盘输入正整数N与删除位数s输出删除后的最小新数以及删除的位数输入输出实例：题目三：分数表示问题设计一个算法，把一个真分数表示为最少埃及分数之和的形式。

所谓埃及分数是指分子为1的分数。

如7/8=1/2+1/3+1/24。

三、实验步骤1.理解算法思想和问题要求；2.编程实现题目要求；3.上机输入和调试自己所编的程序；4.验证分析实验结果；5.整理出实验报告一．实验目的二．问题描述三．算法设计包含：数据结构与核心算法的设计描述、函数调用及主函数设计、主要算法流程图等对于高精度数的运算，应该讲输入的高精度数存储为字符串格式，根据输出要求设置数组，在删除数字是记录其位置。

在位数固定的前提下，让高位的数字尽量小，其值就较小，依据贪婪策略就可以解决这个问题。

另外，删除字符使用后面的字符覆盖已删除的字符的方法，但字符串长度会改变，可能会有比较多字符移动操作，算法效率不高。

定义一个del 函数负责删除字符，不断调用del 函数以删除高位较大的数。

是否四.程序调试及运行结果分析运行程序，输入一个正整数23146，输入要删除3个数字，然后成功运行程序后，输出删除后的最小数为14，删除的位数分别为2,1,5。

贪心算法实验报告

贪心算法实验报告贪心算法实验报告引言：贪心算法是一种常用的算法设计思想，它在求解最优化问题中具有重要的应用价值。

本实验报告旨在介绍贪心算法的基本原理、应用场景以及实验结果，并通过实例加以说明。

一、贪心算法的基本原理贪心算法是一种以局部最优解为基础，逐步构建全局最优解的算法。

其基本原理是在每一步选择中都采取当前状态下最优的选择，而不考虑之后的结果。

贪心算法通常具备以下特点：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元硬币。

通过实验结果可以看出，贪心算法在零钱找零问题中取得了较好的效果。

然而，贪心算法并不是适用于所有问题的万能算法，它的有效性取决于问题的特性。

实验三贪心算法应用

实验3贪心算法（定稿）

贪心算法解活动安排实验报告

贪心算法 实验报告

贪心算法在优化问题中的运用

贪心算法原理及应用

贪心算法设计与应用

中原工学院贪心算法的应用

算法实验报告贪心

算法分析与设计实验三贪心算法

实验项目名称∶用贪心算法解单源最短路径问题

贪心算法实验报告

贪心算法的应用

实验三 贪心算法

贪心算法实验报告(C语言)

贪心算法及其应用doc资料

实验三贪心算法

贪心算法实验

贪心算法实验报告

贪心算法实验报告

实验三贪心算法