floyd算法

floyd算法好像是图论算法里面最简单的一个算法（好写又好理解），应该没有之一了，

floyd算法解决的是多源最短路的问题，模板是最最最最最最简单的。原理上就是动态规划。

动态规划不要从局部上去进行分析。先搞清楚问题的本质，我们在一个多源的图中。现在的要求是:从i到j中途不经过索引比k大的点的最短路径。那么可以写成f[k,i,j].但是我们可以去进行状态转移。
大白话就是：从i点进行出发，讲过1-k这些点，然后最终到达j的最短距离。

分析如下：从i—>j,存在两种选择：
直接从i到j；
从i经过若干个节点k到j。现在【1，k】，往前退一步，变成了【1，k-1】+第k条边的路径
那么可以得出转台转移方程：f[k,i,j]=f[k-1,i,k]+f[k-1,k,j]
优化后：f[i,j]=f[i,k]+f[k,j]

floyd算法的图解

//floyd算法的时间复杂度比较搞，n^3。
//图中可能存在重边和自环,边权可能为负数。
//多源汇最短路，本质上是动态规划
#include <iostream>
#include <algorithm>
using namespace std;
const int N=210,INF=1e9;
//用临界矩阵去进行存储。d[i][j]存在
int d[N][N];
int n,m,q;//
//此时就是存储的是最短的一个长度
void floyd(){
    //三重循环，
    //就是一个状态转移的过程
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
            }
        }
    }
}
int main(){
    cin>>n>>m>>q;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(i==j) d[i][j]=0;
            else d[i][j]=INF;
        }
    }
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        //接下来m行,每行包含三个整数x,y,z,表示存在一条从点x到点y的有向边
        //边长为 z。
        //不能去直接去进行a->b直接去进行赋值
        d[a][b]=min(d[a][b],c);
    }
    floyd();
    //q次循环，找出最小值
    while(q--){
        int a,b;cin>>a>>b;
        //接下来 k行,每行包含两个整数x,y,表示询问点x到点y的最短距离。
        int dis=d[a][b];//全局中已经找到最短的路径了
        //但是floyd算法解决不了负环的问题，需要去进行判断
        if(dis>INF/2)  puts("impossible");
        else cout<<dis<<endl;
    }
    return 0;
}

习题我还在做，接着补充，但是俺觉得floyd算法不是那么难，因为好写也好理解，所以还是比较方便的。