实验三 最短路径的算法(离散数学实验报告)
最短路径的实验报告
最短路径的实验报告最短路径的实验报告引言:最短路径问题是图论中一个经典的问题,涉及到在一个带有权重的图中找到两个顶点之间的最短路径。
本实验旨在通过实际操作和算法分析,深入探讨最短路径算法的性能和应用。
实验设计:本次实验使用了Dijkstra算法和Floyd-Warshall算法来解决最短路径问题。
首先,我们使用Python编程语言实现了这两个算法,并对它们进行了性能测试。
然后,我们选择了几个不同规模的图进行实验,以比较这两种算法的时间复杂度和空间复杂度。
最后,我们还在实际应用中使用了最短路径算法,以验证其实用性。
实验过程:1. 实现Dijkstra算法Dijkstra算法是一种贪心算法,用于求解单源最短路径问题。
我们首先实现了该算法,并对其进行了性能测试。
在测试中,我们使用了一个包含1000个顶点和5000条边的图,记录了算法的运行时间。
结果显示,Dijkstra算法的时间复杂度为O(V^2),其中V表示图中的顶点数。
2. 实现Floyd-Warshall算法Floyd-Warshall算法是一种动态规划算法,用于求解所有顶点对之间的最短路径。
我们在Python中实现了该算法,并对其进行了性能测试。
在测试中,我们使用了一个包含100个顶点和5000条边的图,记录了算法的运行时间。
结果显示,Floyd-Warshall算法的时间复杂度为O(V^3),其中V表示图中的顶点数。
3. 比较两种算法通过对Dijkstra算法和Floyd-Warshall算法的性能测试,我们可以看到,Dijkstra算法在处理较大规模的图时性能更好,而Floyd-Warshall算法在处理较小规模的图时性能更好。
因此,在实际应用中,我们可以根据图的规模选择合适的算法。
4. 应用实例为了验证最短路径算法的实际应用性,我们选择了一个城市交通网络图进行实验。
我们使用了Dijkstra算法来计算两个城市之间的最短路径,并将结果与实际的驾车时间进行比较。
算法实验报告
算法实验报告算法实验报告引言:算法是计算机科学的核心内容之一,它是解决问题的方法和步骤的描述。
算法的设计和分析是计算机科学与工程中的重要研究方向之一。
本实验旨在通过对算法的实际应用和实验验证,深入理解算法的性能和效果。
实验一:排序算法的比较在本实验中,我们将比较三种常见的排序算法:冒泡排序、插入排序和快速排序。
我们将通过对不同规模的随机数组进行排序,并记录每种算法所需的时间和比较次数,以评估它们的性能。
实验结果显示,快速排序是最快的排序算法,其时间复杂度为O(nlogn),比较次数也相对较少。
插入排序的时间复杂度为O(n^2),比较次数较多,但对于小规模的数组排序效果较好。
而冒泡排序的时间复杂度也为O(n^2),但比较次数更多,效率相对较低。
实验二:图的最短路径算法在图的最短路径问题中,我们将比较Dijkstra算法和Floyd-Warshall算法的效率和准确性。
我们将使用一个带权有向图,并计算从一个顶点到其他所有顶点的最短路径。
实验结果表明,Dijkstra算法适用于单源最短路径问题,其时间复杂度为O(V^2),其中V为顶点数。
而Floyd-Warshall算法适用于多源最短路径问题,其时间复杂度为O(V^3)。
两种算法在准确性上没有明显差异,但在处理大规模图时,Floyd-Warshall算法的效率较低。
实验三:动态规划算法动态规划是一种通过将问题分解成子问题并记录子问题的解来解决复杂问题的方法。
在本实验中,我们将比较两种动态规划算法:0-1背包问题和最长公共子序列问题。
实验结果显示,0-1背包问题的动态规划算法可以有效地找到最优解,其时间复杂度为O(nW),其中n为物品个数,W为背包容量。
最长公共子序列问题的动态规划算法可以找到两个序列的最长公共子序列,其时间复杂度为O(mn),其中m和n分别为两个序列的长度。
结论:通过本次实验,我们对不同算法的性能和效果有了更深入的了解。
排序算法中,快速排序是最快且效率最高的;在图的最短路径问题中,Dijkstra算法和Floyd-Warshall算法分别适用于不同的场景;动态规划算法可以解决复杂的问题,并找到最优解。
实验三最短路径的算法(离散数学实验报告)
实验三最短路径的算法(离散数学实验报告)实验3:最短路径算法⼀、实验⽬的通过本实验的学习,理解Floyd(弗洛伊得)最短路径算法的思想⼆、实验内容⽤C语⾔编程实现求赋权图中任意两点间最短路径的Floyd算法,并能对给定的两结点⾃动求出最短路径三、实验原理、⽅法和⼿段1、Floyd算法的原理定义:Dk[i,j] 表⽰赋权图中从结点vi出发仅通过v0,v1,┉,vk-1中的某些结点到达vj的最短路径的长度,若从vi到vj没有仅通过v0,v1,┉,vk-1 的路径,则D[i,j]=∝即D-1[i,j] 表⽰赋权图中从结点vi到vj的边的长度,若没有从结点vi到vj的边,则D[i,j]=∝D0[i,j] 表⽰赋权图中从结点vi到vj的”最短”路径的长度, 这条路上除了可能有v0外没有其它结点D1[i,j] 表⽰赋权图中从结点vi到vj的”最短”路径的长度, 这条路上除了可能有v0,v1外没有其它结点┉┉┉根据此定义,D k[i,j]=min{ D k-1[i,j] , D k-1[i,k-1]+D k-1[k-1,j] }定义:path[i,j]表⽰从结点vi到vj的“最短”路径上vi的后继结点四、实验要求要求输出每对结点之间的最短路径长度以及其最短路径五、实验步骤(⼀)算法描述Step 1 初始化有向图的成本邻矩阵D、路径矩阵path若从结点vi到vj有边,则D[i,j]= vi到vj的边的长度,path[i,j]= i;否则D[i,j]=∝,path[i,j]=-1Step 2 刷新D、path 对k=1,2,┉n 重复Step 3和Step 4Step 3 刷新⾏对i=1,2,┉n 重复Step 4Step 4 刷新Mij 对j=1,2,┉n若D k-1[i,k]+D k-1[k,j][结束循环][结束Step 3循环][结束Step 2循环]Step 5 退出(⼆)程序框图参考主程序框图其中,打印最短路径中间结点调⽤递归函数dist(),其框图如下,其中fist,end是当前有向边的起点和终点dist(int first, int end)七、测试⽤例:1、输⼊成本邻接矩阵:D :06380532290141003210∝∝∝∝V V V V V V V V (其中∝可⽤某个⾜够⼤的数据值代替,⽐如100)可得最短路径矩阵:P :131132122211111010103210--------V V V V V V V V以及各顶点之间的最短路径和最短路径长度:从V0到V1的最短路径长度为:1 ;最短路径为:V0→V1 从V0到V2的最短路径长度为:9 ;最短路径为:V0→V1→V3→V2 从V0到V3的最短路径长度为:3 ;最短路径为:V0→V1→V3 从V1到V0的最短路径长度为:11;最短路径为:V1→V3→V2→V0从V1到V2的最短路径长度为:8 ;最短路径为:V1→V3→V2 从V1到V3的最短路径长度为:2 ;最短路径为:V1→V3 从V2到V0的最短路径长度为:3 ;最短路径为:V2→V0 从V2到V1的最短路径长度为:4 ;最短路径为:V2→V0→V1 从V2到V3的最短路径长度为:6 ;最短路径为:V2→V0→V1→V3 从V3到V0的最短路径长度为:9 ;最短路径为:V3→V2→V0 从V3到V1的最短路径长度为:10;最短路径为:V3→V2→V0→V1 从V3到V2的最短路径长度为:6 ;最短路径为:V3→V2 参考程序: #include #define INFINITY 100 #define Max 10int a[Max][Max],P[Max][Max]; main() {void Print_Flod(int d);int i,j,k,D=4;printf("请输⼊成本邻接矩阵:\n");for(i=0;ifor(j=0;j{scanf("%d",&a[i][j]);}for(i=0;ifor(j=0;j{if(a[i][j]>0&& a[i][j]elseP[i][j]=-1;}for(k=0;kfor(i=0;ifor(j=0;jif (a[i][k]+a[k][j]{a[i][j]=a[i][k]+a[k][j];P[i][j]=k;}Print_Flod(D);}void Print_Flod(int d){void dist(int first,int end);int i,j;for(i=0;ifor(j=0;jif(i!=j){ printf("from V%d to V%d: ",i,j); dist(i,j);printf("V%d",j);printf(" (The length is: %d)\n",a[i][j]); }}void dist(int first,int end){ int x;x=P[first][end];if(x!=first){ dist(first,x); dist(x,end); }else printf("V%d->",x);}输出结果:。
最短路径实验报告
最短路径实验报告最短路径实验报告引言:最短路径算法是计算机科学中的一个经典问题,它在许多领域中都有广泛的应用,如交通规划、电路设计、网络通信等。
本实验旨在通过实践探索最短路径算法的实际应用,并对其性能进行评估。
一、问题描述:我们将研究一个城市的交通网络,其中包含多个节点和连接这些节点的道路。
每条道路都有一个权重,表示通过该道路所需的时间或距离。
我们的目标是找到两个节点之间的最短路径,即使得路径上各个道路权重之和最小的路径。
二、算法选择:为了解决这个问题,我们选择了Dijkstra算法和Floyd-Warshall算法作为比较对象。
Dijkstra算法是一种单源最短路径算法,它通过不断选择当前最短路径的节点来逐步扩展最短路径树。
Floyd-Warshall算法则是一种多源最短路径算法,它通过动态规划的方式计算任意两个节点之间的最短路径。
三、实验设计:我们首先构建了一个包含10个节点和15条道路的交通网络,每条道路的权重随机生成。
然后,我们分别使用Dijkstra算法和Floyd-Warshall算法计算两个节点之间的最短路径,并记录计算时间。
四、实验结果:经过实验,我们发现Dijkstra算法在计算单源最短路径时表现出色,但是在计算多源最短路径时效率较低。
而Floyd-Warshall算法在计算多源最短路径时表现出色,但是对于大型网络的单源最短路径计算则需要较长的时间。
五、性能评估:为了评估算法的性能,我们对不同规模的交通网络进行了测试,并记录了算法的计算时间。
实验结果显示,随着交通网络规模的增大,Dijkstra算法的计算时间呈指数级增长,而Floyd-Warshall算法的计算时间则呈多项式级增长。
因此,在处理大型网络时,Floyd-Warshall算法具有一定的优势。
六、实际应用:最短路径算法在实际应用中有着广泛的用途。
例如,在交通规划中,最短路径算法可以帮助我们找到最优的行车路线,减少交通拥堵。
Dijkstra最短路径算法实习报告
Dijkstra最短路径算法实习报告1.引言交通诱导系统的一个核心技术是最优路径的选择技术。
根据交通网络模型中各顶点和顶点之间的长度、时间或费用等属性权值,通过Dijkstra最短路径算法,解决有向图即交通网络模型中源点到其他顶点的最短路径问题。
2.建立交通道路网络模型交通道路网是路径诱导的基础和对象,首先需要建立交通道路网络模型。
交通道路网中的路段具有属性,且同一路段的两个方向其属性一般不完全相同,有向图能够很好地表达实际的交通网络,便于处理同路段两个方向的不同属性和单行线、交叉口转向限制等特殊交通属性。
综上,采用带权有向图来表达交通道路网。
其中,道路的终点和十字路口通常定义为一个顶点,两个顶点之间的道路定义为一条弧,每条弧根据其距离、途中所需时间或交通费用等定义为路段权值。
在有向图上,一条以i为起点,以j为终点的路径是一些顶点的序列,其中前一条弧的终点是后一条弧的起点,一条路线用一个有序的点集描述,而一条路线的长度、时间或者费用等属性为这条路径上的所有弧的权值之和。
这样便建立好了交通道路网络的模型。
3.最短路径算法迪杰斯特拉(Dijkstra)算法是经典路径诱导规划算法,Dijkstra算法是一个按路径长度递增的次序产生最短路径的算法,算法比较简单,容易实现,但计算量较大。
3.1算法分析:首先引进辅助向量D,它的每个分量D[i]表示当前所找到的从始点v0到每个终点vi的最短路径的长度。
为D[i]赋初值,若从v0到vi有弧,则D[i]为弧上的权值,否则置D[i]为∞。
则长度为D[j]=Min{D[i]|vi∈v}的路径就是从v0出发的长度最短的一条最短路径,此路径为v0—vj。
设下一条长度次短的路径的终点是vk,则这条路径或者是v0—vk,或者是v0—vj—vk。
它的长度是v0到vk弧上的权值或D[j]和vj到vk弧上权值之和。
3.2算法正确性证明:设s为为已切得最短路径的终点的集合,则有结论:下一条最短路径(设其终点为vx)或者是v0—vx,或者是中间只经过s中的顶点而最后到达顶点x的路径。
离散数学 实验报告 迷宫最短路径
离散数学迷宫问题从一个迷宫的入口到出口找出一条可通路经。
用一个二维数组MG(0:M,0:N)模拟迷宫,数组元素为0表示该位置可以通过,数组元素为1表示该位置不可以通行。
MG(1,1)和MG(M-1,N-1)分别为迷宫50输入1. 输入迷宫的大小M行和N列,两者为整数2. 给定MG[M,N]各元素的值(0或1),建立迷宫。
输出是否有通路(YES或NO)样例输入5 51 1 1 1 1 11 0 0 0 0 11 0 0 0 1 11 0 0 1 0 11 0 0 1 0 11 1 1 1 1 1样例输出NO提示1)读入两个整数M,N后,迷宫的大小是0~M和0~N,也就是实际上有M+1行和N+1列2)判断是否有通路主要是判断点(1,1)到点(M-1,N-1)之间是否有通路,第0行、第M行、第1列、第N列的所有值都一定是1。
#include "stdio.h"struct{int i;int j;int di;}stack[10000];int top=-1;int fun(){int mg[500][500],i,j,di,find,N,M,x,y;scanf("%d%d",&M,&N);for(x=0;x<=M;x++)for(y=0;y<=N;y++)scanf("%d",&mg[x][y]);top++;stack[top].i=1; stack[top].j=1; stack[top].di=-1; mg[1][1]=-1;while(top>=0){i=stack[top].i; j=stack[top].j; di=stack[top].di;if(i==M-1&&j==N-1){printf("YES\n");return 0;}find=0;while(di<4&&find==0){di++;if(di==0){i=(stack[top].i)-1; j=stack[top].j;}if(di==1){i=stack[top].i; j=(stack[top].j)+1;}if(di==2){i=(stack[top].i)+1; j=stack[top].j;}if(di==3){i=stack[top].i; j=(stack[top].j)-1;}if(mg[i][j]==0){find=1;break;}}if(find==1){stack[top].di=di;top++;stack[top].i=i; stack[top].j=j; stack[top].di=-1;mg[i][j]=-1;}else{mg[stack[top].i][stack[top].j]=1;top--;}}printf("NO\n");return 0;}int main(){fun();return 0;}。
离散数学 实验报告 迷宫最短路径问题求解
离散数学迷宫问题问题描述:一只老鼠走进了一个迷宫,这个迷宫是由M行N列(如:10行8列)的方格构成的,相邻方格之间可能是相通的,也可能有墙相隔,各方格位置由其对应坐标确定,如图所示。
迷宫在(1,1)处有一个入口,在(M,N)处有一个出口,在入口和出口之间有通路相通。
问题是让你帮助老鼠找出从入口到出口的一条最短路径。
00001000110010100001000000001010101000000011101110001000基本要求:为老鼠找出一条从入口到出口的最短路径。
实现提示:1、迷宫用数组表示,1代表是墙走不通,0表示可以通行。
边界可以扩充为墙,即M×N 迷宫用(M+2)×(N+2)数组表示。
2、向4个方向前进时的位移量可以用以下数组表示,处理是方便。
int move[4][2]={ {0,1},{1,0},{0,-1},{-1,0} };3、采用图的广度优先搜索算法。
#include<stdio.h>#define m 7#define n 8void path(){int maze[m+2][n+2] ;int move[4][2]={ {0,-1},{-1,0},{0,1},{1,0} };int s[54][3];int top=0;int i,j,k,f=0;int g,h,p;for(i=0;i<m+2;++i)for(j=0;j<n+2;++j)scanf("%d",&maze[i][j]);maze[1][1]=2;s[top][0]=1;s[top][1]=1;s[top][2]=0;++top;while(top!=0&&f==0){--top;i=s[top][0];j=s[top][1];k=s[top][2];while(k<4){g=i+move[k][0];h=j+move[k][1];if(g==m&&h==n&&maze[g][h]==0) {for(p=0;p<top;++p)printf("%3d,%d\n",s[p][0],s[p][1]);printf("%3d,%d\n",i,j);printf("%3d,%d\n",m,n);f=1;}//ifif(maze[g][h]==0){maze[g][h]=2;s[top][0]=i;s[top][1]=j;s[top][2]=k;++top;i=g;j=h;k=0;}//ifk=k+1;}//while}//whileif(f==0)printf("no path\n"); }//pathvoid main(){path();}。
最短路径实验报告
D[w] = min+mgraph.arcs[v][w].adj; //更新D[w]
for(j = 0;j<mgraph.vexnum;j++)
//修改P[w],v0到w经过的顶点包括v0到v经过的顶点再加上顶点w
{
P[w][j] = P[v][j];
}
P[w][w] = true;
}
}
}
}
3、运行与测试
for(w = 0;w<mgraph.vexnum;w++)
{
D[v][w] = mgraph.arcs[v][w].adj;//顶点v到顶点w的直接距离
for(u = 0;u<mgraph.vexnum;u++)
{
P[v][w][u] = false;//路径矩阵初值
}
if(D[v][w]<infinity)
//根据新并入的顶点,更新不在S集的顶点到v0的距离和路径数组
{
if(!final[w]&&min<infinity&&mgraph.arcs[v][w].adj<infinity&&
(min+mgraph.arcs[v][w].adj<D[w]))
// w不属于S集且v0→v→w的距离<目前v0→w的距离
程序运行如图所示。
Step1:运行程序,屏幕显示菜单。
Step2:运行功能选择。
Case1:输入“1”,选择菜单项1,进入图的创建操作。
1.1根据屏幕提示,创建有向网。
1.2屏幕显示网信息。
Case2:输入“2”,选择菜单项2,进入求源点到其他各点的距离操作。
最短路径实验报告
一、实验目的学习掌握图的存储结构利用最短路径算法,通过java编程实现最短路径输出。
二、实验环境Eclipse平台三、实验过程最短路径算法问题是计算机科学、运筹学、地理信息系统和交通诱导、导航系统等领域研究的一个热点。
传统的最短路径算法主要有Floyd算法和Dijkstra算法。
Floyd算法用于计算所有结点之间的最短路径。
Dijkstra算法则用于计算一个结点到其他所有结点的最短路径。
本程序利用Dijkstra算法用java语言实现最短路径的可视化。
流程: 画无向邻接矩阵邻接矩阵初始化求取最短路径Java文件如下M ain.java 文件:import java.awt.BorderLayout;import java.awt.Color;import java.awt.FlowLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.ItemEvent;import java.awt.event.ItemListener;import java.util.StringTokenizer;import javax.swing.JButton;import javax.swing.JComboBox;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JPanel;import javax.swing.border.TitledBorder;public class Main {public static void main(String args[]) {new UI("最短路径");}}@SuppressWarnings("serial")class UI extends JFrame implements ActionListener, ItemListener { JFrame frame;JButton button;JLabel label1, label2, label3;JComboBox list1, list2;JPanel panel1, panel2;ShortCanvas canvas;ShortInit inits;SetFont f;String circlename[];String circle1, circle2;String path[];int circlenum;int list2_index;int D[];int renum[];int num = 0;UI(String s) {super(s);canvas = new ShortCanvas();add(canvas,BorderLayout.CENTER);f=new SetFont();inits = new ShortInit();circlename = inits.getcirclename();circlenum =inits.getcirclenum();circle1 = circlename[0];circle2 = circlename[0];panel2 = new JPanel();panel2.setBorder(new TitledBorder("最短路径"));panel2.setBackground(Color.white);panel2.setLayout(new FlowLayout(FlowLayout.LEADING, 5, 5));label1 = new JLabel("起点", JLabel.LEFT);label1.setFont(f.setSysFontAndFace());panel2.add(label1);list1 = new JComboBox();list1.addItemListener(this);list1.setMaximumRowCount(5);// 设置 JComboBox 显示的最大行数panel2.add(list1);label2 = new JLabel("终点");label2.setFont(f.setSysFontAndFace());panel2.add(label2);list2 = new JComboBox();list2.addItemListener(this);panel2.add(list2);list2.setMaximumRowCount(5);// 设置 JComboBox 显示的最大行数for (int i = 0; i < circlenum; i++) {list1.addItem(circlename[i]);list2.addItem(circlename[i]);}button = new JButton("确定");button.addActionListener(this);button.setFont(f.setSysFontAndFace());panel2.add(button);label3 = new JLabel("");label3.setFont(f.setSysFontAndFace());panel2.add(label3);add(panel2,BorderLayout.SOUTH);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);setBounds(100, 100, 530, 547);setVisible(true);validate();}public void itemStateChanged(ItemEvent e) {if (e.getSource() == list1)circle1 = (String) list1.getSelectedItem();if (e.getSource() == list2) {circle2 = (String) list2.getSelectedItem();list2_index = list2.getSelectedIndex();}}public void actionPerformed(ActionEvent e) {if (e.getSource() == button) {ShortPath sp = new ShortPath(circle1, circle2);path = sp.getpath();D = sp.getD();label3.setText("最短路径为:" + D[list2_index]);renum = new int[circlenum];StringTokenizer fenxi = newStringTokenizer(path[list2_index], "->");num = 0;while (fenxi.hasMoreTokens()) {String str = fenxi.nextToken();for (int i = 0; i < circlenum; i++) {if (str.equals(circlename[i])) {renum[num] = i;num++;}}}canvas.flag = 1;canvas.resultroad = renum;canvas.num = num;canvas.repaint();}}}SetFont.java文件import java.awt.Font;import javax.swing.JFrame;import javax.swing.UIManager;import javax.swing.UnsupportedLookAndFeelException;//系统外观处理@SuppressWarnings("serial")public class SetFont extends JFrame {public Font setSysFontAndFace() {try {// 根据类名称设置外观UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel" );} catch (UnsupportedLookAndFeelException ex) {} catch (IllegalAccessException ex) {} catch (InstantiationException ex) {} catch (ClassNotFoundException ex) {}Font font = new Font("新宋体", Font.ITALIC + Font.BOLD, 17);return font;}}ShortCanvas.java文件://画无向邻接矩阵import java.awt.Canvas;import java.awt.Color;import java.awt.Graphics;@SuppressWarnings("serial")public class ShortCanvas extends Canvas {SetFont f;ShortInit init;String circlename[];int roadlength[];int arcs[][]; // 带权邻接矩阵int circlenum;int roadnum;int location[][]; // 各点坐标int flag = 0;int num;int resultroad[];// 结果线路ShortCanvas() {f = new SetFont();init = new ShortInit();circlename = init.getcirclename();roadlength = init.getroadlength();circlenum = init.getcirclenum();roadnum = init.getroadnum();arcs = new int[circlenum][circlenum];location = new int[circlenum][2];for (int i = 0; i < circlenum; i++)for (int j = 0; j < circlenum; j++)arcs[i][j] = 10000;set();}public void paint(Graphics g) {g.setFont(f.setSysFontAndFace());g.drawOval(60, 60, 25, 25); // ag.drawString(circlename[0], 70, 75);g.drawString(String.valueOf(roadlength[0]), 135, 135);g.drawOval(200, 180, 25, 25); // bg.drawString(circlename[1], 210, 195);g.drawLine(70, 85, 200, 192); // a--bg.drawOval(100, 300, 25, 25); // cg.drawString(circlename[2], 110, 315);g.drawString(String.valueOf(roadlength[1]), 90, 195);g.drawLine(70, 85, 112, 300); // a--cg.drawString(String.valueOf(roadlength[2]), 165, 250);g.drawLine(200, 192, 112, 300); // b--cg.drawOval(350, 180, 25, 25); // dg.drawString(circlename[3], 360, 195);g.drawString(String.valueOf(roadlength[3]), 285, 190);g.drawLine(225, 192, 350, 192); // b--dg.drawOval(250, 360, 25, 25); // gg.drawString(circlename[4], 260, 375);g.drawString(String.valueOf(roadlength[4]), 185, 345);g.drawLine(125, 315, 250, 375); // c--gg.drawString(String.valueOf(roadlength[5]), 305, 270);g.drawLine(275, 372, 350, 192); // g--dg.drawOval(450, 80, 25, 25); // eg.drawString(circlename[5], 460, 95);g.drawString(String.valueOf(roadlength[6]), 420, 150);g.drawLine(375, 192, 462, 105); // d--eg.drawOval(480, 300, 25, 25); // fg.drawString(circlename[6], 490, 315);g.drawString(String.valueOf(roadlength[7]), 465, 205);g.drawLine(462, 105, 492, 300); // e--fg.drawString(String.valueOf(roadlength[8]), 420, 280);g.drawLine(375, 192, 480, 312); // d--fg.drawString(String.valueOf(roadlength[9]), 370, 330);g.drawLine(275, 372, 480, 312); // g--fg.drawString(String.valueOf(roadlength[10]), 260, 85);g.drawLine(70, 85, 450, 92); // a--eint i, j;if (flag == 1) {g.setColor(Color.red);for (i = 0; i < num - 1; i++) {j = i + 1;g.drawLine(location[resultroad[i]][0] + 12,location[resultroad[i]][1] + 12,location[resultroad[j]][0] + 12,location[resultroad[j]][1] + 12);}}}public void set() {location[0][0] = 60;location[0][1] = 60;location[1][0] = 200;location[1][1] = 180;location[2][0] = 100;location[2][1] = 300;location[3][0] = 350;location[3][1] = 180;location[4][0] = 250;location[4][1] = 360;location[5][0] = 450;location[5][1] = 80;location[6][0] = 480;location[6][1] = 300;arcs[0][1] = arcs[1][0] = roadlength[0];arcs[0][2] = arcs[2][0] = roadlength[1];arcs[1][2] = arcs[2][1] = roadlength[2];arcs[1][3] = arcs[3][1] = roadlength[3];arcs[2][4] = arcs[4][2] = roadlength[4];arcs[4][3] = arcs[3][4] = roadlength[5];arcs[3][5] = arcs[5][3] = roadlength[6];arcs[5][6] = arcs[6][5] = roadlength[7];arcs[3][6] = arcs[6][3] = roadlength[8];arcs[4][6] = arcs[6][4] = roadlength[9];arcs[0][5] = arcs[5][0] = roadlength[10];}public int[][] getarcs() {return arcs;}}ShortInit.java文件:public class ShortInit {int circlenum=7;int roadnum=9;int num[];String circlename[];int roadlength[];ShortInit (){circlename=new String[10];roadlength=new int[15];circlename[0]="a";circlename[1]="b";circlename[2]="c";circlename[3]="d";circlename[4]="g";circlename[5]="e";circlename[6]="f";roadlength[0]=7;roadlength[1]=6;roadlength[2]=3;roadlength[3]=20;roadlength[4]=5;roadlength[5]=3;roadlength[6]=9;roadlength[7]=6;roadlength[8]=8;roadlength[9]=11;roadlength[10]=8;}public String[] getcirclename(){return circlename;}public int[] getroadlength(){return roadlength;}public int getcirclenum(){return circlenum;}public int getroadnum(){return roadnum;}}Shortpath.java 文件//求取最短路径public class ShortPath {int maxlength = 10000;int maxcirclenum = 30;ShortInit init;ShortCanvas canvas;String circlename[];String start, end;String path[];int arcs[][];int circlenum;int roadnum;int v0;int D[];ShortPath(String s1, String s2) {init = new ShortInit();canvas = new ShortCanvas();circlename = init.getcirclename();circlenum = init.getcirclenum();roadnum = init.getroadnum();start = s1;end = s2;arcs = canvas.getarcs();path = new String[circlenum];for (int p = 0; p < circlenum; p++)path[p] = start;for (int k = 0; k < circlenum; k++) {if (start.equals(circlename[k])) {v0 = k;}}shortestpath(v0);}public void shortestpath(int v0) {int v, i, w;int min;boolean finald[] = new boolean[maxcirclenum];D = new int[maxcirclenum];boolean p[][] = new boolean[maxcirclenum][maxcirclenum];for (v = 0; v < circlenum; v++) {finald[v] = false;D[v] = arcs[v0][v];for (w = 0; w < circlenum; ++w)p[v][w] = false;if (D[v] < maxlength) {p[v][v0] = true;p[v][v] = true;}}D[v0] = 0;finald[v0] = true;for (i = 1; i < circlenum; i++) {min = maxlength;for (w = 0; w < circlenum; w++)if (!finald[w])if (D[w] < min) {v = w;min = D[w];}finald[v] = true;path[v] = path[v] + "->" + circlename[v];for (w = 0; w < circlenum; w++) {if (!finald[w] && (min + arcs[v][w] < D[w])) {D[w] = min + arcs[v][w];path[w] = path[v];p[w][w] = true;}}}for (int j = 0; j < circlenum; ++j) {System.out.println(path[j] + ": "+ String.valueOf(D[j]) + "km");}}public String[] getpath() {return path;}public int[] getD() {return D;}}四、实验结果五、实验体会通过这次实验,懂得了如何通过邻接矩阵存储图,然后利用迪杰斯特拉算法算出最短路径。
离散数学 实验报告
离散数学实验报告离散数学实验报告一、引言离散数学是一门研究离散结构及其运算规则的数学学科,它在计算机科学、信息科学、通信工程等领域具有重要的应用价值。
本实验旨在通过实际案例,探索离散数学在现实生活中的应用。
二、实验目的本实验的目的是通过离散数学的理论知识,解决一个实际问题。
我们选择了图论中的最短路径问题作为案例,以展示离散数学在网络路由、物流规划等领域的应用。
三、实验过程1.问题描述我们的实验场景是一个城市的交通网络,其中各个交叉路口被看作是图的节点,而道路则是图的边。
我们需要找到两个给定节点之间的最短路径,以便规划出行路线。
2.建模为了解决这个问题,我们需要将实际情况抽象成数学模型。
我们将交通网络表示为一个有向图,每个节点代表一个交叉路口,每条边代表一条道路。
每条边上还需要标注距离或时间等权重。
3.算法选择在离散数学中,有多种算法可以解决最短路径问题,如迪杰斯特拉算法、弗洛伊德算法等。
根据实际情况和需求,我们选择了迪杰斯特拉算法。
4.算法实现我们使用编程语言实现了迪杰斯特拉算法,并将其应用于我们的交通网络模型。
算法的核心思想是通过不断更新节点之间的最短距离,逐步找到最短路径。
5.实验结果经过实验,我们成功找到了两个给定节点之间的最短路径,并计算出了最短距离。
这对于规划出行路线具有重要意义,可以帮助人们节省时间和资源。
四、实验总结通过这个实验,我们深入理解了离散数学在实际问题中的应用。
离散数学的概念和算法不仅仅是理论上的抽象,它们可以帮助我们解决现实生活中的复杂问题。
离散数学的应用远不止于此,它还可以用于密码学、数据压缩、人工智能等领域。
通过学习离散数学,我们能够培养出良好的抽象思维和问题解决能力,为未来的科学研究和工程实践打下坚实的基础。
总之,离散数学是一门具有广泛应用前景的学科,通过实验,我们对其应用领域有了更深入的了解。
希望未来能有更多的人关注和研究离散数学,为推动科学技术的发展做出贡献。
最短路径_Dijkstra算法__实验报告
最短路径_Dijkstra算法__实验报告实验六:编程实现Dijkstra 算法求最短路问题.1.需求分析:首先让用户输入一个带权的有向图,输入时可通过一对一对输入存在弧的两个弧头与弧尾顶点以及弧上的权值从而输入整个有向图。
用户输入一对对弧后,我们可以采用数组的形式来进行存储每个顶点之间的权值,最后由用户输入该有向图的源点(即每个最短路径的起点),要求源点必须为刚才输入的各顶点中的某一个,如果用户输入错误,程序要给出错误信息提示并退出程序。
然后,我们可以设计一个Graph这样的类,将对关系的各种操作放入其中,然后我们在主函数中调运这个类就可以实现最短路问题的求解了。
2.概要设计:①.构造一个新的类Graph:class Graph{private: int arcs[MAX][MAX],Path[MAX][MAX],D[MAX];int arcnum,vexnum,weight,v0;Type a,b,vexs[MAX];public:void Creat_Graph();void Show_ShortestPath();void ShortestPath_DIJ();};②.结构化调用类中方法的主函数:int main(){Graph G;G.Creat_Graph();G.ShortestPath_DIJ();G.Show_ShortestPath();return 0;}3.代码实现:#include#define MAX 100#define INFINITY INT_MAXenum BOOL{FALSE,TRUE};using namespace std;templateclass Graph{private: int arcs[MAX][MAX],Path[MAX][MAX],D[MAX]; int arcnum,vexnum,weight,v0;Type a,b,vexs[MAX];public:void Creat_Graph();void Show_ShortestPath();void ShortestPath_DIJ();};templatevoid Graph::Creat_Graph(){int i,j,x,y;cout<<"请输入你要处理的有向图中包含弧的个数:"; cin>>arcnum;vexnum=0;for(i=1;i<=MAX;i++)for(j=1;j<=MAX;j++)arcs[i][j]=INT_MAX;for(i=1;i<=arcnum;i++){cout<<"请依次输入第"<<i<<"条弧的弧头与弧尾的顶点以及该弧上所附带的权值:"<<endl;< p="">cin>>a>>b>>weight;x=0; y=0;for(j=1;j<=vexnum;j++){if(vexs[j]==a){x=j; continue;}else if(vexs[j]==b){y=j; continue;}}if(x==0){vexs[++vexnum]=a; x=vexnum;}if(y==0){vexs[++vexnum]=b; y=vexnum;}arcs[x][y]=weight;}cout<<"请输入该有向图的源点(即各最短路径的起始顶点):";cin>>a;for(i=1;i<=vexnum;i++){if(vexs[i]==a){v0=i; break;}}}templatevoid Graph:: Show_ShortestPath(){int i,j,k;for(i=1;i<=vexnum;i++){if(i==v0) continue;if(D[i]!=INT_MAX){cout<<"从源点"<<vexs[v0]<<"到"<<vexs[i]<<"的最短路径为:"<<endl;< p="">for(k=1;k<=Path[i][0];k++){if(k!=1)cout<<"-->";for(j=1;j<=vexnum;j++)if(Path[i][j]==k)cout<<vexs[j];< p="">}cout<<" "<<"其最短的路径长度为:"<<d[i]<<endl;< p="">}else{cout<<"无法从源点"<<vexs[v0]<<"到达顶点"<<vexs[i]<<"."<<endl;< p="">}}cout<<endl;< p="">}templatevoid Graph::ShortestPath_DIJ(){int v,w,final[MAX],min,i,j;for(v=1;v<=vexnum;v++){final[v]=FALSE; D[v]=arcs[v0][v]; Path[v][0]=0;for(w=0;w<=vexnum;w++)Path[v][w]=FALSE;if(D[v]<int_max)< p="">{ Path[v][v0]=++Path[v][0]; Path[v][v]=++Path[v][0]; }}D[v0]=0; final[v0]=TRUE;for(i=1;i<=vexnum;i++){if(i==v0) continue;min=INT_MAX;for(w=1;w<=vexnum;w++)if(!final[w])if(D[w]<="">final[v]=TRUE;for(w=1;w<=vexnum;w++)if(!final[w]&&(min+arcs[v][w]<d[w])&&min<int_max&&arcs [v][w]<int_max)< p="">{D[w]=min+arcs[v][w];for(j=0;j<=vexnum;j++)Path[w][j]=Path[v][j];Path[w][w]=++Path[w][0];}}}int main(){Graph G;G.Creat_Graph();G.ShortestPath_DIJ();G.Show_ShortestPath();return 0;}4.调试分析:起先在主函数中调用类Graph时将类型参数T赋值为int从而导致用户输入的关系集合R中的元素必须为整数。
《数据结构课程设计》最短路径问题实验报告
《数据结构课程设计》最短路径问题实验报告目录一、概述 0二、系统分析 0三、概要设计 (1)四、详细设计 (5)4.1建立图的存储结构 (5)4.2单源最短路径 (6)4.3任意一对顶点之间的最短路径 (7)五、运行与测试 (8)参考文献 (11)附录 (12)交通咨询系统设计(最短路径问题)一、概述在交通网络日益发达的今天,针对人们关心的各种问题,利用计算机建立一个交通咨询系统。
在系统中采用图来构造各个城市之间的联系,图中顶点表示城市,边表示各个城市之间的交通关系,所带权值为两个城市间的耗费。
这个交通咨询系统可以回答旅客提出的各种问题,例如:如何选择一条路径使得从A城到B城途中中转次数最少;如何选择一条路径使得从A城到B城里程最短;如何选择一条路径使得从A城到B城花费最低等等的一系列问题。
二、系统分析设计一个交通咨询系统,能咨询从任何一个城市顶点到另一城市顶点之间的最短路径(里程)、最低花费或是最少时间等问题。
对于不同的咨询要求,可输入城市间的路程、所需时间或是所需费用等信息。
针对最短路径问题,在本系统中采用图的相关知识,以解决在实际情况中的最短路径问题,本系统中包括了建立图的存储结构、单源最短问题、对任意一对顶点间最短路径问题三个问题,这对以上几个问题采用了迪杰斯特拉算法和弗洛伊德算法。
并未本系统设置一人性化的系统提示菜单,方便使用者的使用。
三、概要设计可以将该系统大致分为三个部分:①建立交通网络图的存储结构;②解决单源最短路径问题;③实现两个城市顶点之间的最短路径问题。
迪杰斯特拉算法流图:弗洛伊德算法流图:四、详细设计4.1建立图的存储结构定义交通图的存储结构。
邻接矩阵是表示图形中顶点之间相邻关系的矩阵。
设G=(V,E)是具有n 个顶点的图,则G 的邻接矩阵是具有如下定义的n 阶方阵。
⎪⎩⎪⎨⎧∞>∈<=,其他情况或或,若0E(G)V ,V )V ,(V ],[j i j i ij W j i A 注:一个图的邻接矩阵表示是唯一的!其表示需要用一个二维数组存储顶点之间相邻关系的邻接矩阵并且还需要用一个具有n 个元素的一维数组来存储顶点信息(下标为i 的元素存储顶点i V 的信息)。
最短路径问题实验报告
徐州工程学院管理学院实验报告实验课程名称:最短路径问题实验地点:南主楼七楼机房经济管理实验中心 2015 年 5 月至 2015 年 6 月},n;之间最短路时,每次都要计算i V 经过节点r V 到达点j V 的路长不会比原来的短,于是不用再计(1)1k k ir rjd d --+,进入下一个节点的搜索。
对于问题(2),构造一个序号矩阵()()k k ij A a =,(0,1,)k =,记录算法第二步中第k次迭代插入节点的情况.优化后的Floyd 算法(记为算法2)如下:第一步,作初始距离矩阵(0)(0)()ij D d =和序号矩阵(0)0)()ij A a =(,其中:(0),,(,1,2,3,),ij ij W i j d i j n i j ⎧==⎨∞⎩相邻对,,不相邻或无路时, (0)0,,,1,2,,,ij i j a i j n i j ⎧==⎨Φ⎩相邻时,(),不相邻或无路, 此时距离矩阵(0)D 中的元素(0)ij d 表示任意两点i V 、j V 不经过其它节点的路长。
第二步,构造迭代矩阵()()()k k ij D d =和序号矩阵(0))()k ij A a =(。
① 对于迭代矩阵()k D 的元素()k ij d : r 从1到n ,且,r i j ≠时,如果(1)(1)k k ir ijd d --≥或(1)(1)k k ri ij d d --≥,说明插入点r V 后路长(1)k ij d -不会变短,此时无须计算(1)1k k ir rjd d --+。
否则{}()(1)(1)(1)min ,k k k k ij ij ir rj d d d d ---=+。
② 相应地,序号矩阵()k A 的各元素变化为:若()(1)(1)k k k ij il lj d d d --=+,且(1)(1)k k ir rjd d --<,则记下点l V ,并在序号矩阵中()k A 对应的元素)k ij a (变为:{}()(1)(1),,k k k ij il l lj a a V a --=。
dijkstra最短路径算法步骤离散数学
dijkstra最短路径算法步骤离散数学Dijkstra最短路径算法是一种经典的图论算法,用于解决单源最短路径问题。
它由荷兰计算机科学家艾兹赫尔·迪科斯彻在1956年提出,被广泛应用于网络路由算法等领域。
Dijkstra算法的核心思想是通过不断更新节点之间的最短路径来找到从源节点到目标节点的最短路径。
在离散数学中,Dijkstra算法是一种十分重要的算法,在实际应用中也具有很高的效率和可靠性。
Dijkstra算法的步骤相对简单,但是需要一定的数学基础和思维逻辑。
首先,需要定义一个起始节点,将其到其他所有节点的距离初始化为无穷大,然后将其加入到一个集合中。
接着,选择集合中距离起始节点最近的节点作为当前节点,更新当前节点到其他节点的距离,如果通过当前节点到其他节点的距离比起始节点到其他节点的距离更短,则更新最短距离。
重复这个过程,直到所有节点都被遍历过一次,最终得到从起始节点到其他所有节点的最短路径。
在离散数学中,Dijkstra算法常常被用来解决网络连接、通信传输等问题。
例如,在计算机网络中,路由器通过Dijkstra算法计算最短路径,将数据包发送到目标地址,保证通信的快速和稳定。
又如在电力系统中,Dijkstra算法可以用来优化电网的输电路径,减少能量损耗,提高供电质量。
因此,学习和掌握Dijkstra算法对于离散数学的学习和实践具有重要意义。
除了Dijkstra算法,离散数学还包括许多其他重要的内容,如图论、集合论、逻辑推理等。
图论是离散数学的一个重要分支,研究图的性质和图之间的关系。
集合论是研究集合及其元素之间的关系和性质的数学分支,是数学中的基础理论之一。
逻辑推理是研究命题之间推理关系的数学分支,是数学和哲学的交叉领域。
这些内容共同构成了离散数学这门学科的基础,对于理解和应用数学知识具有重要意义。
总的来说,Dijkstra最短路径算法是离散数学中的一个重要内容,通过学习和掌握该算法,可以更好地理解和运用离散数学知识。
离散数学实验3报告
实验报告目录第一章实验概述 (3)1.1实验目的 (3)1.2实验内容 (3)1.3实验环境 (3)第二章实验原理和实现过程 (4)2.1实验原理 (4)2.1.1建立图的邻接矩阵, 判断图是否连通 (3)2.1.2 计算任意两个结点间的距离 (4)2.1.3对不连通的图输出其各个连通支 (5)2.2实验过程(算法描述) (5)2.2.1 程序整体思路 (5)2.2.2具体算法流程 (5)第三章实验数据及结果分析 (7)3.1建立图的邻接矩阵并判断图是否连通的功能测试及结果分析 (7)3.1.1输入无向图的边 (7)3.1.2建立图的连接矩阵 (8)3.2其他功能的功能测试和结果分析 (8)3.2.1计算节点间的距离 (8)3.2.2判断图的连通性 (8)3.2.3输出图的连通支 (8)3.2.4退出系统 (9)第四章实验收获和心得体会 (9)4.1实验收获 (9)4.2心得体会 (10)第五章实验源程序清单 (11)5.1程序代码 (11)第一章实验概述1.1 实验目的理解图论的基本概念, 图的矩阵表示, 图的连通性, 图的遍历, 以及求图的连通支方法。
通过实验, 帮助学生更好地掌握计算机科学技术常用的离散数学中的概念、性质和运算, 培养逻辑思维;通过实验提高学生编写实验报告、总结实验结果的能力, 提高理论联系实际的能力;使学生具备程序设计的思想, 能够独立完成简单的算法设计和分析。
1.2 实验内容以偶对的形式输入一个无向简单图的边, 建立该图的邻接矩阵, 判断图是否连通(A), 并计算任意两个结点间的距离(B), 对不连通的图输出其各个连通支(C)。
注意: 题目类型分为A, B, C三类, 其中A为基本题, 完成A类题目可达到设计的基本要求, 其他均为加分题, 并按字母顺序分数增加越高。
基本要求如下:程序需具有基本的容错控制, 在输入错误时有处理手段;程序界面友好, 需要输入的地方有输入说明, 说明输入的内容和格式要求等;实验原理和实现过程应该详细分析问题, 给出解决思路, 描述算法思想, 不能用源程序代替算法;测试数据应全面, 包括非法输入的处理结果等都应包含在内。
中衡实验三-最短路径算法分析与【设计明细】
学生实验报告学院:软件与通信工程学院课程名称:算法分析与设计专业班级:软件144班姓名:刘洋学号: 0144119学生实验报告一、实验综述1、实验目的及要求目的:(1)熟悉不同最短路径问题的求解的方法与一般技巧;(2)掌握算法、算法的实现;(3)掌握调试、改进算法程序基本方法;(4)熟悉两种方法在解决问题中的应用;要求:(1)自己生成问题实例;(2)报告不同算法在实验中的表现。
2、实验仪器、设备或软件仪器: 7/8/10软件:2013二、实验过程(实验步骤、记录、数据、分析)问题实例:利用图的最短路径原理为用户提供路径咨询,掌握求最短路径的算法并编程实现。
算法设计思想:弗洛伊德算法是用邻接矩阵表示带权有向图。
如果从顶点到有弧,则从到存在一条长度为[i][j]的路径,该路径不一定是最短路径,需要进行n次试探。
首先考虑路径(,V1,)是否存在(即判别弧(,v1)(v1,)是否存在),如果存在,则比较(,V1,)和(,)的路径长度,取较短者为从到的中间顶点序号不大于1的最短路径、在路径上再增加一个顶点v2,若(…2)和(v2 …)分别是当前找到的中间顶点序号不大于1的最短路径,则(2…)就有可能是从到的中间顶点的序号不大于2的最短路径。
将他和已经得到从到中间顶点序号不大于1的最短路径比较,从中选出长度较短者作为从到中间顶点序号不大于2的最短路径之后,再增加一个顶点v3,继续进行试探,依次类推。
在一般情况下,若(…)和(…)分别是从到和到的中间顶点序号不大于1的最短路径,则将(…, …)和已经得到的到且中间顶点序号不大于1的最短路径相比较,取其长度较短者作为从到的中间顶点序号不大于k的最短路径。
如此重复,经过n次比较,最后求的的必是从到的最短路径。
用此方法,课可同时求的每对顶点间的最短路径。
综上所述,佛洛依德算法的基本思想是递推的产生一个矩阵序列:a01,……,其中:a0[i][j][i][j];[i][j]{a(1)[i][j](1)[i][k](1)[j][k];}(1<<);由上述公式可以看出,a[i][j]是从到中间顶点序号不大于1的最短路径长度;[i][j]是从到中间顶点序号不大于1的最短路径长度;[i][j]是从到的最短路径长度。
离散数学最短通路的算法
离散数学最短通路的算法
离散数学最短通路算法是在图论中广泛使用的一种算法。
它的目的是找到图中两个节点之间的最短路径。
它可以用于许多实际应用中,例如网络路由,电路设计和交通规划等。
最短路径算法的基本思想是从初始节点开始,逐步向外扩展,直到找到目标节点。
在此过程中,算法维护一个距离图,记录每个节点到起始节点的距离。
最短路径算法有许多不同的实现方式。
其中最著名的是Dijkstra 算法。
该算法使用贪心策略,并且可以保证得到正确的解。
另一个常用的算法是Bellman-Ford算法,它可以处理带负权边的图。
该算法
使用动态规划的思想,并且可以检测负权环。
除了上述算法,还有许多其他算法可以用于求解最短路径问题。
例如,Floyd-Warshall算法可以计算图中所有节点之间的最短路径。
它使用动态规划的思想,并且可以处理带负权边的图。
总之,离散数学最短通路算法是图论中一个重要的主题,并且有许多不同的实现方式。
在实际应用中,需要根据具体的问题选择合适的算法来求解最短路径问题。
- 1 -。
运筹学最短路径实验(实验相关)
实验项目:最短路径问题 实验学时: 4实验日期:2012年11月30日 实验要求:案例 模型 分析实验内容:用最短路径模型解决具体问题前言运输是物流过程的主要职能之一,也是物流过程各项业务的中心活动。
物流过程中的其它各项活动,如包装、装卸搬运、物流信息等,都是围绕着运输而进行的。
可以说,在科学技术不断进步、生产的社会化和专业化程度不断提高的今天,一切物质产品的生产和消费都离不开运输。
物流合理化,在很大程度上取决于运输合理化。
所以,在物流过程的各项业务活动中,运输是关键,起着举足轻重的作用。
而有效的缩减路径可以使得运输费用降低。
本文运用Dijkstra 算法求出最短路径,以最大限度地节约运输费用降低物流成本,Dijkstra 算法用于求解最短路径问题最常用的方法之一。
Dijkstra 算法的基本步骤如下:(1)给起点1v 以P 标号()01=v p ,其余各点均给以T 标号,()∞+=i V T 。
(2)若i v 点为刚得到的p标号的点,考虑这样的点为j v ,考虑()j i v v ,这条边,且()j v 为T 标号,对j v 的T 标号进行如下更改()()()[]ij i j j l v P v T v T +=,min (3)比较所有具有T标号的点,把最小者改为P标号,即()()[]i v V P i min =,当存在两个以上最小者时,可同时改为P标号,若全部点均为P标号,则停止,否则-i v 代i v 改为第二步重做。
案例分析下图所示是某地区交通运输的示意图,试问从1v 出发,经哪条路线达到8v 才能使总行程最短?使用Dijkstra 求解。
2v 5 4v 9 6v4 4 75 41v 8v6 4 5 1 3v7 5v 6 7v 步骤:1. 首先给1v 以P 标号,()01=V P ,给其余所有的点以T 标号,()()8,,2,1 =+∞=i V T i2. (1)考察点1V ,边()()3121,,,V V V V()()()[][]()()()[][]660,min ,min 440,min ,min 1313312122=+∞+=+==+∞+=+=l V P V T V T l V P V T V T(2)比较所有T 标号()(){}32,V T V T ,()42=V T 最小,所以给2V 以P 标号,令()42=V P ,记录路径()21,V V3. (1) 2V 为刚得到P 标号的点,考察边()()5242,,,V V V V ()()()[][]954,m in ,m in 24244=+∞+=+=l V P V T V T ()()()[][]844,m in ,m in 25255=+∞+=+=l V P V T V T(2)比较所有T 标号,()()(){}543,,V T V T V T ,()63=V T 最小,给3V 以P 标号,令()63=V P ,记录路径()31,V V4. (1)3V 为刚得到P 标号的点,考察()()5343,,,V V V V()()()[][]946,9m in ,m in 34344=+=+=l V P V T V T ()()()[][]876,8m in ,m in 35355=+=+=l V P V T V T(2)比较所有T 标号,()(){}54,V T V T ,()85=V T 最小,给5V 以P 标号,令()85=V P ,记录路径()52,V V5. (1) 5V 为刚得到P 标号的点,考察()()7565,,,V V V V ()()()[][]1358,m in ,m in 56566=+∞+=+=l V P V T V T ()()()[][]1468,m in ,m in 57577=+∞+=+=l V P V T V T(2)比较所有T 标号,()()(){}764,,V T V T V T ,()94=V T 最小,给4V 以P 标号,令()94=V P ,记录路径()42,V V6. (1)4V 为刚得到P 标号的点,考察()()7464,,,V V V V ()()()[][]1399,13m in ,m in 46466=+=+=l V P V T V T ()()()[][]1479,14m in ,m in 47477=+=+=l V P V T V T(2) 比较所有T 标号,()(){}76,V T V T ,()136=V T 最小,给6V 以P 标号,令()136=V P ,记录路径()65,V V7. (1)6V 为刚得到P 标号的点,考察()()8676,,,V V V V ()()()[][]14413,14m in ,m in 67677=+=+=l V P V T V T ()()()[][]17413,m in ,m in 68688=+∞+=+=l V P V T V T(2)比较所有T 标号,()(){}87,V T V T ,()147=V T 最小,给7V 以P 标号,令()147=V P ,记录路径()75,V V8. (1)7V 为刚得到P 标号的点,考察()87,V V ()()()[][]15114,17m in ,m in 78788=+=+=l V P V T V T(2)比较所有T 标号,()158=V T 最小,给8V 以P 标号,令()158=V P ,记录路径()87,V V至此可以得到最短路径为87521V V V V V →→→→,最短行程为15实验总结科学合理的运输路线对物流的成本的大小影响很大。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验3:最短路径算法
一、实验目的
通过本实验的学习,理解Floyd(弗洛伊得)最短路径算法的思想
二、实验内容
用C语言编程实现求赋权图中任意两点间最短路径的Floyd算法,并能对给定的两结点自动求出最短路径
三、实验原理、方法和手段
1、Floyd算法的原理
定义:Dk[i,j] 表示赋权图中从结点vi出发仅通过v0,v1,┉,vk-1中的某些结点到达vj的最短路径的长度,
若从vi到vj没有仅通过v0,v1,┉,vk-1 的路径,则D[i,j]=∝即
D-1[i,j] 表示赋权图中从结点vi到vj的边的长度,若没有从结点vi到vj的边,则D[i,j]=∝
D0[i,j] 表示赋权图中从结点vi到vj的”最短”路径的长度, 这条路上除了可能有v0外没有其它结点
D1[i,j] 表示赋权图中从结点vi到vj的”最短”路径的长度, 这条路上除了可能有v0,v1外没有其它结点
┉┉┉
根据此定义,D k[i,j]=min{ D k-1[i,j] , D k-1[i,k-1]+D k-1[k-1,j] }
定义:path[i,j]表示从结点vi到vj的“最短”路径上vi的后继结点
四、实验要求
要求输出每对结点之间的最短路径长度以及其最短路径
五、实验步骤
(一)算法描述
Step 1 初始化有向图的成本邻矩阵D、路径矩阵path
若从结点vi到vj有边,则D[i,j]= vi到vj的边的长度,path[i,j]= i;
否则D[i,j]=∝,path[i,j]=-1
Step 2 刷新D、path 对k=1,2,┉n 重复Step 3和Step 4
Step 3 刷新行对i=1,2,┉n 重复Step 4
Step 4 刷新Mij 对j=1,2,┉n
若D k-1[i,k]+D k-1[k,j] <D k-1[i,j] ,则置D k[i,j]= D k-1[i,k]+D k-1[k,j],path[i,j]=k;否则不变
[结束循环]
[结束Step 3循环]
[结束Step 2循环]
Step 5 退出
(二)程序框图参考
主程序框图
其中,打印最短路径中间结点调用递归函数dist(),其框图如下,其中fist,end是当前有向边的起点和终点
dist(int first, int end)
七、测试用例:
1、输入成本邻接矩阵:D :0
6
3
805322901
4100
3210∝
∝
∝∝V V V V V V V V (其中∝可用某个足够大的数据值代替,比如100)
可得最短路径矩阵:P :1
31132122211
1
11010
1
03210--------V V V V V V V V
以及各顶点之间的最短路径和最短路径长度:
从V0到V1的最短路径长度为:1 ;最短路径为:V0→V1 从V0到V2的最短路径长度为:9 ;最短路径为:V0→V1→V3→V2 从V0到V3的最短路径长度为:3 ;最短路径为:V0→V1→V3 从V1到V0的最短路径长度为:11;最短路径为:V1→V3→V2→V0 从V1到V2的最短路径长度为:8 ;最短路径为:V1→V3→V2 从V1到V3的最短路径长度为:2 ;最短路径为:V1→V3 从V2到V0的最短路径长度为:3 ;最短路径为:V2→V0 从V2到V1的最短路径长度为:4 ;最短路径为:V2→V0→V1 从V2到V3的最短路径长度为:6 ;最短路径为:V2→V0→V1→V3 从V3到V0的最短路径长度为:9 ;最短路径为:V3→V2→V0 从V3到V1的最短路径长度为:10;最短路径为:V3→V2→V0→V1 从V3到V2的最短路径长度为:6 ;最短路径为:V3→V2 参考程序: #include <stdio.h> #define INFINITY 100 #define Max 10
int a[Max][Max],P[Max][Max]; main() {
void Print_Flod(int d);
int i,j,k,D=4;
printf("请输入成本邻接矩阵:\n");
for(i=0;i<D;i++)
for(j=0;j<D;j++)
{
scanf("%d",&a[i][j]);
}
for(i=0;i<D;i++)
for(j=0;j<D;j++)
{
if(a[i][j]>0&& a[i][j]<INFINITY) P[i][j]=i;
else
P[i][j]=-1;
}
for(k=0;k<D;k++)
for(i=0;i<D;i++)
for(j=0;j<D;j++)
if (a[i][k]+a[k][j]<a[i][j])
{
a[i][j]=a[i][k]+a[k][j];
P[i][j]=k;
}
Print_Flod(D);
}
void Print_Flod(int d)
{
void dist(int first,int end);
int i,j;
for(i=0;i<d;i++)
for(j=0;j<d;j++)
if(i!=j)
{ printf("from V%d to V%d: ",i,j);
dist(i,j);
printf("V%d",j);
printf(" (The length is: %d)\n",a[i][j]);
}
}
void dist(int first,int end)
{ int x;
x=P[first][end];
if(x!=first)
{ dist(first,x); dist(x,end); }
else printf("V%d->",x);
}
输出结果:。