Floyd

解决最短路径问题有几个出名的算法:

1.dijkstra算法,最经典的单源最短路径算法

2.bellman-ford算法,允许负权边的单源最短路径算法

3.spfa,其实是bellman-ford+队列优化,其实和bfs的关系更密一点

4.floyd算法,经典的Floyd算法又叫做插点法

Floyd算法:

　　Floyd算法用来找出每对顶点之间的最短距离,它对图的要求是,既可以是无向图也可以是有向图,边权可以为负,但是不能存在负环(可根据最小环的正负来判定).

基本算法:

　　Floyd算法基于动态规划的思想,以 u 到 v 的最短路径至少经过前 k 个点为转移状态进行计算,通过 k 的增加达到寻找最短路径的目的.当 k 增加 1 时,最短路径要么不边,如果改变,必经过第 k 各点,也就是说当起点 u 到第 k 个点的最短距离加上第 k 个点到终点 v 的最短路径小于不经过第 k 个节点的最优最短路经长度的时候更新 u 到 v 的最短距离. 当 k = n 时, u 到 v 的最短路径就确定了. 

伪代码:

　　图的存储用邻接矩阵 gra[][] 来记录,如果 u 与 v 之间没有边直接相连,则 gra[u][v] = INF; dist[][] 记录最终的最短路. pre[i][j] 存储 i 到 j 路径中 i 的后一个节点.

　　1): 初始化:将 gra 中的数据复制到 dist 中作为每对顶点间的最短路的初值, pre[i][j] = j;

　　2): k 从 1 到 n 循环 n 次, 每次循环中枚举图中不同的两点 u, v, 如果 dist[u][v] > dist[u][k] + dist[k][v], 则更新 dist[u][v] = dist[u][k] + dist[k][v], 更新 pre[u][v] = pre[u][k].

　　3): 最后 dist[u][v] 数组中存储的就是 u 到 v 的最短距离, u 到 v 的路径, 则可以按照顺序查找就好了.

以图为例:

有一个如下的无向图, “D”数组存储最短路值, “P” 数组存储最短路径:

 

假设现在每对顶点之间的路径只允许经过点 “1” , 则更新后的每对顶点之间的距离:

 

这里看到点 “2” 到点 “3” 的距离经过点 “1” 得到了更新,同时更新了用于记录路径的 P 数组.

 

第二步,允许每对顶点之间的最短路径经过点 “1” 和点 “2”,则更新后的数组为:

 

可以看到得到更新的路径为:

1 ---> 4, 经过点 “2” 得到更新

1 ---> 5, 经过点 “2” 得到更新

3 ---> 5. 经过点 “1 --- > 2” 得到更新

 

第三步: 允许经过点 “1”, “2” 和点 “3” 则更新后的数组为:

 

这则说明,上一步的最短路径不需要更新.

 

第四步, 允许经过点 “1”, “2” , “3” 和点 “4” 则更新后的数组为:

 

可以看到 3 ---> 5 的路径经过点 “4” 得到了更新(原先是 3 ---> 1 ---> 2 ---> 5, w = 9)

 

第五步, 允许任意两点之间的最短路径可以经过全部点,则更新后的数组为:

这次得到更新的路径为:

1 ---> 4 的路径. 更新为 “1 ---> 2 ---> 5 ---> 4, w = 5” (原路径为 1 ---> 2 ---> 4, w = 7)

2 ---> 3 的路径. 更新为 “2 ---> 5 ---> 4 ---> 3, w = 7” (原路经为 2 ---> 1 ---> 3, w = 8)

2 ---> 4 的路径. 更新为 “2 --> 5 --> 4, w = 2” (原路径为 2 ---> 4, w = 4)

无向图反之亦然.

 

至此最短路径就寻找完毕. dist[i][j] 数组里面保存的就是 i 到 j 的最短距离.如果要查寻路径, 则按照查数组 pre 就好.比如查询 “2” 到 “3” 的路径:

则寻找     pre[2][3] = 5,  2 ---> 5

继续寻找  pre[5][3] = 4,  2 ---> 5 ---> 4

继续寻找  pre[4][3] = 3, 2 ---> 5 ---> 4 ---> 3

由于此时 i = j = 3, 则 “2” 到 “3” 的最短路径已找到为: 2 ---> 5 ---> 4 ---> 3

扔个例题~(洛谷P2910)

题目描述

农夫约翰正驾驶一条小艇在牛勒比海上航行．

海上有N(1≤N≤100)个岛屿，用1到N编号．约翰从1号小岛出发，最后到达N号小岛．

一张藏宝图上说，如果他的路程上经过的小岛依次出现了Ai，A2，…，AM(2≤M≤10000)这样的序列（不一定相邻），那他最终就能找到古老的宝藏． 但是，由于牛勒比海有海盗出没．约翰知道任意两个岛屿之间的航线上海盗出没的概率，他用一个危险指数Dij(0≤Dij≤100000)来描述．他希望他的寻宝活动经过的航线危险指数之和最小．那么，在找到宝藏的前提下，这个最小的危险指数是多少呢？

输入输出格式

输入格式：

第一行：两个用空格隔开的正整数N和M

第二到第M+1行：第i+1行用一个整数Ai表示FJ必须经过的第i个岛屿

第M+2到第N+M+1行：第i+M+1行包含N个用空格隔开的非负整数分别表示i号小岛到第1...N号小岛的航线各自的危险指数。保证第i个数是0。

输出格式

第一行：FJ在找到宝藏的前提下经过的航线的危险指数之和的最小值。

说明 这组数据中有三个岛屿，藏宝图要求FJ按顺序经过四个岛屿：1号岛屿、2号岛屿、回到1号岛屿、最后到3号岛屿。每条航线的危险指数也给出了：航路(1，2)、(2，3)、(3，1)和它们的反向路径的危险指数分别是5、2、1。

FJ可以通过依次经过1、3、2、3、1、3号岛屿以7的最小总危险指数获得宝藏。这条道路满足了奶牛地图的要求（1，2，1，3）。我们避开了1号和2号岛屿之间的航线，因为它的危险指数太大了。

注意：测试数据中a到b的危险指数不一定等于b到a的危险指数！

把危险值当做距离的话，就是求最短路了，正好可以练练Floyd~

代码滴滴~

#include<bits/stdc++.h>
using namespace std;
int n,m,sum,a[101][101],b[100001];
int main(){
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    cin>>b[i];
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    cin>>a[i][j];
    for(int k=1;k<=n;k++)  //弗洛伊德算法
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    if(i!=j&&j!=k&&k!=i&&a[i][j]>a[i][k]+a[k][j])  //求出两地之间的最短距离
    a[i][j]=a[i][k]+a[k][j];
    for(int i=2;i<=m;i++)
    sum+=a[b[i-1]][b[i]];  //累加
    cout<<sum<<endl;
    return 0;
}