最短路径Dijkstra算法实现和Floyd算法实现

/*
Dijkstra算方法（时间复杂度O（n^3））
此程序实现由无向图找到源v0到其他节点的最短路径
*/
#include<iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
#define Member 9
#define MAXINT 65535
typedef int shortpath_weight[Member];       //储存V0到各个节点的最短路径的权重和
typedef int shortpath_pre[Member];          //存储最短路径的前驱，如shortpath_pre[1]=5;就表示v0到v1的最短路径中，v1的前驱是v5
void shortest_Dijkstra(Mgraph G,int v0,shortpath_weight *D,shortpath_pre *P)
{
int final[Member];//用final记录一个是否已找到v0到这个节点的最短路径
int i=0,j=0,k=0;
//初始化
for(i=0;i<G.Nodenum;++i)
{
final[i]=0;
(*D)=G.matrix[v0][i];
(*P)=0;
}
(*D)[v0]=0;
final[v0]=1;

//主循环
for(i=0;i<G.Nodenum-1;++i)
{
//找到下一个最短路径节点
for(j=0;j<G.Nodenum;++j)
{
if(!final[j]&&(*D)[j]<min)
{
min=(*D)[j];
k=j;
}
}
final[k]=1;
//由最新找到的节点，更新V0到未找到的最短路径节权值和，以及这些节点在V0到它们的最短路径的前驱
for(j=0;j<G.Nodenum;++j)
{
if(!final[j]&&(min+G.matrix[k][j])<(*D)[j])
{
(*D)[j]=min+G.matrix[j];
(*P)[j]=k;
}
}
}
}

Floyd算法：找到图中所有节点到其他所有节点的最短路径

思路：由图的矩阵，使任意两个节点都通过节点0，如果(*D)[m]
>(*D)[m][0]+(*D)[0]
,则更换(*D)[m]
的值，更换一次矩阵之后，使任意两个节点都通过1（注意此时矩阵已经更新过通过节点0，顾此时的比较相当于，两个节点可以任意通过节点0或者1或者它们的组合的情况下的最短路径值），依次比较通过节点2,3，4.。。。。。最后就是两个节点通过任意节点组合的最短路径

typedef int shortpath_weight[Member][Member]
typedef int shortpath_later[Member][Member]//注意此处用later是因为，此时的矩阵P[2][5]=3表示的是2到5 的话要先经过3，于是再看p[3][5]=4的话，就是2->3->4->....->5

void ShortestPath_Floyd(Mgraph G,shortpath_weight *D,shortpath_later *P)
{
int v,w,k;
//初始化
for(v=0;v<G.Nodenum;++v)
{
for(w=0;w<G.Nodenum;++w)
{
(*D)[v][w]=G.matrix[v][w];
(*P)[v][w]=w;
}
}
//计算最短路径以及路径矩阵
for(k=0;k<G.Nodenum;++k)
{
for(v=0;v<G.Nodenum;++v)
{
for(w=0;w<G.Nodenum;++w)
{
if((*D)[v][w]>(*D)[v][k]+(*D)[k][w])
{
(*D)[v][w]=(*D)[v][k]+(*D)[k][w];
(*P)[v][w]=(*D)[v][k];
}
}
}
}
}