Floyd算法的介绍
算法的特点：
弗洛伊德算法是解决任意两点间的最短路径的一种算法，可以正确处理有向图或有向图或负权（但不可存在负权回路)的最短路径问题，同时也被用于计算有向图的传递闭包。
算法的思路
通过Floyd计算图G=(V,E)中各个顶点的最短路径时，需要引入两个矩阵，矩阵S中的元素a[i][j]表示顶点i(第i个顶点)到顶点j(第j个顶点)的距离。矩阵P中的元素b[i][j]，表示顶点i到顶点j经过了b[i][j]记录的值所表示的顶点。
假设图G中顶点个数为N，则需要对矩阵D和矩阵P进行N次更新。初始时，矩阵D中顶点a[i][j]的距离为顶点i到顶点j的权值；如果i和j不相邻，则a[i][j]=∞，矩阵P的值为顶点b[i][j]的j的值。 接下来开始，对矩阵D进行N次更新。第1次更新时，如果”a[i][j]的距离” > “a[i][0]+a[0][j]”(a[i][0]+a[0][j]表示”i与j之间经过第1个顶点的距离”)，则更新a[i][j]为”a[i][0]+a[0][j]”,更新b[i][j]=b[i][0]。 同理，第k次更新时，如果”a[i][j]的距离” > “a[i][k-1]+a[k-1][j]”，则更新a[i][j]为”a[i][k-1]+a[k-1][j]”,b[i][j]=b[i][k-1]。更新N次之后，操作完成！
Floyd算法的实例过程
上面，我们已经介绍了算法的思路，如果，你觉得还是不理解，那么通过一个实际的例子，把算法的过程过一遍，你就明白了，如下图，我们求下图的每个点对之间的最短路径的过程如下：
第一步：
我们先初始化两个矩阵，得到下图两个矩阵：
、
第二步：
以v1为中阶，更新两个矩阵：发现，a[1][0]+a[0][6] < a[1][6] 和a[6][0]+a[0][1] < a[6][1]，所以我们只需要矩阵D和矩阵P，结果如下：
通过矩阵P，我发现v2–v7的最短路径是：v2–v1–v7
第三步：
以v2作为中介，来更新我们的两个矩阵，使用同样的原理，扫描整个矩阵，得到如下图的结果：
OK，到这里我们也就应该明白Floyd算法是如何工作的了，他每次都会选择一个中介点，然后，遍历整个矩阵，查找需要更新的值，下面还剩下五步，就不继续演示下去了，理解了方法，我们就可以写代码了。
代码：
floyd.h
#ifndef FLOYD_H
#define FLOYD_H
#pragma once
#include <iostream>
#include <string>
using namespace std;
class Graph_DG
{
private:
int vexnum; // 图中顶点个数
int edge; // 图的边数
int **arc; // 邻接矩阵
int **dis; // 记录各个顶点最短路径的信息
int **path; // 记录各个最短路径
public:
Graph_DG(int v, int e);
~Graph_DG();
// 判断每次输入的边是否合法，顶点从1开始编号
bool check_edge_value(int start, int end);
void creatGraph(int kind);
void print(); // 打印邻接矩阵
void Floyd();
void print_path(); // 打印最短路径
};
#endif // FLOYD_H
floyd.cpp
#include "floyd.h"
Graph_DG::Graph_DG(int v, int e)
{
vexnum = v;
edge = e;
arc = new int*[vexnum];
dis = new int*[vexnum];
path = new int*[vexnum];
for (int i = 0; i < vexnum; ++i)
{
arc[i] = new int[vexnum];
dis[i] = new int[vexnum];
path[i] = new int[vexnum];
for (int j = 0; j < vexnum; ++j)
{
// 邻接矩阵初始化为无穷大
arc[i][j] = INT_MAX;
}
}
}
Graph_DG::~Graph_DG()
{
for (int i = 0; i < vexnum; ++i)
{
delete [] this->arc[i];
delete [] this->dis[i];
delete [] this->path[i];
}
delete [] arc;
delete [] dis;
delete [] path;
}
// 判断我们每次输入的的边的信息是否合法
//顶点从1开始编号
bool Graph_DG::check_edge_value(int start, int end)
{
if (start < 1 || end < 1 || start > vexnum || end > vexnum) // Floyd算法，权值可以为负
{
return false;
}
return true;
}
void Graph_DG::creatGraph(int kind)
{
cout << "请输入每条边的起点和终点（顶点编号从1开始）以及其权重" << endl;
int start, end, weight;
int count = 0;
while (count != edge)
{
cin >> start >> end >> weight;
while (!check_edge_value(start, end))
{
cout << "输入的边的信息不合法，请重新输入" << endl;
cin >> start >> end >> weight;
}
arc[start-1][end-1] = weight;
// 无向图添加这一句
if (kind == 2)
{
arc[end-1][start-1] = weight;
}
++count;
}
}
void Graph_DG::print()
{
cout << "图的邻接矩阵为：" << endl;
int row = 0;
int col = 0;
while (row != vexnum)
{
col = 0;
while (col != vexnum)
{
if (arc[row][col] == INT_MAX)
{
cout << "∞ ";
}
else
{
cout << arc[row][col] << " ";
}
++col;
}
cout << endl;
++row;
}
}
void Graph_DG::Floyd()
{
int row, col;
for (row = 0; row < vexnum; ++row)
{
for (col = 0; col < vexnum; ++col)
{
// 把矩阵D初始化为邻接矩阵
dis[row][col] = arc[row][col];
// 矩阵P的初值为各个边的终点顶点下标
path[row][col] = col;
}
}
// 三重循环，用于计算每两个点之间的最短路径.【动态规划的思想】
int temp, select;
for (temp = 0; temp < vexnum; ++temp)
{
for (row = 0; row < vexnum; ++row)
{
for (col = 0; col < vexnum; ++ col)
{
// 为防止溢出，引入一个select值
select = (dis[row][temp] == INT_MAX || dis[temp][col] == INT_MAX) ?
INT_MAX : dis[row][temp] + dis[temp][col];
if (dis[row][col] > select)
{
// 更新D矩阵
dis[row][col] = select;
// 更新P矩阵
path[row][col] = path[row][temp];
}
}
}
}
}
void Graph_DG::print_path()
{
cout << "各个顶点对的最短路径：" << endl;
int row, col, temp;
for (row = 0; row < vexnum; ++row)
{
for (col = row + 1; col < vexnum; ++col)
{
cout << "v" << to_string(row + 1) << "---v" << to_string(col + 1) << " weight: "
<< dis[row][col] << " path: v" << to_string(row + 1);
temp = path[row][col];
// 循环输出途径的每条路径
while (temp != col)
{
// path[i][j] = k, 表示从i走到j，第一步需要从i到k
// 同理，再从k到j,第一步需要走到path[k][j]
cout << "-->v" << to_string(temp + 1);
temp = path[temp][col];
}
cout << "-->v" << to_string(col + 1) << endl;
}
cout << endl;
}
}
main.cpp
#include <floyd.h>
//顶点数和边数的关系是：((Vexnum*(Vexnum - 1)) / 2) < edge
bool check(int vexnum, int edge)
{
if (vexnum <= 0 || edge <= 0 || (vexnum*(vexnum-1)/2) < edge)
{
return false;
}
return true;
}
int main()
{
int vexnum, edge, kind;
cout << "输入图的种类：1代表有向图，2代表无向图" << endl;
cin >> kind;
while (1)
{
if (kind == 1 || kind == 2)
{
break;
}
else
{
cout << "输入的图的种类编号不合法，请重新输入：1代表有向图，2代表无向图" << endl;
cin >> kind;
}
}
cout << "输入图的顶点个数和边的条数：" << endl;
cin >> vexnum >> edge;
while(!check(vexnum, edge))
{
cout << "输入的数值不合法，请重新输入" << endl;
cin >> vexnum >> edge;
}
Graph_DG graph(vexnum, edge);
graph.creatGraph(kind);
graph.print();
graph.Floyd();
graph.print_path();
return 0;
}
运行结果：
注：
- 原文代码中，析构函数部分delete后面没有加 [] ，会出现内存泄漏的情况。
- Floyd算法可以对负权值图进行求解，若出现负环，则原问题本身无法求解，因此Floyd算法也可用于检验是否出现负环（初始化所有dis[i][i] = 0，在第三层循环relax结束后，加一个判断dis[i][i]是否为负，若为负则说明存在负环，详细代码可参考下一篇博客）。
- 在打印路径部分，对path[i][j]的理解如下：path[i][j] = k, 表示从i走到j，第一步需要从i到k；同理，再从k到j,第一步需要走到path[k][j]。
- Floyd算法本身采用的是动态规划的思想。
参考资料：https://blog.csdn.net/qq_35644234/article/details/60875818