Floyd算法

时间：2014-08-02 01:43:52 阅读：422 评论：0 收藏：0 [点我收藏+]

很简单吧，代码看起来可能像下面这样：

 1 for ( int i = 0; i < 节点个数; ++i )
 2 {
 3     for ( int j = 0; j < 节点个数; ++j )
 4     {
 5         for ( int k = 0; k < 节点个数; ++k )
 6         {
 7             if ( Dis[i][k] + Dis[k][j] < Dis[i][j] )
 8             {
 9                 // 找到更短路径
10                 Dis[i][j] = Dis[i][k] + Dis[k][j];
11             }
12         }
13     }
14 }

但是这里我们要注意循环的嵌套顺序，如果把检查所有节点X放在最内层，那么结果将是不正确的，为什么呢？因为这样便过早的把i到j的最短路径确定下来了，而当后面存在更短的路径时，已经不再会更新了。

让我们来看一个例子，看下图：

bubuko.com,布布扣

图中红色的数字代表边的权重。如果我们在最内层检查所有节点X，那么对于A->B，我们只能发现一条路径，就是A->B，路径距离为9。而这显然是不正确的，真实的最短路径是A->D->C->B，路径距离为6。造成错误的原因就是我们把检查所有节点X放在最内层，造成过早的把A到B的最短路径确定下来了，当确定A->B的最短路径时Dis(AC)尚未被计算。所以，我们需要改写循环顺序，如下：

 1 for ( int k = 0; k < 节点个数; ++k )
 2 {
 3     for ( int i = 0; i < 节点个数; ++i )
 4     {
 5         for ( int j = 0; j < 节点个数; ++j )
 6         {
 7             if ( Dis[i][k] + Dis[k][j] < Dis[i][j] )
 8             {
 9                 // 找到更短路径
10                 Dis[i][j] = Dis[i][k] + Dis[k][j];
11             }
12         }
13     }
14 }

这样一来，对于每一个节点X，我们都会把所有的i到j处理完毕后才继续检查下一个节点。

那么接下来的问题就是，我们如何找出最短路径呢？这里需要借助一个辅助数组Path，它是这样使用的：Path(AB)的值如果为P，则表示A节点到B节点的最短路径是A->...->P->B。这样一来，假设我们要找A->B的最短路径，那么就依次查找，假设Path(AB)的值为P，那么接着查找Path(AP)，假设Path(AP)的值为L，那么接着查找Path(AL)，假设Path(AL)的值为A，则查找结束，最短路径为A->L->P->B。

那么，如何填充Path的值呢？很简单，当我们发现Dis(AX) + Dis(XB) < Dis(AB)成立时，就要把最短路径改为A->...->X->...->B，而此时，Path(XB)的值是已知的，所以，Path(AB) = Path(XB)。

好了，基本的介绍完成了，接下来就是实现的时候了，这里我们使用图以及邻接矩阵：

 1 #define INFINITE 1000           // 最大值
 2 #define MAX_VERTEX_COUNT 20 　　// 最大顶点个数
 3 //////////////////////////////////////////////////////////////////////////
 4  
 5 struct Graph
 6 {
 7     int     arrArcs[MAX_VERTEX_COUNT][MAX_VERTEX_COUNT];    // 邻接矩阵
 8     int     nVertexCount;                               　　// 顶点数量
 9     int     nArcCount;                                  　　// 边的数量
10 };
11 //////////////////////////////////////////////////////////////////////////

首先，我们写一个方法，用于读入图的数据：

 1 void readGraphData( Graph *_pGraph )
 2 {
 3     std::cout << "请输入顶点数量和边的数量: ";
 4     std::cin >> _pGraph->nVertexCount;
 5     std::cin >> _pGraph->nArcCount;
 6  
 7     std::cout << "请输入邻接矩阵数据:" << std::endl;
 8     for ( int row = 0; row < _pGraph->nVertexCount; ++row )
 9     {
10         for ( int col = 0; col < _pGraph->nVertexCount; ++col )
11         {
12             std::cin >> _pGraph->arrArcs[row][col];
13         }
14     }
15 }

接着，就是核心的Floyd算法：

 1 void floyd( int _arrDis[][MAX_VERTEX_COUNT], int _arrPath[][MAX_VERTEX_COUNT], int _nVertexCount )
 2 {
 3     // 先初始化_arrPath
 4     for ( int i = 0; i < _nVertexCount; ++i )
 5     {
 6         for ( int j = 0; j < _nVertexCount; ++j )
 7         {
 8             _arrPath[i][j] = i;
 9         }
10     }
11     //////////////////////////////////////////////////////////////////////////
12  
13     for ( int k = 0; k < _nVertexCount; ++k )
14     {
15         for ( int i = 0; i < _nVertexCount; ++i )
16         {
17             for ( int j = 0; j < _nVertexCount; ++j )
18             {
19                 if ( _arrDis[i][k] + _arrDis[k][j] < _arrDis[i][j] )
20                 {
21                     // 找到更短路径
22                     _arrDis[i][j] = _arrDis[i][k] + _arrDis[k][j];
23  
24                     _arrPath[i][j] = _arrPath[k][j];
25                 }
26             }
27         }
28     }
29 }

OK，最后是输出结果数据代码：

 1 void printResult( int _arrDis[][MAX_VERTEX_COUNT], int _arrPath[][MAX_VERTEX_COUNT], int _nVertexCount )
 2 {
 3     std::cout << "Origin -> Dest   Distance    Path" << std::endl;
 4  
 5     for ( int i = 0; i < _nVertexCount; ++i )
 6     {
 7         for ( int j = 0; j < _nVertexCount; ++j )
 8         {
 9             if ( i != j )   // 节点不是自身
10             {
11                 std::cout << i+1 << " -> " << j+1 << "\t\t";
12                 if ( INFINITE == _arrDis[i][j] )    // i -> j 不存在路径
13                 {
14                     std::cout << "INFINITE" << "\t\t";
15                 }
16                 else
17                 {
18                     std::cout << _arrDis[i][j] << "\t\t";
19  
20                     // 由于我们查询最短路径是从后往前插，因此我们把查询得到的节点
21                     // 压入栈中，最后弹出以顺序输出结果。
22                     std::stack<int> stackVertices;
23                     int k = j;
24                      
25                     do
26                     {
27                         k = _arrPath[i][k];
28                         stackVertices.push( k );
29                     } while ( k != i );
30                     //////////////////////////////////////////////////////////////////////////
31  
32                     std::cout << stackVertices.top()+1;
33                     stackVertices.pop();
34  
35                     unsigned int nLength = stackVertices.size();
36                     for ( unsigned int nIndex = 0; nIndex < nLength; ++nIndex )
37                     {
38                         std::cout << " -> " << stackVertices.top()+1;
39                         stackVertices.pop();
40                     }
41  
42                     std::cout << " -> " << j+1 << std::endl;
43                 }
44             }
45         }
46     }
47 }

好了，是时候测试了，我们用的图如下：

bubuko.com,布布扣

测试代码如下：

 1 int main( void )
 2 {
 3     Graph myGraph;
 4     readGraphData( &myGraph );
 5     //////////////////////////////////////////////////////////////////////////
 6  
 7     int arrDis[MAX_VERTEX_COUNT][MAX_VERTEX_COUNT];
 8     int arrPath[MAX_VERTEX_COUNT][MAX_VERTEX_COUNT];
 9  
10     // 先初始化arrDis
11     for ( int i = 0; i < myGraph.nVertexCount; ++i )
12     {
13         for ( int j = 0; j < myGraph.nVertexCount; ++j )
14         {
15             arrDis[i][j] = myGraph.arrArcs[i][j];
16         }
17     }
18  
19     floyd( arrDis, arrPath, myGraph.nVertexCount );
20     //////////////////////////////////////////////////////////////////////////
21  
22     printResult( arrDis, arrPath, myGraph.nVertexCount );
23     //////////////////////////////////////////////////////////////////////////
24  
25     system( "pause" );
26     return 0;
27 }

如图：

bubuko.com,布布扣

Ok哒~

非原创，原文链接：http://www.cnblogs.com/twjcnblog/archive/2011/09/07/2170306.html

Floyd算法,布布扣,bubuko.com

Floyd算法

原文：http://www.cnblogs.com/gotodsp/p/3886074.html

踩

(0)

评论一句话评论（0）