Floyd算法

Floyd算法又称为弗洛伊德算法，插点法，是一种用于寻找给定的加权图中顶点间最短路径的算法。

核心思路

通过一个图的权值 矩阵求出它的每两点间的 最短路径 矩阵。

从图的带权 邻接矩阵A=[a(i,j)] n×n开始， 递归地进行n次更新，即由矩阵D(0)=A，按一个公式，构造出矩阵D(1)；又用同样地公式由D(1)构造出D(2)；……；最后又用同样的公式由D(n-1)构造出 矩阵D(n)。 矩阵D(n)的i行j列元素便是i号顶点到j号顶点的 最短路径长度，称D(n)为图的 距离矩阵，同时还可引入一个后继节点矩阵path来记录两点间的最短路径。

采用的是(松弛技术)，对在i和j之间的所有其他点进行一次松弛。所以 时间复杂度为O(n^3);

其状态转移方程如下： map[i,j]:=min{map[i,k]+map[k,j],map[i,j]}

map[i,j]表示i到j的最短距离

K是穷举 i,j的断点

map[n,n]初值应该为0，或者按照题目意思来做。

当然，如果这条路没有通的话，还必须特殊处理，比如没有map[i,k]这条路

算法过程
1，从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。

2，对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比已知的路径更短。如果是更新它。

===

把图用邻接距阵G表示出来，如果从Vi到Vj有路可达，则G[i,j]=d，d表示该路的长度；否则G[i,j]=无穷大。

定义一个距阵D用来记录所插入点的信息，D[i,j]表示从Vi到Vj需要经过的点，初始化D[i,j]=j。

把各个顶点插入图中，比较插点后的距离与原来的距离，G[i,j] = min( G[i,j], G[i,k]+G[k,j] )，如果G[i,j]的值变小，则D[i,j]=k。

在G中包含有两点之间最短道路的信息，而在D中则包含了最短通路径的信息。

比如，要寻找从V5到V1的路径。根据D，假如D(5,1)=3则说明从V5到V1经过V3，路径为{V5,V3,V1}，如果D(5,3)=3，说明V5与V3直接相连，如果D(3,1)=1，说明V3与V1直接相连。

时间复杂度
O(n^3)

优缺点分析

Floyd 算法适用于APSP(All Pairs Shortest Paths)，是一种动态规划 算法，稠密图效果最佳，边权可正可负。此 算法简单有效，由于三重循环结构紧凑，对于稠密图，效率要高于执行|V|次 Dijkstra算法。

优点：容易理解，可以算出任意两个节点之间的最短距离，代码编写简单

缺点： 时间复杂度比较高，不适合计算大量数据。

算法描述

a)　初始化：D[u,v]=A[u,v]

b)　For k:=1 to n

For i:=1 to n

For j:=1 to n

If D[i,j]>D[i,k]+D[k,j] Then

D[I,j]:=D[I,k]+D[k,j];

c)　 算法结束：D即为所有点对的最短路径矩阵

#define INFINITE 1000           // 最大值 #define MAX_VERTEX_COUNT 20 　　// 最大顶点个数 //   struct Graph {      int     arrArcs[MAX_VERTEX_COUNT][MAX_VERTEX_COUNT];    // 邻接矩阵      int     nVertexCount;                               　　 // 顶点数量      int     nArcCount;                                  　　 // 边的数量 }; //

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

void readGraphData( Graph *_pGraph )

{

     std::cout << "请输入顶点数量和边的数量: " ;

     std::cin >> _pGraph->nVertexCount;

     std::cin >> _pGraph->nArcCount;

 

     std::cout << "请输入邻接矩阵数据:" << std::endl;

     for ( int row = 0; row < _pGraph->nVertexCount; ++row )

     {

         for ( int col = 0; col < _pGraph->nVertexCount; ++col )

         {

             std::cin >> _pGraph->arrArcs[row][col];

         }

     }


}

接下来就是Floyd的核心算法


void floyd( int _arrDis[][MAX_VERTEX_COUNT], int _arrPath[][MAX_VERTEX_COUNT], int _nVertexCount )

{

     // 先初始化_arrPath

     for ( int i = 0; i < _nVertexCount; ++i )

     {

         for ( int j = 0; j < _nVertexCount; ++j )

         {

             _arrPath[i][j] = i;

         }

     }

     //

 

     for ( int k = 0; k < _nVertexCount; ++k )

     {

         for ( int i = 0; i < _nVertexCount; ++i )

         {

             for ( int j = 0; j < _nVertexCount; ++j )

             {

                 if ( _arrDis[i][k] + _arrDis[k][j] < _arrDis[i][j] )

                 {

                     // 找到更短路径

                     _arrDis[i][j] = _arrDis[i][k] + _arrDis[k][j];

 

                     _arrPath[i][j] = _arrPath[k][j];

                 }

             }

         }

     }

}

输出结果数据代码

void printResult( int _arrDis[][MAX_VERTEX_COUNT], int _arrPath[][MAX_VERTEX_COUNT], int _nVertexCount )

{

     std::cout << "Origin -> Dest   Distance    Path" << std::endl;

 

     for ( int i = 0; i < _nVertexCount; ++i )

     {

         for ( int j = 0; j < _nVertexCount; ++j )

         {

             if ( i != j )   // 节点不是自身

             {

                 std::cout << i+1 << " -> " << j+1 << "\t\t" ;

                 if ( INFINITE == _arrDis[i][j] )    // i -> j 不存在路径

                 {

                     std::cout << "INFINITE" << "\t\t" ;

                 }

                 else

                 {

                     std::cout << _arrDis[i][j] << "\t\t" ;

 

                     // 由于我们查询最短路径是从后往前插，因此我们把查询得到的节点

                     // 压入栈中，最后弹出以顺序输出结果。

                     std::stack< int > stackVertices;

                     int k = j;

                     

                     do

                     {

                         k = _arrPath[i][k];

                         stackVertices.push( k );

                     } while ( k != i );

                     //

 

                     std::cout << stackVertices.top()+1;

                     stackVertices.pop();

 

                     unsigned int nLength = stackVertices.size();

                     for ( unsigned int nIndex = 0; nIndex < nLength; ++nIndex )

                     {

                         std::cout << " -> " << stackVertices.top()+1;

                         stackVertices.pop();

                     }

 

                     std::cout << " -> " << j+1 << std::endl;

                 }

             }

         }

     }

}

int main( void )

{

     Graph myGraph;

     readGraphData( &myGraph );

     //

 

     int arrDis[MAX_VERTEX_COUNT][MAX_VERTEX_COUNT];

     int arrPath[MAX_VERTEX_COUNT][MAX_VERTEX_COUNT];

 

     // 先初始化arrDis

     for ( int i = 0; i < myGraph.nVertexCount; ++i )

     {

         for ( int j = 0; j < myGraph.nVertexCount; ++j )

         {

             arrDis[i][j] = myGraph.arrArcs[i][j];

         }

     }

 

     floyd( arrDis, arrPath, myGraph.nVertexCount );

     //

 

     printResult( arrDis, arrPath, myGraph.nVertexCount );

     //

 

     system ( "pause" );

     return 0;

}