最短路径分析(代码)
最短路径——floyd算法代码（c语言）
最短路径——floyd算法代码（c语⾔）最短路径问题昨天⾃⼰试了试写⼀下dijkstra的算法博客今天来更floyd算法，感觉⾮常简单果然暴⼒才是解决⼀切的王道⼀、总体思想floyd算法就是每⼀次从邻接矩阵选取⼀个顶点k，然后再去矩阵中遍历两个顶点i，j，看看是i→j的路径短，还是i→k→j的路径短，就是完全的暴⼒，算法和代码⾮常简单⼆、代码实现1void Floyd(Graph G)2 {3int arr[G.vexnum][G.vexnum];4for(int i = 0; i < G.vexnum; i++)5for(int j = 0; j < G.vexnum; i++)6 arr[i][j] = G.edge[i][j];78for(int k; k < G.vexnum; k++)9for(int i = 0; i < G.vexnum; i++)10for(int j = 0; j < G.vexnum; j++)11if(arr[i][j] > arr[i][k] + arr[k][j])12 arr[i][j] = arr[i][k] + arr[k][j];13 }三、代码解释其实看上⾯的代码量和代码就知道这个算法很简单 =_=传⼊Floyd算法的参数是Graph G⾸先开辟⼀个⼆维数组arr[][]，并且把图的邻接矩阵G.edge[][]赋值给arr[][]，算法的主要思想就是来修改arr[][]值暴⼒出最短路径1int arr[G.vexnum][G.vexnum];//开辟数组arr[][]接收图G.edge[][]的值2for(int i = 0; i < G.vexnum; i++)3for(int j = 0; j < G.vexnum; i++)4 arr[i][j] = G.edge[i][j];//遍历赋值然后就是每次选择⼀个顶点k，再去找两个顶点i，j，对⽐看看是i→j的路径短，还是i→k→j的路径短也就是arr[i][j] 和 arr[i][k] + arr[k][j]两个的值谁的⽐较⼩，然后修改arr[][]⼀直到遍历完毕1for(int k; k < G.vexnum; k++)//选取k顶点2for(int i = 0; i < G.vexnum; i++)3for(int j = 0; j < G.vexnum; j++)//再选取i，j两个顶点4if(arr[i][j] > arr[i][k] + arr[k][j])//判断i→j的路径和i→k→j的路径谁⽐较短5 arr[i][j] = arr[i][k] + arr[k][j];//如果i→k→j的路径更短，则修改数组arr[][]写完感觉好短。
网络分析(聚类系数、最短路径、效率)matlab代码汇总
nPATH=G; L=(nPATH~=0);
while find(L,1); D=D+n.*L; n=n+1; nPATH=nPATH*G; L=(nPATH~=0).*(D==0);
end
D(~D)=inf; D=D-eye(length(G));
%n-path matrix %shortest n-path matrix
% %Mika Rubinov, UNSW, 2007 (last modified July 2008)
%See comments for clustering_coef_bd %The weighted modification is as follows: %- The numerator: adjacency matrix is replaced with weights matrix ^ 1/3 %- The denominator: no changes from the binary version % %The above reduces to symmetric and/or binary versions of the % clustering coefficient for respective graphs.
function C=clustering_coef_bu(G) %C=clustering_coef_bu(G); clustering coefficient C, for binary undirected graph G % %Reference: Watts and Strogatz, 1998, Nature 393:440-442 % %Mika Rubinov, UNSW, 2007 (last modified September 2008)
最短路径万能Dijkstra算法必备代码
n=input('Please input the number of the notes: k='); %输入节点数目p=n*n;disp('Note: If there is no direct link between notes, use 100 to reprsent infinite');temp=input('Please input the k*k matrix of the length of path: M='); %输入路径长度矩阵while(prod(size(temp))~=p) %验证输入矩阵维数是否正确disp('please input the correct size of the matrix');temp=input('Please input the k*k matrix of the length of path: M='); endw=temp; %路径矩阵初始化i=input('Please identify the initial note: s='); %输入指定节点[s,d]=Dijkstra_sub(i,n,w)Dijkstra_sub函数代码如下：function [S,D]=Dijkstra_sub(i,m,W)dd=[];tt=[];ss=[];ss(1,1)=i;V=1:m;dd=[0;i];% dd的第二行是每次求出的最短路径的终点，第一行是最短路径的值kk=2;[mdd,ndd]=size(dd);while ~isempty(V)[tmpd,j]=min(W(i,V));tmpj=V(j);for k=2:ndd[tmp1,jj]=min(dd(1,k)+W(dd(2,k),V));tmp2=V(jj);tt(k-1,:)=[tmp1,tmp2,jj];endtmp=[tmpd,tmpj,j;tt];[tmp3,tmp4]=min(tmp(:,1));if tmp3==tmpdss(1:2,kk)=[i;tmp(tmp4,2)];elsetmp5=find(ss(:,tmp4)~=0);tmp6=length(tmp5);if dd(2,tmp4)==ss(tmp6,tmp4)ss(1:tmp6+1,kk)=[ss(tmp5,tmp4);tmp(tmp4,2)];elsess(1:3,kk)=[i;dd(2,tmp4);tmp(tmp4,2)];end;enddd=[dd,[tmp3;tmp(tmp4,2)]];V(tmp(tmp4,3))=[];[mdd,ndd]=size(dd);kk=kk+1; end;S=ss; D=dd(1,:);。
最短路径python实例
最短路径python实例当涉及到寻找图中两个节点之间的最短路径时，有多种算法可以使用。
在 Python 中，一个常见的实现最短路径的算法是 Dijkstra 算法。
以下是一个使用 Dijkstra 算法寻找图中最短路径的简单示例：```pythonimport sysclass Graph:def __init__(self, vertices):self.V = vertices # 顶点数self.graph = [[0 for column in range(vertices)] for row in range(vertices)] # 图的邻接矩阵def add_edge(self, u, v, w):self.graph[u][v] = w # 添加边 (u,v)，权重为 wdef dijkstra(self, src):distance = [sys.maxsize] * self.V # 初始化距离数组distance[src] = 0 # 源节点到自身的距离为 0path = [[] for _ in range(self.V)] # 初始化路径数组for _ in range(self.V):u = self.find_min_distance(distance) # 找到未访问节点中距离最小的节点path[u] = [u] # 更新路径数组for v in range(self.V):if self.graph[u][v] > 0 and distance[v] > distance[u] + self.graph[u][v]: # 更新距离，如果通过 u 到 v 的路径更短distance[v] = distance[u] + self.graph[u][v]return pathdef find_min_distance(self, distance):min_distance = sys.maxsizemin_index = -1for i in range(self.V):if distance[i] < min_distance:min_distance = distance[i]min_index = ireturn min_index# 创建一个有 9 个顶点的图g = Graph(9)# 添加边g.add_edge(0, 1, 4)g.add_edge(0, 7, 8)g.add_edge(1, 2, 8)g.add_edge(1, 7, 11)g.add_edge(2, 3, 7)g.add_edge(2, 8, 2)g.add_edge(3, 4, 9)g.add_edge(3, 5, 14)g.add_edge(4, 5, 10)g.add_edge(5, 6, 2)g.add_edge(5, 8, 6)g.add_edge(6, 7, 1)g.add_edge(6, 8, 7)g.add_edge(7, 8, 4)# 找到源节点到每个节点的最短路径shortest_path = g.dijkstra(0)# 打印最短路径for i in range(g.V):print(f"从源节点到节点 {i} 的最短路径: {shortest_path[i]}")```这个示例中，我们首先定义了一个图的类 `Graph`，然后创建了一个有 9 个顶点的图，并添加了一些边。
动态规划之最短路径源代码
动态规划之最短路径问题源代码#include "stdio.h"#include "conio.h"#define n 16 /*图的顶点数*/#define k 7 /*图的段数*/#define l 30#define MAX 100typedef int NodeNumber;/*节点编号*/typedef int CostType;/*成本值类型*/CostType cost[n][n];NodeNumber path[k];NodeNumber cur=-1;void creategraph(CostType *cost[n][n]) /*创建图的成本矩阵*/ {int i,j,x,y,value;for(i=0;i<n;i++)for(j=0;j<n;j++) cost[i][j]=0;printf("\nEnter the cost of graph:\n");for(i=0;i<l;i++){scanf("%d,%d,%d",&x,&y,&value);cost[x][y]=value;}}void outgraph(CostType *cost[n][n]) /*输出图的成本矩阵*/ {int i,j;printf("Print the cost of graph:\n");for(i=0;i<n;i++){for(j=0;j<n;j++) printf("%2d",cost[i][j]);printf("\n");}}/*使用向前递推算法求多段图的最短路径*/void FPath(CostType *cost[n][n],NodeNumber *path[k]) {int i,j,leng,temp,v[n],d[n];for(i=0;i<n;i++) v[i]=0;for(i=n-2;i>=0;i--){ leng=MAX;for(j=i+1;j<=n-1;j++)if(cost[i][j]>0 && (cost[i][j]+v[j])<leng){leng=cost[i][j]+v[j];temp=j;}v[i]=leng;d[i]=temp;}path[0]=0;path[k-1]=n-1;for(i=1;i<=k-2;i++) path[i]=d[path[i-1]]; }/*输出最短路径序列*/void outpath(NodeNumber *path[k]){int i;printf("\nPrint the shortest treet:\n");for(i=0;i<k;i++) printf("%3d",path[i]); }main(){NodeNumber m,t;creategraph(&cost);outgraph(&cost);FPath(&cost,&path);outpath(&path);}。
最短路径 源代码
final[v]=FALSE; D[v]=G.arcs[v0][v]; for ( w=0;w<G.vexnum;++w)
P[v][w]=FALSE; if (D[v]<INFINITY) {
#include <stdio.h> #include <stdlib.h>
#define INT_MAX 2147483647 #define INFINITY INT_MAX #define FALSE 0 #define TRUE 1 #define NumVertices 6 //图中最大顶点个数 typedef int PathMatrix[NumVertices][NumVertices]; //最短路径数组 typedef int ShortPathTable[NumVertices]; //最短路径长度 typedef int AdjMatrix[NumVertices][NumVertices]; typedef char VertexType; typedef struct{ VertexType vexs[NumVertices]; AdjMatrix arcs; //邻接矩阵 int vexnum,arcnum; }MGraph;
void ShortestPath_DIJ(MGraph G,int v0,PathMatrix &P,ShortPathTable &D) { //D[v]为带权长度 //若 P[v][w]为 TRUE,则 w 是从 v0 到 v 当前求的最短路径上的顶点 //final[v]为 TRUE 当且仅当 V∈V-S,即已经求得 v0 到 V 的最短路径 //final[v]=TRUE 也就是将 v 加入到 S
Floyd算法求解最短路径问题(完整程序代码)
引言在图论中经常会遇到这样的问题，在一个有向图里求出任意两个节点之间的最短距离。
当节点之间的权值是正值的时候，我们可以采用Dijkstra算法，用贪心策略加于解决。
但当节点之间的权值有负数的时候，Dijkstra就行不通了，这里介绍另外一种算法—Floyd最短路径算法。
对于任意图，选择存储结构存储图并实现FLOYD算法求解最短路经。
将问题分解，分解为两方面。
一是对于任意图的存储问题，第二个是实现FLOYD算法求解最短路经。
首先对于图的创建选择合适的存储结构进行存储，对于合适的存储结构可以简化程序。
本实验采用邻接矩阵存储。
然后是实现FLOYD算法求解最短路经，在FLOYD算法中路径的长度即是图中两定点间边的权值，FLOYD算法要求输出任意两个顶点间的最短路径，而且经过的顶点也要输出。
考虑到问题的特殊性，采用一个二维数组和一个三维数组进行存储。
二维数组存储最短路径，三维数组存储路径经过的顶点，在进行适当的算法后对这两个数组进行输出即可。
通过问题的分解，逐个解决，事先所要求的程序。
最短路径算法问题是计算机科学、运筹学、地理信息系统和交通诱导、导航系统等领域研究的一个热点。
传统的最短路径算法主要有Floyd算法和Dijkstra算法。
Floyd算法用于计算所有结点之间的最短路径。
Dijkstra算法则用于计算一个结点到其他所有结点的最短路径。
Dijkstra算法是已经证明的能得出最短路径的最优解，但它的效率是一个很大的问题。
对于具有n个结点的一个图，计算一个结点到图中其余结点最短路径的算法时间复杂度为O(n2)。
对于一座大中型城市，地理结点数目可能达到几万个到几十万个，计算最短路径的时间开销将是非常巨大的。
本文根据吴一民老师的建议，分析当前存在的各种求最短路径的算法，提出一种新的基于层次图的最短路径算法，即将一个平面图划分若干子图，子图抽象为一个高层图。
最短路径的计算首先在高层图中进行，缩小了最短路径的查找范围，降低了最短路径计算的时间开销。
最短路径算法及代码实现
最常用的路径算法有：
[编辑]Dijkstra算法
详细介绍
Dijkstra复杂度是O(N^2)，如果用binary heap优化可以达到O((E+N)logN)，用fibonacci heap 可以优化到O(NlogN+E)
其基本思想是采用贪心法，对于每个节点v[i]，维护估计最短路长度最大值，每次取出一个使得该估计值最小的t，并采用与t相连的边对其余点的估计值进行更新，更新后不再考虑t。
在此过程中，估计值单调递减，所以可以得到确切的最短路。
Dijkstra 程序：
详细介绍
Bellman-Ford主要是用于赋权图。
Bellman-Ford算法即标号修正算法。
实践中常用到的方法通常是FIFO标号修正算法和一般标号修正算法的Dequeue实现。
前者最坏时间复杂度是O(nm), 是解决任意边权的单源最短路经问题的最优强多项式算法。
也可以用这个算法判断是否存在负权回路.
SPFA算法
SPFA就是bellmanford的一种实现方式。
SPFA算法就是上面说的FIFO标号修正算法, 请参见《网络流：理论、算法与应用》。
SPFA程序：。
C语言自动生成查找迷宫最短路径的代码
C语言自动生成查找迷宫最短路径的代码#include#include#include#include#includeusing namespace std;#define OVERFLOW 0#define OK 1#define ERROE 0#define TRUE 1#define FALSE 0#define SIZE 102//迷宫的最大范围typedef int Status;typedef struct{int x;int y;}PosType;//坐标位置typedef struct {PosType seat; //通道块在迷宫中的"坐标位置"int di; //从上一通道块走向此通道块的"方向"}SElemType;void Random(int (*mg)[SIZE],int size,PosType start,PosType end);/*随机生成迷宫的函数/*为了能够让尽量能通过，将能通过的块和不能通过的块数量比大致为3:1*/Status Pass(PosType e,int (*mg)[SIZE]);//当前块可否通过Status FootPrint(PosType e,int (*mg)[SIZE]);//留下通过的足迹PosType NextPos(PosType e,int dir);//下一步Status Equal(PosType e1,PosType e2);//e1与e2的位置坐标是否相同Status MarkPath(PosType e,int (*mg)[SIZE],int di);//对最短可行路径上的“通道块”进行标记PosType FrontPos(PosType e,int dir);//寻找当前通道块的上一步的位置Status PathPrint(stack s,int (*mg)[SIZE]);//迷宫最短路径的标记Status PathClean(int (*mg)[SIZE],stack s);//路径清除Status MazePath(PosType start,PosType end,int (*mg)[SIZE],stack &s);/*迷宫函数/* 若迷宫maze中从入口start到出口end的通道，则求得一条存放在栈中/* 并返回TRUE；否则返回FALSE*/void PrintMaze(int (*mg)[SIZE],int size);//打印迷宫Status Check(char &choice);//确认输入正确int main(){stack s;int mg[SIZE][SIZE]={1},size;PosType start,end;char choice;system("mode con cols=220 lines=220");printf("\n==================迷宫最短路径游戏==================");printf("\n说明:■不能走的区域");printf("\n '空格'代表可通过的区域");printf("\n默认起点为左上角位置，默认终点为右下角位置\n");printf("\n================================ ============\n");printf("请输入迷宫边长(3~%d),系统将为你产生一个随机迷宫：",SIZE-2);scanf("%d",&size);while((size>SIZE-2)||(size<1)){printf("输入有误！\n");printf("请输入迷宫边长(3~%d),系统将为你产生一个随机迷宫：",SIZE-2);scanf("%d",&size);}size+=2;//补上外围getchar();//跳过'\n'start.x=1;start.y=1; //起点坐标end.x=size-2;end.y=size-2; //终点坐标Random(mg,size,start,end);PrintMaze(mg,size);while(!((choice=='Q')||(choice=='q'))){printf("是否使用该迷宫?(y/n)\n");Check(choice);if((choice=='Y')||(choice=='y')){PathClean(mg,s);}while((choice=='n')||(choice=='N')){while(!s.empty())s.pop();choice=' ';printf("请输入迷宫边长(3~%d),系统将为你产生一个随机迷宫：",SIZE-2);scanf("%d",&size);while((size>SIZE-2)||(size<1)){printf("输入有误！\n");printf("请输入迷宫边长(3~%d),系统将为你产生一个随机迷宫：",SIZE-2);scanf("%d",&size);}size+=2;//补上外围start.x=1;start.y=1;//起点坐标end.x=size-2;end.y=size-2; //终点坐标getchar();//跳过'\n'Random(mg,size,start,end);PrintMaze(mg,size);printf("是否使用该迷宫?(y/n)\n");Check(choice);}printf("是否人工选择起点和终点(y/n)?【默认：起点(1,1),终点(%d,%d)】\n",size-2,size-2);Check(choice);if((choice=='y')||(choice=='Y')){printf("请输入“起点”坐标(1~%d)用空格分隔：",size-2);scanf("%d %d",&start.x,&start.y);while(((start.x>size-2)||start.x<1)||((start.y>size-2)||(start.y<1))||!Pass(start,mg)){if(!Pass(start,mg)) printf("些位置不能为“起点”！\n");else printf("输入有误！\n");printf("请输入“起点”坐标(1~%d)用空格分隔：",size-2);scanf("%d %d",&start.x,&start.y);}printf("请输入“终点”坐标(1~%d)用空格分隔：",size-2);scanf("%d %d",&end.x,&end.y);while(((end.x>size-2)||end.x<1)||((end.y>size-2)||(end.y<1))||!Pass(end,mg)||Equal(start,end)){if(!Pass(end,mg)) printf("些位置不能为“终点”！\n");else if(Equal(start,end)) printf("该位置已为起点！\n");else printf("输入有误！\n");printf("请输入“终点”坐标(1~%d)用空格分隔：",size-2);scanf("%d %d",&end.x,&end.y);}getchar();//跳过'\n'}MazePath(start,end,mg,s);PrintMaze(mg,size);printf("退出游戏请输入\"Q\"否则继续游戏！\n");choice=getchar();getchar();//跳过'\n'}printf("\n==========程序退出，感谢使用!==========\n");return 0;}void Random(int (*mg)[SIZE],int size,PosType start,PosType end){int i,j,k;srand(time(NULL));for(j=0;j<size;j++)mg[0][j]=mg[size-1][j]=1; /*设置迷宫外围"不可走"，保证只有一个出口和入口*/for(i=1;i<size-1;i++)mg[i][0]=mg[i][size-1]=1; /*设置迷宫外围"不可走"，保证只有一个出口和入口*/for(i=1;i<size-1;i++)for(j=1;j<size-1;j++){k=rand()%4; //随机生成0、1、2、4三个数if(k)mg[i][j]=0;else{mg[i][j]=1;}//else}mg[start.y][start.x]=0;mg[end.y][end.x]=0; //将入口、出口设置为"0"即可通过}Status Pass(PosType e,int (*mg)[SIZE]){if (mg[e.y][e.x]==0) //0时可以通过return OK; // 如果当前位置是可以通过，返回1 return OVERFLOW; // 其它情况返回0}Status FootPrint(PosType e,int (*mg)[SIZE]){mg[e.y][e.x]=7;return OK;}PosType NextPos(PosType e,int dir){PosType E;switch(dir){case 1:E.x=e.x+1; //向右E.y=e.y;break;case 2:E.x=e.x; //向下E.y=e.y+1;break;case 3:E.x=e.x-1; //向左E.y=e.y;break;case 4:E.x=e.x; //向上E.y=</size-1;j++){</size-1;i++)</size-1;i++)</size;j++)e.y-1;break;}return E;}Status Equal(PosType e1,PosType e2){if((e1.x==e2.x)&&(e1.y==e2.y))return TRUE;return FALSE;}Status MarkPath(PosType e,int (*mg)[SIZE],int di) {switch(di){case 1://向右mg[e.y][e.x]=11;break;case 2://向下mg[e.y][e.x]=12;break;case 3://向左mg[e.y][e.x]=13;break;case 4://向上mg[e.y][e.x]=14;break;}return OK;}PosType FrontPos(PosType e,int dir) {PosType E;switch(dir){case 1:E.x=e.x-1; //向左E.y=e.y;break;case 2:E.x=e.x; //向上E.y=e.y-1;break;case 3:E.x=e.x+1; //向右E.y=e.y;break;case 4:E.x=e.x; //向下E.y=e.y+1;break;}return E;}Status PathPrint(stack s,int (*mg)[SIZE]) {SElemType e,front,tail;int di;e=s.top();tail=e;s.pop();MarkPath(e.seat,mg,1);while(!s.empty()){front=s.top();s.pop();if(Equal(front.seat,FrontPos(e.seat,e.di))) {di=e.di;e=front;MarkPath(e.seat,mg,di);}}mg[tail.seat.y][tail.seat.x]=20;mg[e.seat.y][e.seat.x]=10;return OK;Status PathClean(int (*mg)[SIZE],stack s){SElemType e;while(!s.empty()){e=s.top();s.pop();mg[e.seat.y][e.seat.x]=0;}return OK;}Status MazePath(PosType start,PosType end,int (*mg)[SIZE],stack &s){queue q;SElemType e;int di=0;e.di=di;e.seat=start;// 设定"当前位置"为"入口位置"q.push(e);s.push(e);do{e=q.front();q.pop();for(di=1;di<=4;di++)e.seat=NextPos(e.seat,di);e.di=di;if(Pass(e.seat,mg)){q.push(e);s.push(e);FootPrint(e.seat,mg);if(Equal(e.seat,end)){PathPrint(s,mg);return TRUE;}}e.seat=FrontPos(e.seat,di);}}while(!q.empty());printf("\n\n囧 ! 不能到达终点!"); return FALSE;}void PrintMaze(int (*mg)[SIZE],int size) {int i,j;printf("\n");for(i=0;i<size;i++){for(j=0;j<size;j++){switch(mg[i][j]){case 0: case 7: printf(" "); break; case 1: printf("■"); break; case 10: printf("起"); break; case 20: printf("终"); break; case 11: printf("→"); break; case 12: printf("↓"); break; case 13: printf("←"); break; case 14: printf("↑"); break;}}printf("\n"); }printf("\n");}Status Check(char &choice){while(!(((choice=getchar())=='y')||(choice=='n')||(choice=='Y ')||(choice=='N')))//非正确输入{if(choice!='\n'){printf("请输入确定选择(y/n)\n");getchar();}}getchar();//跳过'\n'return OK;}</size;j++){</size;i++){。
【数据结构算法】实验8-图的最短路径问题（附源代码）
【数据结构算法】实验8-图的最短路径问题（附源代码）浙江大学城市学院实验报告课程名称数据结构与算法实验项目名称实验八图的最短路径问题实验成绩指导老师（签名）日期一.实验目的和要求1.掌握图的最短路径概念。
2.理解并能实现求最短路径的DijKstra算法（用邻接矩阵表示图）。
二. 实验内容1、编写用邻接矩阵表示有向带权图时图的基本操作的实现函数，基本操作包括：① 初始化邻接矩阵表示的有向带权图void InitMatrix(adjmatrixG);② 建立邻接矩阵表示的有向带权图 void CreateMatrix(adjmatrix G, int n) （即通过输入图的每条边建立图的邻接矩阵）;③ 输出邻接矩阵表示的有向带权图void PrintMatrix(adjmatrix G, int n) （即输出图的每条边）。
把邻接矩阵的结构定义以及这些基本操作函数存放在头文件Graph2.h中。
2、编写求最短路径的DijKstra算法函数 void Dijkstra( adjmatrix GA, int dist[], edgenode *path[], int i, int n) ，该算法求从顶点i到其余顶点的最短路径与最短路径长度，并分别存于数组path 和dist 中。
编写打印输出从源点到每个顶点的最短路径及长度的函数void PrintPath(int dist[], edgenode *path[], int n)。
3、编写测试程序（即主函数），首先建立并输出有向带权图，然后计算并输出从某顶点v0到其余各顶点的最短路径。
要求：把指针数组的基类型结构定义edgenode、求最短路径的DijKstra算法函数、打印输出最短路径及长度的函数PrintPath以及主函数存放在文件test9_2.cpp中。
测试数据如下：4、填写实验报告，实验报告文件取名为report8.doc。
5、上传实验报告文件report8.doc与源程序文件test9_2.cpp及Graph2.h到Ftp服务器上自己的文件夹下。
dijkstra算法代码c语言
dijkstra算法代码c语言Dijkstra算法代码C语言简介Dijkstra算法是一种用于寻找带权有向图中最短路径的经典算法。
它由荷兰计算机科学家Edsger Dijkstra于1956年发明。
本文将介绍Dijkstra算法的基本原理和用C语言实现的代码。
算法原理1.初始化：设定一个起始点，将起始点到其他所有点的距离初始为无穷大，将起始点到自身的距离设为0，创建一个空的集合用于存放已找到最短路径的点。
2.选取最短路径：从未找到最短路径的点中选择一个距离起始点最近的点，将其加入到已找到最短路径的点的集合中。
3.更新距离：对于新加入的点，更新它周围点到起始点的最短距离。
如果通过新加入的点到达某个点的距离比当前已知最短距离小，则更新该点的最短距离。
4.重复步骤2和步骤3，直到所有点都找到最短路径。
C语言实现下面是用C语言实现Dijkstra算法的代码：#include <>#include <>#define SIZE 10#define INFINITY 9999void dijkstra(int graph[SIZE][SIZE], int startNode) {int distance[SIZE];bool visited[SIZE];for (int i = 0; i < SIZE; i++) {distance[i] = INFINITY;visited[i] = false;}distance[startNode] = 0;for (int count = 0; count < SIZE - 1; count++) {int minDistance = INFINITY;int minIndex;for (int i = 0; i < SIZE; i++) {if (!visited[i] && distance[i] <= minDistanc e) {minDistance = distance[i];minIndex = i;}}visited[minIndex] = true;for (int i = 0; i < SIZE; i++) {if (!visited[i] && graph[minIndex][i] && dis tance[minIndex] != INFINITY &&distance[minIndex] + graph[minIndex][i] < distance[i]) {distance[i] = distance[minIndex] + graph [minIndex][i];}}}printf("最短路径为:\n");for (int i = 0; i < SIZE; i++) {printf("%d 到 %d 的距离: %d\n", startNode, i, di stance[i]);}}int main() {int graph[SIZE][SIZE] = {{0, 6, 0, 1, 0},{6, 0, 5, 2, 2},{0, 5, 0, 0, 5},{1, 2, 0, 0, 1},{0, 2, 5, 1, 0}};int startNode = 0; // 起始点的索引dijkstra(graph, startNode);return 0;}总结Dijkstra算法是解决最短路径问题的一种有效方法。
单源最短路径c语言代码
单源最短路径c语言代码以下是Dijkstra算法的C语言代码实现，用于求解单源最短路径：```。
#include <stdio.h>。
#include <limits.h>。
#define V 6 // 图中顶点数。
//定义一个宏，用于查找尚未处理的最短路径的节点。
#define minDistance(dist, visited) \。
({ int min = INT_MAX, index; \。
for (int i = 0; i < V; i++) \。
if (!visited[i] && dist[i] <= min) \。
min = dist[i], index = i; \。
index; })。
void dijkstra(int graph[V][V], int src) 。
int dist[V]; // 存储从源点到各顶点的距离。
bool visited[V]; // 标记顶点是否被处理。
for (int i = 0; i < V; i++) 。
dist[i] = INT_MAX;。
visited[i] = false;。
}。
dist[src] = 0;。
for (int i = 0; i < V - 1; i++) 。
int u = minDistance(dist, visited);。
visited[u] = true;。
for (int j = 0; j < V; j++) 。
if (!visited[j] && graph[u][j] && dist[u] != INT_MAX &&。
dist[u] + graph[u][j] < dist[j])。
dist[j] = dist[u] + graph[u][j];。
}。
}。
printf("顶点距离源点的距离\n");。
0001Dijkstra算法找最短路径代码
克拉算法的核心就是从原点出发（原点可以是自己定义的任意一个点），以原点为圆心，半径从小到大，判断原点到半径上面的点的最短距离，这个距离可能是圆心r0->r1（半径较小）->r2（半径较大）或者是r0->r2（如果存在r0到r2这条路径的话）例某公司在六个城市c1, c2,,,, c6 中有分公司，从ci到cj 的直接航程票价记在下述矩阵的(i, j) 位置上。
（∞表示无直接航路），请帮助该公司设计一张城市c1 到其它城市间的票价最便宜的路线图。
符号含义：用矩阵a[n,n]（n 为顶点个数）存放各边权的邻接矩阵，行向量pb 、index1、index2 、d 分别用来存放P 标号信息、标号顶点顺序、标号顶点索引、最短通路的值。
其中分量index2(i) 存放始点到第i 点最短通路中第i 顶点前一顶点的序号；d(i) 存放由始点到第i 点最短通路的值。
求第一个城市到其它城市的最短路径的Matlab 程序如下：（可以直接复制下方代码运行）其中a(1,2)表示第一个点到第二个点的距离，以此类推，在实际应用中先把所有点直接的距离矩阵写出来，不连通的点用无穷大表示clc,clear alla=zeros(6);a(1,2)=50;a(1,4)=40;a(1,5)=25;a(1,6)=10;a(2,3)=15;a(2,4)=20;a(2,6)=25;a(3,4)=10;a(3,5)=20;a(4,5)=10;a(4,6)=25;a(5,6)=55;a=a+a'a(find(a==0))=inf %将a=0的数全部替换为无强大pb(1:length(a))=0;pb(1)=1; %当一个点已经求出到原点的最短距离时，其下标i对应的pb(i)赋1index1=1; %存放存入S集合的顺序index2=ones(1,length(a)); %存放始点到第i点最短通路中第i顶点前一顶点的序号d(1:length(a))=inf;d(1)=0; %存放由始点到第i点最短通路的值temp=1; %temp表示c1,算c1到其它点的最短路。
Dijkstra算法，最短路径路由算法matlab代码
Dijkstra算法，最短路径路由算法matlab代码Dijkstra算法是⼀种最短路径路由算法，⽤于计算⼀个节点到其他所有节点的最短路径。
主要特点是以起始点为中⼼向外层层扩展，直到扩展到终点为⽌。
Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率较低。
算法详细解释各⽹站都有，不太难。
下边是对下图从D开始到A节点寻找最短路径的matlab代码，个⼈原创。
%% Dijkstra算法%by Jubobolv369 at 2022/1/22clc;clear;close all;%% 初始化带权邻接矩阵,起点、终点等initRoute=[0 12 inf inf inf 16 14;12 0 10 inf inf 7 inf;inf 10 0 3 5 6 inf;inf inf 3 0 4 inf inf;inf inf 5 4 0 2 8;16 7 6 inf 2 0 9;14 inf inf inf 8 9 0;];[row,column]=size(initRoute);start_node=4;end_node=1;close_list=[];open_list=[];%closelist中加⼊初始节点close_list=[start_node,start_node,0];%% 如果closelist中没有终点，则遍历节点，通过⽐较逐渐加⼊节点到closelist。
while isempty(find(close_list(:,1) == end_node))[last1,~]=size(close_list);%获取closelist的最后⼀⾏的索引now_node=close_list(last1,1);%当前节点编号now_length=close_list(last1,3);%当前最优长度[last2,~]=size(open_list); %%获取openlist的最后⼀⾏的索引now_list=initRoute(now_node,:); %从原始矩阵中取初当前节点的边权值i=1;%% 更新openlistfor j=1:column%如果第j个节点可达、不是⾃⾝且不在close_list中，该点可能需要改动或添加到openlist中if now_list(j)~=inf && now_list(j)~=0 && isempty(find(close_list(:,1) == j))if last1==1open_list(i,1)=j;open_list(i,2)=now_node;open_list(i,3)=now_list(j);i=i+1;%如果不在openlist中，就将其添加到其中,否则将通过当前⽗节点到此节点的权值与之前的作⽐较elsek=find(open_list(:,1) == j);if isempty(k)open_list(last2+i,1)=j;open_list(last2+i,2)=now_node;open_list(last2+i,3)=now_list(j)+now_length;i=i+1;elseif open_list(k,3)>(now_list(j)+now_length) %若現在的路徑⾧度⼩，則更新路徑open_list(k,1)=j;open_list(k,1)=j;open_list(k,2)=now_node;open_list(k,3)=now_list(j)+now_length;endendendend%% 更新closelist和openlist。
最短路径算法floyd代码
最短路径算法floyd代码1.引言1.1 概述最短路径算法是图论中一个重要的问题，它的目标是找到两个节点之间最短的路径。
在实际生活中，最短路径算法被广泛应用于交通规划、物流配送、通信网络等领域。
针对不同类型的图，有不同的最短路径算法可供选择，其中Floyd算法是一种被广泛使用的算法之一。
Floyd算法是一种动态规划算法，它通过逐步优化图中各个节点之间的最短路径长度来求解最短路径。
其基本思想是通过计算任意两个节点之间的中间节点，以确定最短路径的中间节点集合。
通过反复迭代更新中间节点集合，最终可以得到节点之间的最短路径长度。
本文将介绍Floyd算法的原理和实现代码。
首先，我们将详细解释Floyd算法的原理，包括其计算最短路径的思路和步骤。
接着，我们将给出Floyd算法的代码实现，通过具体的编程示例来展示算法的具体实现过程和运行结果。
本文的目的是帮助读者了解Floyd算法，并通过实例代码帮助读者理解算法的具体实现步骤。
读者可以通过学习和实践运用Floyd算法，为实际问题寻找最短路径提供一种有效的解决方案。
此外，本文还将总结Floyd 算法的优缺点，以及对该算法在实际应用中的一些考虑和限制。
通过阅读本文并实践代码，读者将能够更好地理解Floyd算法的原理和实现方法，并在实际问题中灵活运用该算法来解决最短路径问题。
无论是对于图论的研究者还是对于应用场景中的实际需求，本文都将提供一些有价值的参考和启示。
在接下来的章节中，我们将逐步介绍Floyd算法的详细原理和代码实现。
让我们一起开始这段有趣的学习之旅吧！文章结构（Article Structure）本篇文章主要围绕最短路径算法Floyd展开讨论，按照以下结构进行阐述。
1. 引言1.1 概述：对最短路径算法的背景和应用进行简要介绍，强调其在网络通信、路线规划和图论等领域的重要性。
1.2 文章结构：本节内容。
1.3 目的：明确本文旨在通过介绍Floyd算法的原理和代码实现，帮助读者理解和应用该算法。
最短路径——dijkstra算法代码（c语言）
最短路径——dijkstra算法代码（c语⾔）最短路径问题看了王道的视频，感觉云⾥雾⾥的，所以写这个博客来加深理解。
（希望能在12点以前写完）（）⼀、总体思想1.初始化三个辅助数组s[],dist[],path[]s[]:这个数组⽤来标记结点的访问与否，如果该结点被访问，则为1，如果该结点还没有访问，则为0；dist[]:这个数组⽤来记录当前从v到各个顶点的最短路径长度，算法的核⼼思想就是通过不断修改这个表实现； path[]:这个数组⽤来存放最短路径；2.遍历图，修改上⾯的各项数组，每次只找最短路径，直到遍历结束⼆、代码实现1void dijkstra(Graph G, int v)2 {3int s[G.vexnum];4int dist[G.vexnum];5int path[G.vexnum];6for(int i = 0; i < G.vexnum; i++)7 {8 s[i] = 0;9 dist[i] = G.edge[v][i];10if(G.edge[v][i] == max || G.edge[v][i] == 0)11 {12 path[i] = -1;13 }14else15 {16 path[i] = v;17 }18 s[v] = 1;19 }2021for(int i = 0; i < G.vexnum; i++)22 {23int min = max;24int u;25for(int j = 0; j < G.vexnum; j++)26 {27if(s[j] != 1 && dist[j] < min)28 {29 min = dist[j];30 u = j;31 }32 }33 s[u] = 1;34for(int j = 0; j < G.vexnum; j++)35 {36if(s[j] != 1 && dist[j] > dist[u] + G.edge[u][j])37 {38 dist[j] = dist[u] + G.edge[u][j];39 path[j] = u;40 }41 }42 }43 }三、代码解释先⾃⼰定义⼀个⽆穷⼤的值max#define max infdijkstra算法传⼊的两个参为图Graph G；起点结点 int v；⾸先我们需要三个辅助数组1int s[G.vexnum];//记录结点时是否被访问过，访问过为1，没有访问过为02int dist[G.vexnum];//记录当前的从v结点开始到各个结点的最短路径长度3int path[G.vexnum];//记录最短路径，存放的是该结点的上⼀个为最短路径的前驱结点初始化三个数组1for(int i = 0; i < G.vexnum; i++)2 {3 s[i] = 0;//⽬前每个结点均未被访问过，设为04 dist[i] = G.edge[v][i];//dist[]数组记录每个从v结点开到其他i结点边的长度（权值）5if(G.edge[v][i] == max || G.edge[v][i] == 0)6 {7 path[i] = -1;8 }//如果v到i不存在路径或者i就是v结点时，将path[i]设为-1，意为⽬前v结点不存在路径到i9else10 {11 path[i] = v;12 }//反之，若v到i存在路径，则v就是i的前驱结点，将path[i] = v13 s[v] = 1;//从遍历起点v开始，即已经访问过顶点s[v]=114 }开始遍历数组并且每次修改辅助数组以记录⽬前的情况，直⾄遍历结束1for(int i = 0; i < G.vexnum; i++)2 {3int min = max;//声明⼀个min = max⽤来每次记录这次遍历找到的最短路径的长度（权值）4int u;//声明u来记录这次历找到的最短路径的结点5for(int j = 0; j < G.vexnum; j++)//开始遍历找⽬前的最短路径6 {7if(s[j] != 1 && dist[j] < min)8 {9 min = dist[j];10 u = j;11 }//找出v到结点j的最短路径，并且记录下最短路径的结点u = j12 }13 s[u] = 1;//找到结点u，即已访问过u，s[u] = 114for(int j = 0; j < G.vexnum; j++)//开始遍历修改辅助数组的值15 {16if(s[j] != 1 && dist[j] > dist[u] + G.edge[u][j])17 {18 dist[j] = dist[u] + G.edge[u][j]；19 path[j] = u;20 }//如果v→j的路径⽐v →u→j长，那么修改dist[j]的值为 dist[u] + G.edge[u][j]，并且修改j的前驱结点为path[j] = u21 }22 }遍历结束后，数组dist[]就是存放了起点v开始到各个顶点的最短路径长度最短路径包含的结点就在path数组中例如我们得到如下的path[]数组1 path[0] = -1;//0到⾃⼰⽆前驱结点2 path[1] = 0;//1的前驱为结点0,0⽆前驱结点，即最短路径为0 →13 path[2] = 1;//2的前驱结为点1,1的前驱结点0，0⽆前驱结点，即最短路径为0 →1 →24 path[3] = 0;//3的前驱为结点0,0⽆前驱结点，即最短路径为0 →35 path[4] = 2;//4的前驱结为点2,2的前驱结为点1,1的前驱结点0，0⽆前驱结点，即最短路径为0 →1 →2 →4 dijkstra对于存在负权值的图不适⽤，明天再更新Floyd算法叭。
最短最优路径算法附程序代码
实验报告一一．题目要求输入Ｎ（Ｎ<10）个城市，每两个城市之间有对应的距离和费用（可以不能到达），要求实现如下程序：ａ）给出任意两个城市之间的最短距离，及其到达方式；ｂ）给出任意两个城市之间的最小费用，及其到达方式；ｃ）权衡距离和费用，给出任意两个城市之间的最优路径，及其到达方式；PS：1. 距离矩阵和费用矩阵由同学自己给出；2. 题c)的最优路径由自己定义。
二．算法设计：欲求得每一对顶点之间的最短路径，解决这一问题的办法是采用弗洛伊德算法。
弗洛伊德算法仍从图的带权邻接矩阵出发，其主要思想是：设集合S的初始状态为空集合，然后依次向集合S中加入顶点V0,V1,V2，…，Vn-1，每次加入一个顶点，我们用二维数组D保存每一对顶点之间的最短路径的长度，其中，D[i][j]存放从顶点Vi到Vj的最短路径的长度。
在算法执行中，D[i][j]被定义为：从Vi到Vj的中间只经过S中的顶点的所有可能的路径中最短路径的长度（如果从Vi到Vj中间只经过S中的顶点当前没有路径相通，那么d[i][j]为一个大值MaxNum）。
即d[i][j]中保存的是从Vi 到Vj的“当前最短路径”的长度。
每次加入一个新的顶点，Vi和Vj之间可能有新的路径产生，将它和已经得到的从Vi到Vj的最短路径相比较，d[i][j]的值可能需要不断修正，当S=V时，d[i][j]的值就是从Vi到Vj的最短路径。
因为初始状态下集合S为空集合，所以初始化D[i][j]=A[i][j]（A[i][j]是图的邻接矩阵）的值是从Vi直接邻接到Vj，中间不经过任何顶点的最短路径。
当S中增加了顶点V0,那么D(0)[i][j]的值应该是从Vi到Vj，中间只允许经过v0的当前最短路径的长度。
为了做到这一点，只需对D(0)[i][j]作如下修改：D(0)[i][j]=min{D[i][j],D[i][0]+D[0][j]}一般情况下，如果D(k-1)[i][j]是从Vi到Vj，中间只允许经过{ V0,V1,V2，…，Vk-1}的当前最短路径的长度，那么，当S中加进了Vk，则应该对D进行修改如下: D(k)[i][j]=min{D(k-1)[i][j],D(k-1)[i][k]+D(k-1)[k][j]}三．概要设计：1.数据结构二维数组来表示邻接矩阵，数组中存储元素表示邻接点之间的距离，或费用。
最短路径算法代码
最短路径算法代码
以下是Dijkstra算法的Python代码实现：
import heapq
def dijkstra(graph, start):
# 存储每个节点的最短距离
distances = {node: float('inf') for node in graph}
distances[start] = 0
# 使用堆来进行优化
queue = []
heapq.heappush(queue, [distances[start], start])
while queue:
# 取出堆顶元素
current_distance, current_node = heapq.heappop(queue)
# 如果当前节点的距离比存储的短距离还短，忽略该节点
if current_distance > distances[current_node]:
continue
# 对于每个邻居节点，计算距离并更新
for neighbor, weight in graph[current_node].items():
distance = current_distance + weight
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(queue, [distance, neighbor]) return distances
这是一个基本的Dijkstra算法实现，用于计算从起点到其他节点的最短距离。
其中，graph是图的邻接矩阵，start是起点节点。
算法使用了堆优化来提高效率。
最短路径算法源程序代码
// 最大结 // 节点 // 若节点间 #include < stdio .h>#include < conio.h>#include < string .h> #defineJiedianNum 6 点数#define NameLenght 3 名字长度#define Infinity 10000 没有路径距离设定为 Infinity char*JiedianNameFile = "jiedianname.txt" ;// 图的顶点 -- 节点名char *JiedianPathFile = "jiedianpath.txt" ; // 边 -- 节点间的连接关系char *MinPathDataFile ="minpath.txt" ;// 最短路径数据/******************************************************* /* 从文件中读入结点数据*//* 函数参数：*//* char jiedian[][]: 存放节点名的数组*//* int *NodNum: 指针变量，指向存放节点个数的变量*//* 输入数据：文本数据文件：JiedianNameFile*//* 文件数据格式：*//* < 节点个数>*//* < 节点名>*//* 输出数据：指从该函数中带回到调用函数的数据，包括：*//* jiedian[][]-- 节点名称*//* NodeNum-- 节点名的个数*//* 返回值：数据读入是否成功的标志*//* 0-- 失败1-- 成功*//******************************************************* int InputJiedianNode( char jiedian[][NameLenght], int *NodeNum ){int i,n;FILE *fp;if (!(fp = fopen(JiedianNameFile, "r" ))){ printf( "节点数据文件不存在\n" );getch();return (0);}fscanf(fp, "%d" ,&n);if (!n){ printf( "文件中无节点数据!\n" );getch();return (0);}for (i= 0;i< n;i++ ) fscanf(fp, "%s" ,jiedian[i]);fclose(fp);*NodeNum =n;return (1);}I******************************************************* /* 从文件中读入最短路径数据*//* 函数参数：*//* int dist[][]: 节点间最短路径的值*//* int Path[][]: 节点间最短路径结点数据*//* int *NodNum: 指针变量，表示读入数据的多少*//* 输入数据：数据文件：MinPathDataFile*//* 文件数据格式：二进制数据，数据存放顺序：*//* < 节点个数n><n*n 个最短路径值><n*n 个结点值> *//* 输出数据：指从该函数中带回到调用函数的数据，包括：*//* jiedian[][]*//* Path[][]*/*//* 返回值：数据读入是否成功的标志*//* 0-- 失败1-- 成功*//******************************************************* int InputMinPath( int dist[][JiedianNum], intPath[][JiedianNum], int *NodeNum){int n;FILE *fp;if (!(fp = fopen(MinPathDataFile, "rb" ))){ printf( " 最小路径数据文件不存在!\n" );getch();return (0);}fread( &n,sizeof (int ),1,fp);fread(dist, sizeof (int ),n*n,fp);fread(Path, sizeof (int ),n*n,fp); fclose(fp);*NodeNum =n;return (1);}/******************************************************* /* 查找节点名*//* 函数参数：*//* char str[][]: 存放节点名的数组*//* int n ：str 中数据的行数，即节点名的个数*//* char *p: 指针变量，表示需要查找的节点名*//* 输入数据：全部函数参数均为输入数据*//* 输出数据：返回值作为函数的输出数据*//* 查找成功：被查找的节点名在数组str 中的序号*/ /* 查找失败：－1，表示被查找的节点名未出现在数组中*//******************************************************* int search( char str[][NameLenght], int n,char*p){int i=0;while(i< n){ if (!strcmp(str[i],p)) return (i); i++;} return (- 1); }I*******************************************************/**//* 函数参数：计算节点间最短路径< 无>*//* 输入数据：文本数据文件：JiedianNameFile*/ /* */ /* */ /* */ /*文件数据格式：< 节点个数>< 节点名>文本数据文件：JiedianPathFile*/ /*文件数据格式：*//* < 边数>*//* < 结点名>< 节点名>< 边值> *//* 输出数据：数据文件：MinPathDataFile*//* 文件数据格式：二进制数据，数据存放顺序：*/ /* < 结点个数n><n*n 个最短路径值><n*n 个结点值> *//* 返回值：< 无>*//* 说明：文本数据文件中数据间用空格或换行符格开*//******************************************************* void shorttestpath(){int i,j,k,NodeNum,EgeNum,val;int arc[JiedianNum][JiedianNum];// 权值矩阵char jiedian[JiedianNum][NameLenght];// 结点int dist[JiedianNum][JiedianNum]; // 最短路径长度矩阵int Path[JiedianNum][JiedianNum];// 最短路径矩阵charjiedian1[NameLenght],jiedian2[NameLenght]JFILE *fp;/* -------------------------------------------------- *//* 算法步骤：*//* 1、读入结点数据*//* 2、邻接矩阵初始化：所有元素赋Infinity ，*//* 对角线元素赋0 *//* 3、读入结点间边的数据，转换为邻接矩阵的数据*//* 4、路径矩阵初始化，若arc[i][j]<Infinity ，*//* 则：at[i][j]=i 否则：Path[i][j]=-1 *//* 5、计算最短路径*//* 6、保存最小路径数据*//* -------------------------------------------------- */// -------- 初始化邻接矩阵if (!InputJiedianNode(jiedian, & NodeNum)) return ;else{for (i= 0;i< NodeNum;i ++){for (j =0;j< NodeNum;j ++)if(i== j) arc[i][j] =0; else arc[i][j]=Infinity;}printf( "%s\n" ,jiedian[i]);}}// ---- 读入结点间边的数据--------if (!(fp = fopen(JiedianPathFile, "r" ))) {printf( " 结点间边的数据文件不存在!!!\n" );getch(); return ;}fscanf(fp, "%d" ,& EgeNum);if (!EgeNum){printf( " 文件中无结点间边的数据!!!\n" );getch();return ; }for (k=0;k< EgeNum;k ++ ){fscanf(fp, "%s" ,jiedian1);fscanf(fp, "%s" ,jiedian2);fscanf(fp, "%d" ,&val);i=search(jiedian,NodeNum,jiedian1); j=search(jiedian,NodeNum,jiedian2); arc[i][j]=arc[j][i] =val;}fclose(fp);// -------- 路径矩阵初始化for (i= 0;i< NodeNum;i ++)for (j = 0;j < NodeNum;j ++){if ((arc[i][j] < Infinity) && (i!= j))Path[i][j] =i;else Path[i][j] =- 1;}// 初始化最短路径长度矩阵dist[][]for (i= 0;i< NodeNum;i ++ )for (j = 0;j< NodeNum;j ++)dist[i][j] =arc[i][j];// 弗罗伊德算法for (k=0;k< NodeNum;k ++)for (i= 0;i< NodeNum;i ++ )for (j = 0;j < NodeNum;j ++)if (dist[i][k] +dist[k][j] < dist[i][j]) {dist[i][j] =dist[i][k] + dist[k][j];Path[i][j] =Path[k][j];}// -------- 保存城市间最短路径的信息if (!(fp = fopen(MinPathDataFile, "wb" ))){printf( " 打不开文件%s !!!\n" ,MinPathDataFile); getch(); return ;}fwrite( & NodeNum, sizeof (int ),1,fp);fwrite(dist, sizeof (int ),NodeNum *NodeNum,fp) fwrite(Path, sizeof (int ),NodeNum *NodeNum,f p);fclose(fp);return ;}/******************************************************* /* 求一个节点到其它节点的最短路径*//* 函数参数：< 无>*//* 输入数据：文本数据文件：JiedianNameFile *//* 数据文件：MinPathDataFile*/*//* 输出数据：*//* 指定节点到其它所有节点的最短路径值和路径*//* (屏幕显式)*//* 返回值：< 无>*//******************************************************* void One_To_Other_Path(){int i,j,k,NodeNum,StartNode;char jiedian[JiedianNum][NameLenght];// 结点int dist[JiedianNum][JiedianNum];// 最短路径长度矩阵int Path[JiedianNum][JiedianNum];// 最短路径矩阵int top,PathStack[JiedianNum]; char jiedian1[NameLenght]; FILE *fp;/*数组中获得/*中结点间路径/*并放入栈中，/* *//* 算法步骤：*//* 1、输入结点数据*//* 2、输入最小路径数据*//* 3、输入起点节点名称，并确定其正确性*//* 方法：调用查找函数，若返回值>=0则正确*//* 4、依次求起点节点到其它节点的最短路径*//* 方法：根据两节点的序号i,j在dist*/最短路径值。
最短路径算法源码(VB)
最短路径算法源码(VB)最短路径查询程序，速度特快，3万节点，35000条路全部遍历，只需1秒。
现将最短路径的思路告诉大家，希望大家在优化，并用不同语言编制，我正在学delphi,准备用delphi做成库，本例以由拓扑关系的arc/info 文件为数据源。
其中a1,b1,c1是以fnode排序生成的数组，a1对应fnode,b1对应tnode,c1对应length,同样a2,b2,c2,是以tnode 生成的数组。
Indexa1是对应某一起点与其相连的终点的个数，indexb1时对应某一终点与其相连的起点的个数，即其拓扑关系。
Public Function shortpath(startno As Integer, endno As Integer) As Single以开始点，结束点为参数。
Dim result() As SingleDim result1 As Integer定义结果点Dim s1 As SingleDim min As SingleDim ii, i, j, aa As IntegerDim yc() As BooleanDim ycd() As BooleanDim rs1() As SingleDim no() As IntegerDim nopoint As IntegerReDim yc(1 To maxno) As BooleanReDim ycd(1 To maxno) As BooleanReDim rs1(1 To maxno) As SingleReDim result(1 To 2, 1 To maxno) As Single定义结果，其中result(1,maxno)为结果点，result(2,maxno)为结果长度。
For i = 1 To maxno// maxno为网中最大的节点数。
yc(i) = False //标记已经查过的点。
ycd(i) = False //标记已经作结果点用过的点rs1(i) = 1E+38 //假设从起点到任一点的距离都为无穷大Next ill = startno //设置开始点。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
最短路径分析（源码）using System; ArcEngine using ESRI.ArcGIS.Carto;using ESRI.ArcGIS.Geometry;using ESRI.ArcGIS.Geodatabase;using workAnalysis;//12namespace GisEditor{/// <summary>/// 最短路径分析/// </summary>public class ClsPathFinder{private IGeometricNetwork m_ipGeometricNetwork;private IMap m_ipMap;private IPointCollection m_ipPoints;private IPointToEID m_ipPointToEID;private double m_dblPathCost =0;private IEnumNetEID m_ipEnumNetEID_Junctions;private IEnumNetEID m_ipEnumNetEID_Edges;private IPolyline m_ipPolyline;#region Public Function//返回和设置当前地图public IMap SetOrGetMap{set{ m_ipMap = value;}get{return m_ipMap;}}//打开几何数据集的网络工作空间public void OpenFeatureDatasetNetwork(IFeatureDataset FeatureDataset){CloseWorkspace();if (!InitializeNetworkAndMap(FeatureDataset))Console.WriteLine( "打开network出错");}//输入点的集合public IPointCollection StopPoints{set{m_ipPoints= value;}get{return m_ipPoints;}}//路径成本public double PathCost{get {return m_dblPathCost;}}//返回路径的几何体public IPolyline PathPolyLine(){IEIDInfo ipEIDInfo;IGeometry ipGeometry;if(m_ipPolyline!=null)return m_ipPolyline;m_ipPolyline = new PolylineClass();IGeometryCollection ipNewGeometryColl = m_ipPolyline as IGeometryCollection;ISpatialReference ipSpatialReference = m_ipMap.SpatialReference; IEIDHelper ipEIDHelper = new EIDHelperClass();ipEIDHelper.GeometricNetwork = m_ipGeometricNetwork;ipEIDHelper.OutputSpatialReference = ipSpatialReference;ipEIDHelper.ReturnGeometries = true;IEnumEIDInfo ipEnumEIDInfo =ipEIDHelper.CreateEnumEIDInfo(m_ipEnumNetEID_Edges);int count = ipEnumEIDInfo.Count;ipEnumEIDInfo.Reset();for(int i =0;i<count;i++){ipEIDInfo = ipEnumEIDInfo.Next();ipGeometry = ipEIDInfo.Geometry;ipNewGeometryColl.AddGeometryCollection( ipGeometry as IGeometryCollection);}return m_ipPolyline;}//解决路径public void SolvePath(string WeightName){try{int intEdgeUserClassID;int intEdgeUserID;int intEdgeUserSubID;int intEdgeID;IPoint ipFoundEdgePoint;double dblEdgePercent;/*PutEdgeOrigins方法的第二个参数要求是IEdgeFlag类型的数组,* 在VB等其他语言的代码中，只需传人该类型数组的第一个元素即* 可，但C#中的机制有所不同，需要作出如下修改：使用* ITraceFlowSolverGEN替代ITraceFlowSolver*/ITraceFlowSolverGEN ipTraceFlowSolver = new TraceFlowSolverClass() as ITraceFlowSolverGEN;INetSolver ipNetSolver = ipTraceFlowSolver as INetSolver;INetwork ipNetwork = m_work;ipNetSolver.SourceNetwork = ipNetwork;INetElements ipNetElements = ipNetwork as INetElements;int intCount = m_ipPoints.PointCount;//定义一个边线旗数组IEdgeFlag[] pEdgeFlagList = new EdgeFlagClass[intCount];for(int i = 0;i<intCount ;i++){INetFlag ipNetFlag = new EdgeFlagClass()as INetFlag;IPoint ipEdgePoint = m_ipPoints.get_Point(i);//查找输入点的最近的边线m_ipPointToEID.GetNearestEdge(ipEdgePoint, out intEdgeID,out ipFoundEdgePoint, out dblEdgePercent);ipNetElements.QueryIDs( intEdgeID, esriElementType.esriETEdge, out intEdgeUserClassID, out intEdgeUserID,out intEdgeUserSubID);erClassID = intEdgeUserClassID;erID = intEdgeUserID;erSubID = intEdgeUserSubID;IEdgeFlag pTemp = (IEdgeFlag)(ipNetFlag as IEdgeFlag);pEdgeFlagList[i]=pTemp;}ipTraceFlowSolver.PutEdgeOrigins(ref pEdgeFlagList);INetSchema ipNetSchema = ipNetwork as INetSchema;INetWeight ipNetWeight =ipNetSchema.get_WeightByName(WeightName);INetSolverWeights ipNetSolverWeights = ipTraceFlowSolver as INetSolverWeights;ipNetSolverWeights.FromToEdgeWeight = ipNetWeight;//开始边线的权重ipNetSolverWeights.ToFromEdgeWeight = ipNetWeight;//终止边线的权重object [] vaRes =new object[intCount-1];//通过findpath得到边线和交汇点的集合ipTraceFlowSolver.FindPath(esriFlowMethod.esriFMConnected,esriShortestPathObjFn.esriSPObjFnMinSum,out m_ipEnumNetEID_Junctions,out m_ipEnumNetEID_Edges,intCount-1, ref vaRes);//计算元素成本m_dblPathCost = 0;for (int i =0;i<vaRes.Length;i++){double m_Va =(double) vaRes[i];m_dblPathCost = m_dblPathCost + m_Va;}m_ipPolyline = null;}catch(Exception ex){Console.WriteLine(ex.Message);}}#endregion#region Private Function//初始化几何网络和地图private bool InitializeNetworkAndMap(IFeatureDataset FeatureDataset) {IFeatureClassContainer ipFeatureClassContainer;IFeatureClass ipFeatureClass ;IGeoDataset ipGeoDataset;ILayer ipLayer ;IFeatureLayer ipFeatureLayer;IEnvelope ipEnvelope, ipMaxEnvelope ;double dblSearchTol;INetworkCollection ipNetworkCollection = FeatureDataset as INetworkCollection;int count = ipNetworkCollection.GeometricNetworkCount;//获取第一个几何网络工作空间m_ipGeometricNetwork = ipNetworkCollection.get_GeometricNetwork(0); INetwork ipNetwork = m_work;{m_ipMap = new MapClass();ipFeatureClassContainer = m_ipGeometricNetwork as IFeatureClassContainer;count = ipFeatureClassContainer.ClassCount;for(int i =0;i<count;i++){ipFeatureClass = ipFeatureClassContainer.get_Class(i); ipFeatureLayer = new FeatureLayerClass();ipFeatureLayer.FeatureClass = ipFeatureClass;m_ipMap.AddLayer( ipFeatureLayer);}}count = m_yerCount;ipMaxEnvelope = new EnvelopeClass();for(int i =0;i<count;i++){ipLayer = m_ipMap.get_Layer(i);ipFeatureLayer = ipLayer as IFeatureLayer;ipGeoDataset = ipFeatureLayer as IGeoDataset;ipEnvelope = ipGeoDataset.Extent;ipMaxEnvelope.Union( ipEnvelope);}m_ipPointToEID = new PointToEIDClass();m_ipPointToEID.SourceMap = m_ipMap;m_ipPointToEID.GeometricNetwork = m_ipGeometricNetwork;double dblWidth = ipMaxEnvelope.Width;double dblHeight = ipMaxEnvelope.Height;if( dblWidth > dblHeight)dblSearchTol = dblWidth / 100;elsedblSearchTol = dblHeight / 100;m_ipPointToEID.SnapTolerance = dblSearchTol;return true ;}//关闭工作空间private void CloseWorkspace(){m_ipGeometricNetwork = null;m_ipPointToEID = null;m_ipEnumNetEID_Junctions = null;m_ipEnumNetEID_Edges = null;m_ipPolyline = null;}#endregion}}备注：在调用该类时的次序：ClsPathFinder m_ipPathFinder;if(m_ipPathFinder==null)//打开几何网络工作空间{m_ipPathFinder = new ClsPathFinder();ipMap = this.m_ActiveView.FocusMap;ipLayer = ipMap.get_Layer(0);ipFeatureLayer = ipLayer as IFeatureLayer;ipFDB = ipFeatureLayer.FeatureClass.FeatureDataset;m_ipPathFinder.SetOrGetMap = ipMap;m_ipPathFinder.OpenFeatureDatasetNetwork(ipFDB);}private void ViewMap_OnMouseDown(object sender,ESRI.ArcGIS.MapControl.IMapControlEvents2_OnMouseDownEvent e)//获取地图上鼠标输入的点{IPoint ipNew ;if( m_ipPoints==null){m_ipPoints = new MultipointClass();m_ipPathFinder.StopPoints = m_ipPoints;}ipNew =ViewMap.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(e.x ,e.y);object o = Type.Missing;m_ipPoints.AddPoint(ipNew,ref o,ref o);}m_ipPathFinder.SolvePath("Weight");//先解析路径IPolyline ipPolyResult = m_ipPathFinder.PathPolyLine();//最后返回最短路径。