算法分析与设计实验报告--贪心法 (2)
算法设计与分析_王红梅_第7章 贪心法

( 3 )解决函数 solution :检查解集合 S 是否构成问 题的完整解。例如,在付款问题中,解决函数是已 付出的货币金额恰好等于应付款。 ( 4 )选择函数 select :即贪心策略,这是贪心法 的关键,它指出哪个候选对象最有希望构成问题的 解,选择函数通常和目标函数有关。例如,在付款 问题中,贪心策略就是在候选集合中选择面值最大 的货币。
C=
∞ 3 3 ∞ 3 7 2 3 6 2
3 7 ∞ 2 5 1
2 3 2 ∞ 3
6 2 5 3 ∞
1
1 2 5 2 2 2
5
4
2
3
(a) 5城市的代价矩阵 2 2
(b) 城市1→城市4 1 2 5
3 4 (c) 城市5→城市2 1 2 3 2 2
5
2 3
5
2
2
5 4
5 3 3 2 (f) 城市2回到出发城市1
例:用贪心法求解付款问题。 假设有面值为5元、2元、1元、5角、2角、1角的货币,需 要找给顾客4元6角现金,为使付出的货币的数量最少,首 先选出1张面值不超过4元6角的最大面值的货币,即2元, 再选出1张面值不超过2元6角的最大面值的货币,即2元, 再选出1张面值不超过6角的最大面值的货币,即5角,再选 出1张面值不超过1角的最大面值的货币,即1角,总共付出 4张货币。
7.2.2 图着色问题
给定无向连通图 G=(V, E) ,求图 G的最小色数 k , 使得用k种颜色对G中的顶点着色,可使任意两个相 邻顶点着色不同。
例如,图7.3(a)所示的图可以只用两种颜色着色,将 顶点1、3和4着成一种颜色,将顶点2和顶点5着成另 外一种颜色。为简单起见,下面假定k个颜色的集合 为{颜色1, 颜色2, …, 颜色k}。 3
算法分析与设计实验报告 实验5:贪心算法的应用

sort(d,d+n,cmp);//按纵坐标升序排列 last=d[0].r;//记录当前线段被覆盖的最大坐标值
for(int i=1;i<n;i++) { if(d[i].l<=last && d[i].r>=last)//线段 d[i]的右坐标在 last 之后, 左坐标在 Last 之前的情况,即产生了覆盖。此时还要更新 last 坐标
} cout<<n.substr(0,l-s+x)<<endl;//只打印剩下的左边 l-(s-x)个数字 } return 0; } 2. #include<iostream> #include<cstdio> #include <algorithm> using namespace std; struct point {
课程实验报告
课程名称 算法分析与设计 班级 计算 161 实验日期
姓名
何严鸿
学号 20160701 实验成绩 9
实验名称
实验 5:贪心算法的应用
实
1.理解贪心算法的概念;
验
目
2.掌握贪心算法的基本思想。
的
及
要
求
实
操作系统:Windows
验
环
IDE:Visual C++
境
(1)删数问题
2018/5/06
{
length=d[i].r-d[i-1].l; last=d[i].r; } else if (d[i].r<=last) //线段 d[i]的右坐标在 last 之内,不产生覆盖 continue; else if (d[i].l>=last) //线段 d[i]的左坐标在 Last 之后,此时 last 之后的部分不会对之前的部分产生影响,更新 last 坐标。length 的值加上之 前的部分 { last=d[i-1].r; length=length+d[i].r-d[i].l; } } cout<<last<<endl; return 0; }
贪心算法 实验报告

贪心算法实验报告贪心算法实验报告引言:贪心算法是一种常用的算法设计策略,它通常用于求解最优化问题。
贪心算法的核心思想是在每一步选择中都选择当前最优的解,从而希望最终能够得到全局最优解。
本实验旨在通过实际案例的研究,探索贪心算法的应用和效果。
一、贪心算法的基本原理贪心算法的基本原理是每一步都选择当前最优解,而不考虑整体的最优解。
这种贪婪的选择策略通常是基于局部最优性的假设,即当前的选择对于后续步骤的选择没有影响。
贪心算法的优点是简单高效,但也存在一定的局限性。
二、实验案例:零钱兑换问题在本实验中,我们以零钱兑换问题为例,来说明贪心算法的应用。
问题描述:假设有不同面值的硬币,如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. 实验对比和讨论通过实验对比,我们可以看到贪心算法和动态规划算法在不同场景下的优化效果和性能有所不同。
对于小规模问题,贪心算法能够快速计算得到一个近似最优解,并能在较短的时间内完成计算。
然而,贪心算法不能保证一定得到全局最优解,可能会得到次优解。
对于大规模问题,动态规划算法能够在较短的时间内得到全局最优解。
贪心算法应用

edges[j].end = temp;
temp = edges[i].weight;
edges[i].weight = edges[j].weight;
edges[j].weight = temp;
}
void MiniSpanTree(MGraph *G)//生成最小生成树
for (i = 1; i <= G->arcnum; i++)//核心部分
{
n = Find(parent, edges[i].begin);
m = Find(parent, edges[i].end);
if (n != m)
{
parent[n] = m;
printf("<< %d, %d >> %d\n", edges[i].begin, edges[i].end, edges[i].weight);
{
printf("%d ",G->arc[i][j].adj);
}
printf("\n");
}
}
void sort(edge edges[],MGraph *G)//对权值进行排序
{
int i, j;
for ( i = 1; i < G->arcnum; i++)
{
for ( j = i + 1; j <= G->arcnum; j++)
}
}
}
int Find(int *parent, int f)//找尾
单源最短路径(贪心法)实验报告
算法分析与设计实验报告第 5 次实验使用贪心法求出给定图各点的最短路径,并计算算法的执行时间,分析算法的有效性。
已知一个有向网络 G=(V,E)和源点 V1,如上所示,求出从源点出发到图中其余顶点的最短路径。
1 用邻接矩阵表示有向图,并进行初始化,同时选择源点;}手动输入实现实验所给图形:随机数产生图的权值:通过这次实验,我回顾了回溯法求解最短路径问题,在其中加入了舍伍德附录:完整代码#include<stdio.h>#include<stdlib.h>#include<time.h>#define maxint 1000int c[200][200]={0};void Dijkstra(int n,int v,int dist[],int prev[]){ bool s[maxint];for(int i=1;i<=n;i++){dist[i]=c[v][i];s[i]=false;if(dist[i]==maxint) prev[i]=0;else prev[i]=v;} //找到第一个可行源点 s[]标志,记录prev[]前一个点dist[v]=0;s[v]=true;for(int i=1;i<n;i++){int temp=maxint;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(int j=1;j<=n;j++){int newdist=dist[u]+c[u][j];if(newdist<dist[j]){dist[j]=newdist;prev[j]=u;}}}}int main(){int n,v;printf("请输入顶点数: ");scanf("%d",&n);//printf("路径: ");srand(time(0));for(int i=1;i<n+1;i++){for(int j=1;j<n+1;j++){/* scanf("%d",&c[i][j]);*/ ///手动输入if(i!=j){if((c[j][i]==0)||(c[j][i]==1000))c[i][j]=rand()%100+1;else c[i][j]=1000;if(c[i][j]>50) c[i][j]=1000;}}}printf("请输入源点: ");scanf("%d",&v);int dist[n+1],prev[n+1];printf("\n路径:\n");for(int i=1;i<n+1;i++){for(int j=1;j<n+1;j++)printf("%5d ",c[i][j]);printf("\n");}Dijkstra(n,v,dist,prev);for(int i=1;i<n+1;i++){printf("\n%d到%d的最短路径为:%d",v,i,dist[i]);}}。
《算法设计与分析》课程实验报告 (贪心算法(一))
《算法设计与分析》课程实验报告实验序号: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,这是不可能的。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Dijkstra方法的基本思想是从vs出发,逐步地向外探寻最短路。执行过程中,与每个点对应,记录下一个数(称为这个点的标号),它或者表示从vs到该点的最短路的权(称为P标号)、或者是从vs到该点的最短路的权的上界(称为T标号),方法的每一步是去修改T标号,并且把某一个具T标号的改变为具P标号的点,从而使G中具P标号的顶点数多一个,这样至多经过n-1(n为图G的顶点数)步,就可以求出从vs到各点的最短路。
(3)编写程序实现多机调度问题
【问题描述】要求给出一种作业调度方案,使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。约定,每个作业均可在任何一台机器上加工处理,但未完工前不允许中断处理。作业不能拆分成更小的子作业。
算法思想分析
⑴所谓单源最短路径问题是指:已知图G=(V,E),我们希望找出从某给
if(D[j]!=-1) P[j]=0;
else P[j]=-1;
}
}
void theshortestway(int R[], int B[],int D[], int P[])
{for(int k=1;k<VEX;k++) //每次从蓝点集中取出具有最短特殊路长度的结点min
{int min;
for(min=0;B[min]==0;) min++; //求蓝点集结点最小下标元素
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);
《算法分析与设计》实验报告
完成日期:
20011.11.17
实验目的
(1)了解贪心算法思想
(2)掌握贪心法典型问题,如背包问题、作业调度问题等。
实验内容
(1)编写一个简单的程序,实现单源最短路径问题。
(2)编写一段程序,实现找零。
【问题描述】当前有面值分别为2角5分,1角,5分,1分的硬币,请给出找n分钱的最佳方案(要求找出的硬币数目最少)。
当n>m时,首先将n个作业依其所需的处理时间从大到小排序。然后依此顺序将作业分配给空闲的处理机。算法所需的计算时间为O(nlogn)。
代码:
#include <iostream>
using namespace std;
#define N 10//作业数
#define M 3//机器数
static int time[N]={2,8,18,32,50,72,98,128,182,200},s[M]={0,0,0};
定的源结点S∈V到V中的每个结点的最短路径。
首先,我们可以发现有这样一个事实:如果P是G中从vs到vj的最短路,vi是P中的一个点,那么,从vs沿P到vi的路是从vs到vi的最短路。
(一)Dijkstra算法
对于图G,如果所有Wij≥0的情形下,目前公认的最好的方法是由Dijkstra于1959年提出来的。
}
void main()
{cout<<"请问你要找零多少钱(单位:元)"<<endl;
int m;cin>>m;
ZhaoLing(m);
cout<<"需要找";
for (int j = 0; j < ZUSHU-1; j ++)
cout<<GeShu[j]<<"张"<<Ling[j]<<"元"<<",";
-1 , -1 , 0 , -1 , 10 ,
-1 , -1 , 20 , 0 , 60 ,
-1 , -1 , -1 , -1 , 0
}; //邻接矩阵
int R[maxpoint]={0};
int B[maxpoint];
int D[VEX];
int P[VEX];//定义数组D用来存放结点特殊距离,P数组存放父亲结点
(1)初始时,S中仅含有源节点。
(2)设u是G的某一个顶点,把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径,用数组D[i]记录顶点i当前所对应的最短特殊路径长度。
(3)Dijkstra算法每次从V-S中取出具有最短特殊路长度的顶点u,将u添加到S中,同时对数组D作必要的修改。
(4)一旦S包含了所有V中顶点,dist就记录了从源到所有其它顶点之间的最短路径长度。
在叙述Dijkstra方法的具体步骤之前,以例1为例说明一下这个方法的基本思想。例1中,s=1。因为所有Wij≥0,故有d(v1, v1)=0。这时,v1是具P标号的点。现在考察从v1发出的三条弧,(v1, v2), (v1, v3)和(v1, v4)。如果某人从v1出发沿(v1, v2)到达v2,这时需要d(v1, v1)+w12=6单位的费用;如果他从v1出发沿(v1, v3)到达v3,这时需要d(v1, v1)+w13=3单位的费用;类似地,若沿(v1, v4)到达v4,这时需要d(v1, v1)+w14=1单位的费用。因为min{ d(v1, v1)+w12,d(v1,v1)+w13,d(v1, v1)+w14}= d(v1, v1)+w14=1,可以断言,他从v1到v4所需要的最小费用必定是1单位,即从v1到v4的最短路是(v1, v4),d(v1, v4)=1。这是因为从v1到v4的任一条路P,如果不是(v1, v4),则必是先从v1沿(v1, v2)到达v2,或者沿(v1, v3)到达v3。但如上所说,这时他已需要6单位或3单位的费用,不管他如何再从v2或从v3到达v4,所需要的总费用都不会比1小(因为所有wij≥0)。因而推知d(v1, v4)=1,这样就可以使v4变成具P标号的点。现在考察从v1及v4指向其余点的弧,由上已知,从v1出发,分别沿(v1, v2)、(v1, v3)到达v2, v3,需要的费用分别为6与3,而从v4出发沿(v4, v6)到达v6所需的费用是d(v1, v4)+w46=1+10=11单位。因min{ d(v1, v1)+w12,d(v1, v1)+w13,d(v1, v4)+w46}= d(v1, v1)+w13=3。基于同样的理由可以断言,从v1到v3的最短路是(v1, v3),d(v1, v3)=3。这样又可以使点v3变成具P标号的点,如此重复这个过程,可以求出从v1到任一点的最短路。
}
}
int max(int t[],int num) //max函数求解处理时间总和最长
{int max=t[0];
for(int i=1;i<num;i++)
if(max<t[i]) max=t[i];
return max;
}
int min(int t[],int m)
{int min=0; //min记录目前处理作业时间和最小的机器号
//初始时,红点集中仅有源结点0
void instital(int R[], int B[],int D[], int P[])
{R[0]=1; B[0]=0;
for(int i=1;i<VEX;i++)
B[i]=1;
//对数组D、P进行初始化
for(int j=0;j<VEX;j++)
{D[j]=graph[0][j];
在下述的Dijstra方法具体步骤中,用P,T分别表示某个点的P标号、T标号,si表示第i步时,具P标号点的集合。为了在求出从vs到各点的距离的同时,也求出从Vs到各点的最短路,给每个点v以一个λ值,算法终止时λ(v)=m,表示在Vs到v的最短路上,v的前一个点是Vm;如果λ(v)=∞,表示图G中不含从Vs到v的路;λ(Vs)=0。
cout<<"从0点到各点的最短距离"<<endl;
for(int m = 0; m < VEX; m++)
cout<<D[m]<<" ";
cout<<endl;
}
调试运行:
2.找零问题
基本思想:将要找零的数跟各种面值的零钱按由大到小比较,用除法得到个面值的找零数,直到全部找零。
#include<iostream>
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];}
for(int j=min;j<VEX;j++)
if(D[j]!=-1&&D[j]<D[min]&&B[j]==1) min=j;
//将具有最短特殊路长度的结点min添加到红点集中
R[min]=1; B[min]=0;
//对数组D作必要的修改
for(j=1;j<VEX;j++)