整理《挑战程序设计竞赛》中最短路的代码

一.Bellman-Ford
核心公式：
d[i]=min(d[j]+e.cost,d[i])
释：
d[i]:i节点到源点的当前最短距离
e.cost:相邻两节点的距离（公式中的为j节点指向i节点的距离）
原因：
(图片来自百度百科)
这里假设B1为i节点，则A123可以为j节点。d[j]为确定的 j到源点最短距离。此时肯定是比较A123的距离加上i，j的距离之和的最短距离。这个最短距离就是最终确定的d[i]。
代码流程：
遍历所有边，当发现边的出发点被更新过时，对边进行松弛操作，更新边的终点。直至某次遍历所有边时没有可以更新边的情况。
松弛操作：d[e.to]>d[e.from]+e.cost;
样例代码：

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<algorithm>
#include<map>
#include<vector>
#include<cmath>
using namespace std;
#define N 1000+5
#define MAXN 1000000
#define mem(arr,a) memset(arr,a,sizeof(arr))
#define INF 0x3f3f3f3f
#define LL long long int 
#define pow(a) (a)*(a)
int d[N];       
int cost[N][N];
int vis[N];
int e, v;
struct edge{ int from; int to; int cost; };
edge es[N];
void dijkstra(){
    mem(vis, 0);
    mem(d, INF);
    d[1] = 0;
    while (1){
        int flag = -1;
        for (int i = 1; i <= e; i++){
            edge etemp = es[i];
            if (d[etemp.from] != INF&&d[etemp.to] > d[etemp.from] + etemp.cost){
                d[etemp.to] = d[etemp.from] + etemp.cost;
                flag = 0;
            }
        }
        if (flag)break;

    }
    cout << d[v] << endl;
}
int main(){
    cin >> e >> v;
    mem(cost, INF);
    for (int i = 1; i <= v; i++){
        int a, b, c; cin >> a >> b >> c;
        es[i].from = a, es[i].to = b, es[i].cost = c;
    }
    dijkstra();
}

注意，这个算法没办法处理从源点可达负圈的图。当图中有负圈时，每次遍历都会进行松弛操作，也就是程序进入了死循环。
复杂度:O(VE)
松弛操作的循环需要E次，while的循环需要进行V-1次。因为每进行一次while循环，至少确定一个点的最短距离d[i]。V-1次确定了除源点外所有点的最短距离。
判断是否存在负圈：
对while循环进行计数，当循环第V次时可退出程序，并声明图中存在负圈。

---

二：dijkstra算法
dijkstra算法是对Bellman-Ford算法的优化。在Bellman-Ford算法中，d[j]若不是最短距离 ，那么得到的d[i]也不会是最短距离，从d[i]出发进行的松弛操作也是多余的。因此dijkstra对其进行改进。
1.以最短距离d[i]“刚刚”确定的i点出发进行松弛更新
2.不再以之前最短距离确定的点进行松弛。
下面从代码中解释这两点。

#define N 2000+5
#define MAXN 1000000
#define mem(arr,a) memset(arr,a,sizeof(arr))
#define INF 0x3f3f3f3f
#define LL long long int 
int d[N];
int vis[N];
int cost[N][N];
int T, n;
int dijkstra(){
    int v = -1;
    mem(d, INF);
    mem(vis, 0);
    d[1] = 0;
    while (1){
        v = -1;
        for (int i = 1; i <= n; i++){
            if (!vis[i] && (v == -1 || (d[i] < d[v])))v = i;
        }
        if (v == -1)break;
        vis[v] = 1;
        for (int i = 1; i <= n; i++){
            d[i] = min(d[i], d[v] + cost[v][i]);//松弛操作
        }
    }
    return d[n];
}

这里vis数组是记录最短距离已经确定的点。进行一次while循环，在松弛操作的循环中，是以刚刚确定最短距离的点为出发点进行松弛。在每次确定这样的点后都会用vis数组进行记录，在以后挑选新的点时就不会用到已经记录的点。

给我的感觉是，所有的点分为三部分，一部分是确定最短距离的点，一部分是用刚刚确定最短路的点松弛过的点，一部分是未访问点。在松弛过得点中挑出最短距离的点，则这个点变为已经确定最短距离的点，归到第一部分并进行松弛。被松弛到的点从第三部分变为第二部分。直到所有点被归为第一部分。

复杂度：O(V^2)这种写法其实跟Bellman-Ford差不多，松弛V次，while循环V

注意事项：算法不适用于存在负边的图。当图中存在负边时，在进行松弛操作时会造成结果的错误。比如对某条负边的起点a进行松弛后，假设该负边的终点为b，再次进行while循环时以b为起点进行松弛，会更新a的最短距离值，违背了原本算法在进行确定最短距离后就不会改变的初衷。存在负边时算符不适用。

优化的dijkstra，复杂度O(ElogV)

struct edge{ int to, cost; };
typedef pair<int, int> P;
int V;
vector<edge>G[N];
int d[N];
void dijkstra(int s){
    priority_queue<P, vector<P>, greater<P> >que;
    fill(d, d + V, INF);
    d[s] = 0;
    que.push(P(0, s));
    while (!que.empty()){
        P p = que.top();
        que.pop();
        int v = p.second;
        if (d[v] < p.first)continue;
        for (int i = 0; i < G[v].size(); i++){
            edge e = G[v][i];
            if (d[e.to]>d[v] + e.cost){
                d[e.to] = d[v] + e.cost;
                que.push(P(d[e.to], e.to));
            }
        }
    }
}

代码采用了优先队列的数据结构，队列中的元素为图中的点，用堆维护最短距离，操作复杂度为O(logV)。而松弛操作的所需的次数为E,所以总体复杂度为O(ElogV).

三，Floyd-Warshall
dp思想，复杂度O(v^3),没有需要说明的。