整合：求最短路算法 floyd prim dijkstra Kruskal spfa算法简析
(转载）
一、floyd算法（快速计算i到j的最短距离，复杂度高[n^3]）
1.定义概览
Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。Floyd-Warshall算法的时间复杂度为O(N3)，空间复杂度为O(N2)。
2.算法描述
1)算法思想原理：
Floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所在）
从任意节点i到任意节点j的最短路径不外乎2种可能，1是直接从i到j，2是从i经过若干个节点k到j。所以，我们假设Dis(i,j)为节点u到节点v的最短路径的距离，对于每一个节点k，我们检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，证明从i到k再到j的路径比i直接到j的路径短，我们便设置Dis(i,j) = Dis(i,k) + Dis(k,j)，这样一来，当我们遍历完所有节点k，Dis(i,j)中记录的便是i到j的最短路径的距离。
2).算法描述：
a.从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。
b.对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比己知的路径更短。如果是更新它。
3).Floyd算法过程矩阵的计算----十字交叉法
方法：两条线，从左上角开始计算一直到右下角 如下所示
给出矩阵，其中矩阵A是邻接矩阵，而矩阵Path记录u,v两点之间最短路径所必须经过的点
相应计算方法如下：
最后A3即为所求结果
代码实现：初始化：D[u,v]=A[u,v]（A为邻接矩阵）
for (int k = 1; k <= n; k++)
for(int i = 1; i <= n; i++)
for(int j = 1; j <= n; j++){
if (d[i][k] + d[k][j] < d[i][j])
d[i][j] = d[i][k] + d[k][j];
}二、prim算法（每次选取一条边。该边满足：1、一端已选，一端未选；2、该边权值最小。)
1、普利姆（Prime）算法（只与顶点相关）
2、算法描述：
普利姆算法求最小生成树时候，和边数无关，只和定点的数量相关，所以适合求稠密网的最小生成树，时间复杂度为O（n*n）。
3、算法过程：
1.将一个图的顶点分为两部分，一部分是最小生成树中的结点（A集合），另一部分是未处理的结点（B集合）。
2.首先选择一个结点，将这个结点加入A中，然后，对集合A中的顶点遍历，找出A中顶点关联的边权值最小的那个（设为v），将此顶点从B中删除，加入集合A中。
3.递归重复步骤2，直到B集合中的结点为空，结束此过程。
4.A集合中的结点就是由Prime算法得到的最小生成树的结点，依照步骤2的结点连接这些顶点，得到的就是这个图的最小生成树。
4、算法实现具体过程：
1.将第一个点放入最小生成树的集合中（标记visit[i]=1意思就是最小生成树集合）。
2.从第二个点开始，初始化lowcost[i]为跟1点相连（仅仅相连）的边的权值（lowcost[i]不是这个点的最小权值！在以后会逐步更新）。
3.找最小权值的边。
从第二点开始遍历，如果不是最小生成树的集合的点，则找出从2到n的最小权值（lowcost[j]）。
4.将找出来的最小权值的边的顶点加入最小生成树的集合中（标记visit[i] = 1），权值想加。
5.更新lowcost[j]集合。
假设第一次：lowcost[2]代表与1相连的点的权值，现在加入了k点。则比较k点与2点的边map[k][2]和lowcost[2]的大小，若lowcost[2]大，则lowcost[2] = map[k][2]。（关键步骤：实质就是每在最小生成树集合中加入一个点就需要把这个点与集合外的点比较，不断的寻找两个集合之间最小的边）
6.循环上述步骤，指导将全部顶点加入到最小生成树集合为止。
5、图例演示
6、代码实现：
void prim()
{
int temp, k;
sum = 0;
memset(visit, false, sizeof(visit)); //初始化visit
visit[1] = true;
for(int i = 1; i <= n; ++i) //初始化d[i]
d[i] = map[1][i];
for(int i = 1; i <= n; ++i)//找生成树集合点集相连最小权值的边
{
temp = INF;
for(int j = 1; j <= n; ++j)
if(!visit[j] && temp > d[j])
temp = d[k = j];
if(temp == INF) break;
visit[k] = true; //加入最小生成树集合
sum += temp;//记录权值之和
for(int j = 1; j <= n; ++j) //更新d数组
if(!visit[j] && d[j] > map[k][j])
d[j] = map[k][j];
}
} 三、dijkstra算法
1.定义概览
Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。注意该算法要求图中不存在负权边。
问题描述：在无向图 G=(V,E) 中，假设每条边 E[i] 的长度为 w[i]，找到由顶点 V0 到其余各点的最短路径。（单源最短路径）
2.算法描述
1)算法思想：设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组，第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将加入到集合S中，直到全部顶点都加入到S中，算法就结束了），第二组为其余未确定最短路径的顶点集合（用U表示），按最短路径长度的递增次序依次把第二组的顶点加入S中。在加入的过程中，总保持从源点v到S中各顶点的最短路径长度不大于从源点v到U中任何顶点的最短路径长度。此外，每个顶点对应一个距离，S中的顶点的距离就是从v到此顶点的最短路径长度，U中的顶点的距离，是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。
2)算法步骤：
a.初始时，S只包含源点，即S＝{v}，v的距离为0。U包含除v外的其他顶点，即:U={其余顶点}，若v与U中顶点u有边，则
b.从U中选取一个距离v最小的顶点k，把k，加入S中（该选定的距离就是v到k的最短路径长度）。
c.以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值的顶点k的距离加上边上的权。
d.重复步骤b和c直到所有顶点都包含在S中。
执行动画过程如下图
3.算法代码实现：
void Dijkstra(int v0)
{
bool S[MAXNUM]; // 判断是否已存入该点到S集合中
int n=MAXNUM;
for(int i=1; i<=n; ++i)
{
dist[i] = A[v0][i];
S[i] = false; // 初始都未用过该点
if(dist[i] == MAXINT)
prev[i] = -1;
else
prev[i] = v0;
}
dist[v0] = 0;
S[v0] = true;
for(int i=2; i<=n; i++)
{
int mindist = MAXINT;
int u = v0; // 找出当前未使用的点j的dist[j]最小值
for(int j=1; j<=n; ++j)
if((!S[j]) && dist[j]四、Kruskal算法
克鲁斯卡尔算法的核心思想是：在带权连通图中，不断地在边集合中找到最小的边，如果该边满足得到最小生成树的条件，就将其构造，直到最后得到一颗最小生成树。
克鲁斯卡尔算法的执行步骤：
第一步：在带权连通图中，将边的权值排序；
第二步：判断是否需要选择这条边（此时图中的边已按权值从小到大排好序）。判断的依据是边的两个顶点是否已连通，如果连通则继续下一条；如果不连通，那么就选择使其连通。
第三步：循环第二步，直到图中所有的顶点都在同一个连通分量中，即得到最小生成树。
下面我用图示法来演示克鲁斯卡尔算法的工作流程，如下图：
判断法则：当将边CI加入到已找到边的集合中时，是否会形成回路？
1.如果没有形成回路，那么直接将其连通。 此时，对于边的集合又要做一次判断：这两个点是否在已找到点的集合中出现过？
①.如果两个点都没有出现过，那么将这两个点都加入已找到点的集合中；
②.如果其中一个点在集合中出现过，那么将另一个没有出现过的点加入到集合中；
③.如果这两个点都出现过，则不用加入到集合中。
2.如果形成回路，不符合要求，直接进行下一次操作。
根据判断法则，不会形成回路，将点C和点I连通，并将点C和点I加入到集合中。如图：
继续，这次选择边AH，根据判断法则，不会形成回路，将其连通，此时这两个点已经在集合中了，所以不用加入。
继续，这次选择边BC，根据判断法则，会形成回路，直接进行下一次操作。
继续，这次选择边DE，根据判断法则，不会形成回路，将其连通，并将点E加入到集合中。如图：
最后选择边DF，根据法则，会形成回路，不将其连通，也不用加入到集合中。
好了，所有的边都遍历完成了，所有的顶点都在同一个连通分量中，我们得到了这颗最小生成树。
通过生成的过程可以看出，能否得到最小生成树的核心问题就是上面所描述的判断法则。那么，我们如何用算法来描述判断法则呢？我认为只需要三个步骤即可：
⒈将某次操作选择的边XY的两个顶点X和Y和已找到点的集合作比较，如果
①.这两个点都在已找到点的集合中，那么return 2；
②.这两个点有一个在已找到点的集合中，那么return 1；
③这两个点都不在一找到点的集合中，那么return 0；
⒉当返回值为0或1时，可判定不会形成回路；
⒊当返回值为2时，判定能形成回路的依据是：假如能形成回路，设能形成回路的点的集合中有A,B,C,D四个点，那么以点A为起始点，绕环路一周后必能回到点A。如果能回到，则形成回路；如果不能，则不能形成回路。
算法代码如下：
#include //定义输入／输出函数
#include //定义各种数据类型最值常量
#include //定义数学函数
#include //定义杂项函数及内存分配函数
#include //字符串处理
#include //算法
#include //队列
#include //栈
using namespace std;
int N, M;
int re[1005]; //源根
int finds(int x){ //找根函数
if (re[x] == x) return x;
else return re[x] = finds(re[x]);
}
struct node{
int from, to, cost;
};
node a[20005];
int vis[1005];
int cmp(node a, node b){return a.cost > b.cost;}
long long sum;
int flag;
int main()
{
while (scanf("%d%d", &N, &M) != EOF){
for (int i = 0; i < M; i++)
scanf("%d%d%d", &a[i].from, &a[i].to, &a[i].cost);
sort(a, a+M, cmp);
//读取输入
for (int i = 0; i <= N; i++) re[i] = i;
//根重置
memset(vis, 0, sizeof(vis));
//访问重置
sum = flag = 0;
for (int i = 0; i < M; i++){
if (finds(a[i].from) == finds(a[i].to)) continue;
//如果查找后两数根不相等，则进行以下程序
re[finds(a[i].from)] = finds(a[i].to);
//直接把一根连在另一根的生成树上
vis[a[i].from] = 1;
vis[a[i].to] = 1;
sum += a[i].cost;
}
for (int i = 1; i <= N; i++){
if (vis[i] == 0) flag = 1;
if (finds(i) != finds(1)) flag = 1;
}
if (flag == 1) printf("-1\n");
else printf("%lld\n", sum);
}
} 五、spfa算法
对SPFA的一个很直观的理解就是由无权图的BFS转化而来。在无权图中，BFS首先到达的顶点所经历的路径一定是最短路(也就是经过的最少顶点数)，所以此时利用数组记录节点访问可以使每个顶点只进队一次，但在带权图中，最先到达的顶点所计算出来的路径不一定是最短路。一个解决方法是放弃数组，此时所需时间自然就是指数级的，所以我们不能放弃数组，而是在处理一个已经在队列中且当前所得的路径比原来更好的顶点时，直接更新最优解。
代码实现：
#include
#include
#include
#include
#include
#include
#define MAXN 150005
const int INF = 9999999;
using namespace std;
int N, M;
struct node{
int to, cost;
int next;
};
node e[150005];
int d[30005], adj[30005];
//d数组表示到原点的最短距离，adj表示某一点最后出现的位置；
bool vis[30005];
void spfa()
{
for (int i = 0; i < 30005; i++) d[i] = INF;
d[1] = 0;
memset(vis, 0, sizeof(vis));
int sta[30005];
栈模拟，等价于用stack
int top = 0;
vis[1] = 1;
sta[++top] = 1;
while (top){
int pos = sta[top--];
vis[pos] = 0;
for (int i = adj[pos]; i != -1; i = e[i].next){
int to = e[i].to;
int cost = e[i].cost;
if (d[to] > d[pos] + cost){
d[to] = d[pos] + cost;
if (vis[to] == 0){
sta[++top] = to;
vis[to] = 1;
}
}
}
}
return;
}
int a, b, c;
int main()
{
while (scanf("%d%d", &N, &M) != EOF){
memset(vis,0,sizeof(vis));
for (int i = 0; i < 30005; i ++) adj[i] = -1;
//多组数据必要的清空
for (int i = 0; i < M; i++){
scanf("%d%d%d", &a, &b, &c);
e[i].to = b;
e[i].cost = c;
e[i].next = adj[a];
adj[a] = i;
}
spfa();
printf("%d\n", d[N]);
}
}