求最短路的三种方法：dijkstra，spfa，floyd

dijkstra是一种单源最短路算法。在没有负权值的图上，vi..vj..vk是vi到vk最短路的话，一定要走vi到vj的最短路。所以每次取出到起点距离最小的点，从该点出发更新邻接的点的距离，如果更新成功则把新点加入priority_queue。储存图使用的是邻接表。代码如下：

#include <bits/stdc++.h>//有向图
using namespace std;
//dijkstra 不适用于带负权的图
const int maxn = , maxm = , INF = 0x3f3f3f;// maxn比顶点数略大，maxm比边数略大
int head[maxn], vis[maxn], dis[maxn], fa[maxn];
int next[maxm], u[maxm], v[maxm], w[maxm];
typedef pair<int, int> pi;// pair排序策略是优先排前面，pair把距离放前面，点放后面
int n, m;
void ini()
{
    memset(vis, , sizeof(vis));//开始所有点都没被处理
    memset(head, -, sizeof(head));//所有点都没有边
    for(int i = ; i <= n; i++)
        dis[i] = INF;//起点到所有点距离为无穷大
}

void dij(int s, int e)
{
    priority_queue<pi, vector<int>, greater<int> > Q;//优先队列
    dis[s] = ;
    Q.push(make_pair(dis[s], s));
    while(!Q.empty())
    {
        pi u = Q.top();
        Q.pop();//取出d最小的点
        int x = u.second;
        if(x == e)
            break;
        if(vis[x])//处理过，跳过
            continue;
        vis[x] = ;
        for(int i = head[x]; ~i; i = next[i])//更新从当前d最小的点相邻点的距离
        {
            if(dis[v[i]] > dis[x] + w[i])
            {
                dis[v[i]] = dis[x] + w[i];//松弛成功
                fa[v[i]] = x;
                Q.push(make_pair(dis[v[i]], v[i]));//把更新成功的点加入队列
            }
        }
    }
    if(dis[e] == INF)
        return;//s到e无路径
    vector<int> ans;//用vector从终点往起点找路径，也可以用递归
    int temp = e;
    while(temp!=s)
    {
        ans.push_back(temp);
        temp = fa[temp];
    }
    ans.push_back(s);
    for(int i = ans.size()-; i >= ; i--)
        printf("%d ", ans[i]);
    printf("\n%d\n", dis[e]);
}

int main()
{
    //freopen("in.txt", "r", stdin);
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &m);
        ini();
        for(int i = ; i < m; i++)
        {
            scanf("%d%d%d", u+i, v+i, w+i);
            next[i] = head[u[i]];
            head[u[i]] = i;//建立邻接表
        }
        int S, E;//起点终点
        scanf("%d%d", &S, &E);
        dij(S, E);
    }
    return ;
}

dijkstra经典的一比，不过要求不能含负权，于是又学了下能处理带负权图的spfa：

spfa感觉有点像bfs，但bfs只处理一个节点一次，而spfa如果松弛了路径上经过的节点，就要对路径上之后的点都更新一遍。有负环的话，每走一遍负环，距离就减小环长，也就不存在最短路，所以假定不存在负环（或者判断一下有无负环）。代码如下：

#include <bits/stdc++.h>//有向图
using namespace std;
const int maxn = , maxm = , INF = 0x3f3f3f3f;
int head[maxn], in[maxn], dis[maxn], fa[maxn];//in标记在queue中的点
int u[maxm], v[maxm], w[maxm], next[maxm];
int n, m;

void ini()
{
    memset(in, , sizeof(in));
    memset(head, -, sizeof(head));
    for(int i = ; i <= n; i++)
        dis[i] = INF;
}

void print(int s, int e)//递归打印路径
{
    if(e!=s)
        print(s, fa[e]);
    printf("%d ", e);
}

void spfa(int s, int e)//有点像bfs，不过bfs不会处理之前处理过的点
{
    queue<int> Q;
    dis[s] = ;
    in[s] = ;
    Q.push(s);
    while(!Q.empty())
    {
        int x = Q.front();
        Q.pop();
        in[x] = ;
        for(int i = head[x]; ~i; i = next[i])
        {
            if(dis[v[i]] > dis[x] + w[i])
            {
                dis[v[i]] = dis[x] + w[i];
                fa[v[i]] = x;
                if(!in[v[i]])
                   {
                       Q.push(v[i]);
                       in[v[i]] = ;
                   }
            }
        }
    }
    print(s, e);
    printf("\n%d\n", dis[e]);
}
int main()
{
    freopen("in.txt", "r", stdin);
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &m);
        ini();
        for(int i = ; i < m; i++)
        {
            scanf("%d%d%d", u+i, v+i, w+i);
            next[i] = head[u[i]];
            head[u[i]] = i;
        }
        int s, e;
        scanf("%d%d", &s, &e);
        spfa(s, e);
    }
    return ;
}

多源最短路径有个floyd算法，其实就是离散讲的warshall闭包：（但是因为时间复杂度O（n^3）有点嫌弃2333），没自己实现一下，核心代码如下：

    for(int k = ; k <= n; k++)
        for(int i = ; i <= n; i++)
            for(int j = ; j <= n; j++)
                if(g[i][j] > g[i][k] + g[k][j])
                    g[i][j] = g[i][k] + g[k][j];

思路是开始用邻接矩阵存放图，更新两点距离只能靠经过其他点中转，所以每次多允许经过一个点（即第一个循环），考虑最短路（第二三重循环）。

floyd好处是代码短，能一次求出所有节点之间的最短路。

今天收获挺大，总结一下稠密/无负权图用dijkstra，稀疏/有负权图用spfa，时间要求不高用floyd。

（心情依然很烂）