算法训练 - 最短路

最近在学习一些常见的算法，算法这东西不练是不行的，所以学习的同时也找了些题来练。我找的题目来源于 Vjudge 上的 kuangbin带你飞专题训练。每做完一个专题，我都会写一篇博客整理一下这个专题。现在这个专题是，图论中的最短路。
最短路相关的算法有很多，在专题训练中会用到的有 Dijkstra 算法（包括优先队列优化版本） 、Bellman-Ford 算法（包括其队列优化版本 SPFA 算法）、Floyd-Warshall 算法。以下就将主要介绍这几个算法，并提供代码模板。

---

---

Dijkstra 算法

Dijkstra 算法是很多数据结构和算法教材上都介绍过的一种最短路算法，它的思想主要是一个贪心的思想，即每一次选择距离源节点最近的节点作为拓展节点，最多经过 V（节点数）次选择，就可以确定从源节点到所有节点的最短路径。
下面是普通的 Dijkstra 算法和经过优先队列优化后的 Dijkstra 算法的代码：

普通版

int V, d[MAXV];

void dijkstra(int s)
{
    fill(d, d+V, INF);              // d[i] 表示 s 到 i 的最短路
    fill(used, used+V, false);      // used数组标记指定节点是否拓展过
    d[s] = 0;

    for (int t = 0;t < N;t++)
    {
        int v = -1, m = INF;
        // 寻找一个拓展节点
        for (int u = 0;u < V;u++)
            if (!used[u] && d[u] < m)
            {
                m = d[u];
                v = u;
            }
        if (v == -1)
            break;
        used[v] = true;

        // 从拓展节点开始向与其相邻的节点松弛
        for (int u = 0;u < V;u++)
            if (!used[u])
                d[u] = min(d[u], d[v]+cost[v][u]);
    }
}

优先队列版

struct node{
    int c, v;
    node(int c = 0, int v = 0) : c(c), v(v) {}
    bool operator < (const node &p) const
    {
        return v > p.v;
    }
};

struct edge{
    int to, cost;
    edge(int to = 0, int cost = 0) : to(to), cost(cost) {}
}am[maxv];
int V, d[maxv];

void pq_dijkstra(int s)
{
    fill(used, used+V, false);
    fill(d, d+V, INF);

    priority_queue<node> que;
    que.push(node(s, 0));
    d[s] = 0;

    while (!que.empty())
    {
        node cur = que.top();
        que.pop();
        int v = cur.c;

        if (used[v])
            continue;
        used[v] = true;
        for (int i = 0;i < am[v].size();i++)
        {
            int u = am[v][i].to;
            int c = am[v][i].cost;

            if (d[u] > d[v] + c)
            {
                d[u] = d[v] + c;
                que.push(node(u, d[u]));
            }
        }
    }
}

Bellman_Ford 算法

Bellman-Ford 算法基于以下递推公式：
d[i]=min(d[j]+cos