Floyd再思考
——by ThinkofBlank
一.序言
Floyd,是一个十分常用的图论算法，其作用是在O(n^3)的时间内计算出全源最短路。其实现原理是利用的dp,然而，刚开始接触Floyd的时候，并没有去尝试理解，思考此算法，仅仅记了下打法就跑了，最近无聊时思考了下，得出了些有用的东西，特此来分享
注意:以下说的图都是无负环的，不然，求甚么最短路。。。
当然，给出的图是联通且点的个数至少为3
二.引入
1、路径合成可行性
给定一个图,假设我们已知i->j的最短路径为a1,i->k的最短路径为a2,(a1<a2)，那么j->k的最短路径是多少？
答案是a2-a1?不！并不是，比如下图：
很明显的，j->k的最短路径应该是a1+a2才对,当然，也有满足最短路径为a1-a2的情况，如下图:
所以，如果我们单纯地知道i->j和i->k的最短路径，我们是无法求出正确的j->k的最短路径的
那么，我们来换一换,假设我们已知i->k的最短路径为a1,k->j的最短路径为a2,那么i->j的最短路径是不是就可求呢？
初步画个图:
由此可以判断出i->j的最短路径是a1+a2,于是就又错啦！
以下给出两个hack的情况:
当然，对于第一个hack的情况，要j和k之间的是双相边
于是，我们真的无法求出来了吗？不！
我们注意到，对于两种hack的情况，其实它都可以看出i->k,k->j的行走方式，只是某些时候，k=i或j罢了！
所以，就有:对于一条路径i->j,它可以由i->k,k->j合成，那么我们只需要合成就好了。这就是路径的合成可行性
感性的理解:由i到j,我们可以先从i到k，再从k到j，如果直接由i到j中途不停留的话，那么相当于此时k=i或者j
那么，这里就有一个方法了！
我们枚举所有的k!这样，我们就可以枚举出所有的路径出来！然后把这些权值取最小,即一定为最小路径！
首先，我们设dis(i,j)表示i->j的最短路径(初始无限大)，那么如果有一条边权为w从i->j的边，我们就令dis(i,j)=min(dis(i,j),w)
这样我们就求出了对于所有i->k,k->j中k=i或j的时候的路径了
那么之后怎么求呢？
简单啊！
枚举k嘛，我就老老实实枚举k和i,j就好了嘛
for:i=1->n
for:j=1->n
for:k=1->n
dis(i,j)=min(dis(i,j),dis(i,k)+dis(k,j))
看，这不就好了嘛！
然而，这是错的。。。
为啥？
因为我们回过去看枚举所有k得到最短路径的条件:dis(i,k)与dis(k,j)一定也是最短路径!
但是，我们目前，我们对于部分dis(i,k)和dis(k,j)并没有枚举，所以，我们的答案不一定正确！
那么该如何改进呢？
传统的Floyd是使用松弛操作进行的:
for:k=1->n
for:i=1->n
for:j=1->n
dis(i,j)=min(dis(i,j),dis(i,k)+dis(k,j))
咋看一下没啥不同，但事实上，它是在进行dp,具体的我就不说多了，现在来讨论下Floyd的Ex算法:
先来引入一个定理:
2、一定存在两个点最短路径为它们两个点的直接连边
先者有言:没有证明的理论，都是猜想，不能直接用
那么，我们就来证明一波
我使用的是反证法:
假设所有点两两之间的最短路都间隔了至少经过了一个点
我们设i->j的最短路为i->k->j
那么，不难发现，如果i->k的最短路不是i,k的直接连边，而是i->t->k的话，那么明显有i->j的最短路中
i->t->k->j更优
那么i->j的最短路不止经过一点呢，我们直接假设为i->t->k->j,我们可以同理去分析i->t
所以，这与假设不相符
所以，命题得证。
而且,同理去分析k->j，还会再多得一对点，所以对于任意一对最短路为直接连边的两点A,B
我们一定可以找到另外的一个点C，使得那个点与两点中的其中一个点(假设为B)的直接连边是最小路径
简单分析下便可发现，这样的点对至少有n-1个
那么，如果我们找到所有这样的点对，我们就可以再推出至少n-2条最短路径,然后再用这n-2条路径继续推...
循环n-1次便可以推完所有的最短路径了！
三、算法
那，我们怎么找到这n-1条边呢？对于一个图，我们可以采用玄学的方法——枚举法！
这样，我们就有了一个算法的雏形:
一开始的赋值就不说了。。。
首先，我们将所有边加入对应的表中(使用数组即可~),比如u->v，我们就令s(u,++siz(u))=v,表示，我们有一条从
u->v的确定了权值的边（不一定最小）
然后，我们进行一下操作:
1.枚举i
2.访问与i相连的边，找到一个k
3.访问与k相连的边，找到一个j
4.如果dis(i,k)+dis(k,j)<dis(i,j)，我们令dis(i,j)=dis(i,k)+dis(k,j)，并把j加入i的表中
5.回到步骤1，重复n-2次即可(第一次是赋值那里)
两个优化:
1.对于每个点来说，我们维护一个bool数组ys(i,j)表示j是否在i的表里面，如果是，我们就无需把j加入表中，否则，我们就将j加入表中，并使ys(i,j)=1
2.对于不在起作用的表，我们将它砍掉，无需再访问(详细见代码的kil数组)
于是我们有了代码:
//#pragma GCC optimize()//手动Ox优化
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int M=1001;
int dis[M][M];
int s[M][M],siz[M];
bool kil[M][M];
bool ys[M][M];
inline void Ex_Floyd(int n){
int tim=n-2;
while(tim--){
bool flag=0;
for(int i=1;i<=n;++i){
for(int j=1;j<=siz[i];++j){
int v=s[i][j];
if(kil[i][j]){
continue;
}
kil[i][j]=1;
for(int k=1;k<=siz[v];++k){
int e=s[v][k];
if(dis[i][e]>dis[i][v]+dis[v][e]){
dis[i][e]=dis[i][v]+dis[v][e];
if(!ys[i][e]){
ys[i][e]=1;
s[i][++siz[i]]=e;
}
flag=1;
kil[i][j]=0;
}
}
}
}
if(!flag){
break;
}
}
}
signed main(){
int n,m;
scanf("%lld%lld",&n,&m);
for(int i=1;i<=n;++i){
for(int j=1;j<=n;++j){
dis[i][j]=1e16;
}
dis[i][i]=0;
}
for(int i=1;i<=m;++i){
int u,v,w;
scanf("%lld%lld%lld",&u,&v,&w);
if(dis[u][v]>w){
if(!ys[u][v]){
ys[u][v]=1;
s[u][++siz[u]]=v;
}
dis[u][v]=w;
}
}
Ex_Floyd(n);
return 0;
}
我们把它称作Ex_Floyd算法，为什么呢？我们通过一道题来说明:
http://ybt.ssoier.cn:8088/problem_show.php?pid=1421
我们惊奇的发现，传统的Floyd算法竟然无法通过此题，而此算法可以
经过尝试发现，Floyd错的点中，存在负权边
事实证明，传统的Floyd似乎不能跑负权边啊。。。
而此算法可以，故命名为Ex_Floyd(经过一番尝试后,发现,此算法应与Floyd的复杂度接近,不过常数可能会大点)