算法训练 - 最短路

最近在学习一些常见的算法，算法这东西不练是不行的，所以学习的同时也找了些题来练。我找的题目来源于 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 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]+cost[j][i])
Bellman-Ford 算法可以处理带有负边的情况，条件是到某个节点的最短路径在第 N 次循环中仍然被更新。

普通版

struct edge{
    int from, to, cost;
}es[maxe];

int V, E;
int d[MAXV];

void bellman-ford()
{
    fill (d, d+N, INF);
    d[s] = 0;

    for (int i = 0;i < V;i++)
    {
        bool update = false;
        for (int j = 0;j < E;j++)
        {
            int v = es[j].from;
            int u = es[j].to;

            if (d[v] < INF && d[u] > d[v] + es[j].cost)
            {
                d[u] = d[v] + es[j].cost;
                update = true;
            }
        }

        if (!update)
            break;
    }
}

判负环

// 使用的数据结构和上面的代码相同
// 如果返回值为 true 则说明存在负环
bool find_negative_loop()
{
    memset(d, 0, V*sizeof(int));

    for (int i = 1;i <= V;i++)
    {
        for (int j = 0;j < E;j++)
        {
            int v = es[j].from;
            int u = es[j].to;

            if (d[v] < INF && d[u] > d[v] + es[j].cost)
            {
                d[u] = d[v] + es[j].cost;

                if (i == V)
                    return true;
            }
        }
    }
    return false;
} 

SPFA 算法

Bellman-Ford 算法有一个明显的缺陷是对于一个 d[i]，即便 d[i] 并不是到达 i 节点的最短路径长度，与 i 相连的部分节点 j 还是会被松弛，这样经过松弛之后的 d[j] 也不是最短路，所以 Bellman-Ford 算法可以在这个方面被优化。SPFA 算法就是一个被广泛使用的 Bellman-ford 算法队列优化版本，SPFA 算法也具备判断负环是否存在的能力，判断条件是如果某个节点入队次数超过 V 次，那么它一定在某一个负环上。

struct edge{
    int u, v, p;
    int next;
}am[maxe];
int ei, head[maxn];

void init()
{
    ei = 0;
    memset(head, -1, sizeof(int)*V);
}

void add(int u, int v, int p)
{
    am[ei].u = u;
    am[ei].v = v;
    am[ei].p = p;
    am[ei].next = head[u];
    head[u] = ei;
    ei += 1;
}
// 以上数据结构邻接表，SPFA 算法中大多使用邻接表

int V, E;
int d[maxv], cnt[maxv];
bool used[maxv];

void spfa(int s)
{
    memset(cnt, 0 , sizeof(int)*V);
    memset(used, false, sizeof(int)*V);

    d[s] = 0;
    cnt[s] = 1;
    used[s] = true;

    queue<int> que;
    que.push(s);
    while (!que.empty())
    {
        int cur = que.front();
        que.pop();
        used[s] = false;

        for (int i = head[cur], i != -1;i++)
        {
            int to = am[i].v;
            int co = am[i].p;

            if (d[to] > d[cur] + p)
            {
                d[to] = d[cur] + p;

                // 如果 cnt[to] > V, 则说明 to 节点在某个负环上
                if (!used[to] && used[to] <= V)
                {
                    used[to] = true;
                    que.push(to);
                    cnt[to] += 1;
                }
            }
        }
    }
}

以上是 SPFA 算法的队列版本，还有相应的栈版本，有的情况下用栈会更快。此外，SPFA 算法还有 DFS 形式。判断负环的时候，用 SPFA 的 DFS 形式判负环的平均时间复杂度相比于 BFS 形式更低一些。

Floyd-Warshall 算法

Floyd-Warshall 算法是用来求任意两点之间的最短路径的，它将动态规划思想应用于求最短路的一个算法。
设 d[k][i][j] 表示从 i 点 经过 k 点 到 j 点的最短路径长度，那么它可以分成两种情况：
1、不经过点 k 的路径到达 j 点;
2、经过点 k 一次的路径到达 j 点（如果不存在负环的话，对于任意点 k ，从 i 到 j 的最短路径最多只经过 k 一次）
因此就可以得到以下递推公式：
d[k][i][j]=min(d[k−1][i][j],d[k−1][i][k]+d[k−1][k][j])
值得注意的是，对于 d[k][i][j] 而言，k 的范围是 0~k，然而经过上述归约之后，范围变到了 0~k-1。
可以看到经过点 k 的最短路只和经过 k-1 的最短路相关，因此可以将以上递推公式降为二维的形式：
d[i][j]=min(d[i][j],d[i][k]+d[k][j])
Floyd-Warshall 算法同样可以用来判负环，条件是如果 d[i][i] < 0, 那么点 i 一定位于某个负环上。

// Floyd-Warshall 算法
int V, d[MAXV][MAXV];   // d[u][v] 表示 u 到 v 之间的路径

void floyd_warshall()
{
    for (int k = 1;k < V;k++)
        for (int i = 0;i < V;i++)
            for (int j = 0;j < V;j++)
                d[i][j] = min(d[i][j], d[i][k]+d[k][j]);
}

差分约束

最短路中有一类重要的题目形式就是差分约束题，差分约束系统将求解一个不等式组中两个变量的最大值问题变为最短路问题，不得不说我个人觉得还是蛮神奇的…
对于具有 n 个变量 m 个不等式的不等式组，如果不等式组中每个不等式左右两边都只有一个变量，那么这种不等式方程组又叫做差分约束系统。对于这样的不等式组中的不等式，有以下两种情况：
1、 xi+C>=xj 对应一条从 i 节点到 j 节点的边权为 C 的路径
2、 xi+C<=xj 对应一条从 j 节点到 i 节点的边权为 -C 的路径
依照以上两条规则建图，求 xj−xi 的最大值就等价于求点 i 到 j 的最短路。

一些小技巧

另外，在某些最短路问题中，还发现一些小技巧。
比如说，求 s 到其余所有点的最短距离是用最短路算法跑一遍，求其余所有点到 s 的最短距离的话，就把对应的邻接矩阵转置之后，用最短路算法跑一遍。
在比如说，在 HDU-4725 题中，建图需要先拆点，把每个层都拆成两个点，一个进入点一个出来的点。这样的想法我觉得很妙，这样的拆点建图的方法，在另外一些题目中还有用到。