Floyd算法求最短路径

http://blog.csdn.net/hackerain/article/details/6055946

#define MAX_VERTEX_NUM 20
#define MAX 1000000000
typedef struct
{
	std::string vexs[MAX_VERTEX_NUM];
	int edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
	int vertexnum,edgenum;
}MGraph;
void createDN_AM(MGraph &G,int n,int e)
{
	G.vertexnum=n;
	G.edgenum=e;
	int i,j,k;
	int weight;
	for(i=0;i<n;i++)
	{
		cin>>G.vexs[i];
	}
	for(i=0;i<n;i++)
		for(j=0;j<n;j++)
		{
			if(i==j)
				G.edges[i][j]=0;
			else
				G.edges[i][j]=MAX;
		}
	for(k=0;k<e;k++)
	{
		cin>>i>>j>>weight;
		G.edges[i][j]=weight;
	}
}
void ShortestPath_Floyd(MGraph &G)
{
	int i,j,k;
	int dist[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
	std::string path[2*MAX_VERTEX_NUM][2*MAX_VERTEX_NUM];
	for(i=0;i<G.vertexnum;i++)
		for(j=0;j<G.vertexnum;j++)
		{
			dist[i][j]=G.edges[i][j];
			if(dist[i][j]<MAX)
			{
				path[i][j]=G.vexs[i]+G.vexs[j];
			}
			else
				path[i][j]="";
		}
	for(k=0;k<G.vertexnum;k++)
		for(i=0;i<G.vertexnum;i++)
			for(j=0;j<G.vertexnum;j++)
				if(dist[i][k]+dist[k][j]<dist[i][j])
				{
					dist[i][j]=dist[i][k]+dist[k][j];
					path[i][j]=path[i][k]+path[k][j];
				}
	for(i=0;i<G.vertexnum;i++)
	{
		for(j=0;j<G.vertexnum;j++)
			cout<<path[i][j]<<" "<<dist[i][j]<<" ";
		cout<<endl;
	}
}


int main()
{
	MGraph G;
	createDN_AM(G,7,8);
	ShortestPath_Floyd(G);
	return 0;
}

 

 

原文：

01.#include<iostream>  
02.#include<string>  
03.using namespace std;  
04./*邻接矩阵的类型定义*/  
05.#define MAX 10000000  
06.#define MAX_VERTEX_NUM 20  
07.typedef struct  
08.{  
09.    string vexs[MAX_VERTEX_NUM];//用一维数组存储顶点信息  
10.    int edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//用二维数组充当矩阵，来存储顶点边的信息  
11.    int vexnum,edgenum;//顶点树和边数  
12.}MGraph;  
13./*构造有向网的邻接矩阵*/  
14.void CreateDN_AM(MGraph &G,int n,int e)  
15.{  
16.    G.vexnum=n;  
17.    G.edgenum=e;  
18.      
19.    int i,j,k;  
20.    int weight;  
21.    for(i=0;i<n;i++)  
22.        cin>>G.vexs[i];//输入顶点信息  
23.    for(i=0;i<n;i++)  
24.        for(j=0;j<n;j++)  
25.        {  
26.            if(i==j)  
27.                G.edges[i][j]=0;//主对角线上的权值为0  
28.            else  
29.                G.edges[i][j]=MAX;//将矩阵初始化为MAX  
30.        }  
31.    for(k=0;k<e;k++)  
32.    {  
33.        cin>>i>>j>>weight;  
34.        G.edges[i][j]=weight;  
35.    }  
36.}  
37./*弗洛伊德算法求最短路径*/  
38.void ShortestPath_Floyd(MGraph &G)  
39.{  
40.    int i,j,k;  
41.    int dist[MAX_VERTEX_NUM][MAX_VERTEX_NUM];  
42.    string path[2*MAX_VERTEX_NUM][2*MAX_VERTEX_NUM];  
43.    for(i=0;i<G.vexnum;i++)  
44.        for(j=0;j<G.vexnum;j++)  
45.        {//初始化工作  
46.            dist[i][j]=G.edges[i][j];  
47.            if(dist[i][j]<MAX)  
48.                path[i][j]=G.vexs[i]+G.vexs[j];  
49.            else  
50.                path[i][j]="";  
51.        }  
52.    //三个for循环求最短路径  
53.    for(k=0;k<G.vexnum;k++)  
54.        for(i=0;i<G.vexnum;i++)  
55.            for(j=0;j<G.vexnum;j++)  
56.                if(dist[i][k]+dist[k][j]<dist[i][j])  
57.                {  
58.                    dist[i][j]=dist[i][k]+dist[k][j];  
59.                    path[i][j]=path[i][k]+path[k][j];  
60.                }  
61.    for(i=0;i<G.vexnum;i++)  
62.    {  
63.        for(j=0;j<G.vexnum;j++)  
64.            cout<<path[i][j]<<" "<<dist[i][j]<<" ";  
65.        cout<<endl;  
66.    }  
67.}  
68.void main()  
69.{  
70.    freopen("in.txt","r",stdin);  
71.    MGraph G;  
72.    CreateDN_AM(G,4,6);  
73.    ShortestPath_Floyd(G);  
74.}  

 

弗洛伊德算法主要是采用了dist二维数组来存储各个顶点之间的最短路径，然后不断更新，它的典型标识是有三个连续的for循环：将每一个顶点插入到另外两个顶点之间，看是否能得到较小的路径，这是它的主要思想，即是所谓的“试探”或是“动态”，其实理解是容易理解的，就是不好表达。