数据结构学习之弗洛伊德floyd算法求最短路径

#include "stdio.h"
#include "stdlib.h"
#define MAX 20
#define INFINITY 9999

typedef bool PathMatrix[MAX+1][MAX+1][MAX+1];
typedef int DistanceMatrix[MAX+1][MAX+1];

typedef struct
{
int vexnum,arcnum;
char vexs[MAX+1];
int arcs[MAX+1][MAX+1];
}MGraph;

void CreateDN(MGraph &G)
{
int i,j,k,v1,v2,w;
printf("请输入顶点数和边数:");
scanf("%d %d",&G.vexnum,&G.arcnum);
for(i=0;i<G.vexnum;i++)
{
getchar();
printf("请输入第%d个结点：",i);
scanf("%c",&G.vexs[i]);
}
for(i=0;i<G.vexnum;i++)
for(j=0;j<G.vexnum;j++)
G.arcs[i][j]=INFINITY;
for(k=0;k<G.arcnum;k++)
{
printf("请输入边----源点，终点，权值：");
scanf("%d %d %d",&v1,&v2,&w);
G.arcs[v1][v2]=w;
}
}

void ShortestPath_FLOYD(MGraph G,PathMatrix &P,DistanceMatrix &D)
{
int v,w,u,i;
for(v=0;v<G.vexnum;++v)
for(w=0;w<G.vexnum;++w)
{
D[v][w]=G.arcs[v][w];
for(u=0;u<G.vexnum;++u)
P[v][w][u]=false;
if (D[v][w]<INFINITY)
{
P[v][w][v]=true;
P[v][w][w]=true;
}
}
for(u=0;u<G.vexnum;++u)
for(v=0;v<G.vexnum;++v)
for(w=0;w<G.vexnum;++w)
if (D[v][u]+D[u][w]<D[v][w])
{
D[v][w]=D[v][u]+D[u][w];
for(i=0;i<G.vexnum;++i)
P[v][w][i]=P[v][u][i]||P[u][w][i];
}
}

void main()
{
MGraph G;
int i,j,k;
CreateDN(G);
PathMatrix p;
DistanceMatrix D;
ShortestPath_FLOYD(G,p,D);
for(i=0;i<G.vexnum;i++)
for(j=0;j<G.vexnum;j++)
{
printf("%c到顶点%c的最短路径为:\n",G.vexs[i],G.vexs[j]);
for(k=0;k<G.vexnum;k++)
printf("%d ",p[i][j][k]);
printf("代价为:%d\n",D[i][j]);
printf("\n");
}
}

请输入顶点数和边数:5 7
请输入第0个结点：a
请输入第1个结点：b
请输入第2个结点：c
请输入第3个结点：d
请输入第4个结点：e
请输入边----源点，终点，权值：0 1 3
请输入边----源点，终点，权值：0 3 8
请输入边----源点，终点，权值：1 2 9
请输入边----源点，终点，权值：1 3 2
请输入边----源点，终点，权值：3 2 5
请输入边----源点，终点，权值：3 4 1
请输入边----源点，终点，权值：2 4 4

#include<stdlib.h>
#include<stdio.h>
#define INFINITY 1000        // 最大值
#define MAX_VERTEX_NUM   20     // 最大顶点个数
#define TRUE 1
#define FALSE 0
typedef enum{DG, DN, UDG, UDN} GraphKind;          // 四种图类型
typedef struct MGraph{
char vexs[MAX_VERTEX_NUM];    // 顶点向量
int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];    // 邻接矩阵
int vexnum,arcnum;   // 图的当前顶点数和弧数
GraphKind kind;      // 图的种类标志
} MGraph;
void find(int P[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM],MGraph G,int a,int b);
void main(){
MGraph G;
int D[MAX_VERTEX_NUM][MAX_VERTEX_NUM],P[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM];
int v,w,k,a,b,i;
printf("请输入顶点数和弧数");
scanf("%d %d",&G.vexnum,&G.arcnum);
G.kind=DG;
printf("请输入邻接矩阵\n");
for (v = 0; v < G.vexnum; v++)
for (w = 0; w < G.vexnum; w++)
scanf("%d",&G.arcs[v][w]);   //读入邻接矩阵

// P[v][w][k]为TRUE，则从v到w的最短路径中含有k节点
// D[v][w]从v到w的最短路径的长度
for (v = 0; v < G.vexnum; v++)
for (w = 0; w < G.vexnum; w++){
D[v][w] = G.arcs[v][w];
for (k = 0; k < G.vexnum; k++)
P[v][w][k] = FALSE;
if (D[v][w] < INFINITY)
P[v][w][v] = P[v][w][w] = TRUE;
}

for (k = 0; k < G.vexnum; k++)
for (v = 0; v < G.vexnum; v++)
for (w = 0; w < G.vexnum; w++)
if (D[v][k] + D[k][w] < D[v][w]){
D[v][w] = D[v][k] + D[k][w];
for (i = 0; i < G.vexnum; i++)
P[v][w][i] = P[v][k][i] || P[k][w][i];
}

for(a=0; a<G.vexnum; a++)
for(b=0; b<G.vexnum; b++)
if(D[a][b] < INFINITY && a!=b){
printf("%c到%c最短路径为",65+a,65+b);
printf("%c\t",65+a);
find(P,G,a,b);
printf("%c\t",65+b);
printf("长度为%d",D[a][b]);
printf("\n");
}
}
void find(int P[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM],MGraph G,int a,int b){
int k;
for(k = 0; k < G.vexnum; k++)
if(P[a][b][k]==TRUE && k!=a && k!=b){
find(P,G,a,k);
printf("%c\t",65+k);
find(P,G,k,b);
}
}

请输入顶点数和弧数6 9

请输入邻接矩阵

0 3 1000 4 1000 5

1000 0 1 1000 1000 5

1000 1000 0 5 1000 1000

1000 3 1000 0 1000 1000

1000 1000

1000 3 0 2

1000 1000 1000 2 1000 0

A到B最短路径为A B 长度为3

A到C最短路径为A B C 长度为4

A到D最短路径为A D 长度为4

A到F最短路径为A F 长度为5

B到C最短路径为B C 长度为1

B到D最短路径为B C D 长度为6

B到F最短路径为B F 长度为5

C到B最短路径为C D B 长度为8

C到D最短路径为C D 长度为5

C到F最短路径为C D B D B F 长度为13

D到B最短路径为D B 长度为3

D到C最短路径为D B C 长度为4

D到F最短路径为D B F 长度为8

E到B最短路径为E D B 长度为6

E到C最短路径为E D B D B C 长度为7

E到D最短路径为E D 长度为3

E到F最短路径为E F 长度为2

F到B最短路径为F D B 长度为5

F到C最短路径为F D B D B C 长度为6

F到D最短路径为F D 长度为2

Press any key to continue