图论-次短路求法

测试题目 NKOJ1107 达喀尔拉力赛

方法一 Bellman-Ford. 计算 S 到任意点的最短路得到 dis[i], 计算任意点到 T 的最短路 sid[i], 枚举每一条边，假设这条边从 x 到 y, 权值 w.

显然次短路长度就是 min{ dis[x] + w + sid[y] } .这个方法代码非常好写，也很好想，不过跑了两次最短路，常数略大。

方法二 Dijkstra. dis 表示最短路, dis2 表示次短路, 见代码. 

void Dijkstra(int beg)
{
    LL i;
    for (i = 1; i <= n; ++i) dis[i] = dis2[i] = INF;
    dis[beg] = 0;//注意这里不能写 dis2[beg] = 0，想一想为什么（笑 
    while (!Q.empty()) Q.pop();
    Q.push(strdis(beg, dis[beg]));
    while (!Q.empty()) {
        strdis p = Q.top(); Q.pop();
        if (p.dis > dis2[p.v]) continue;////注意这里是 p.dis ，不能写 dis[p.v] ，因为当前取出的 p.dis 表示的也可能是 dis2[p.v] ，这与最短路写法中 p.dis 等价于 dis[p.v]  不同 
        for (i = 0; i < G[p.v].size(); ++i) {
            LL tmp = p.dis + G[p.v][i].w;//注意这里是 p.dis ，不能写 dis[p.v] ，因为当前取出的 p.dis 表示的也可能是 dis2[p.v] ，这与最短路写法中 p.dis 等价于 dis[p.v]  不同 
            if (dis[G[p.v][i].v] > tmp) {
                swap(dis[G[p.v][i].v], tmp);//注意这里最短路更新后，原来的值应该交换到 tmp 中，用于下面的 if 语句里更新次短路
                Q.push(strdis(G[p.v][i].v, dis[G[p.v][i].v]));
            }
            if (dis[G[p.v][i].v] < tmp && dis2[G[p.v][i].v] > tmp) { 
                dis2[G[p.v][i].v] = tmp;
                Q.push(strdis(G[p.v][i].v, dis2[G[p.v][i].v]));//注意 dis2 也应当 push 进队列，例子如下
                //例子：dis[5] = 100, dis2[5] = 200
                //有一条边 5 到 8 的边权值为 50
                //如果不把 dis2 入队，那么之后的算法中 dis[8] = 150, dis2[8] = INF
                //只有当队列里有 200 这个值，才能 200+50 得出 250，然后更新 dis2[8] = 250 
            }
        }
    }
    return ;
}

完整代码：

#include <stdio.h>
#include <vector>
#include <queue>

using namespace std;

typedef long long LL;

const int _N = 600;
const long long INF = 99999999999999LL;

LL n, m;
LL dis[_N], dis2[_N];

struct node {
    LL v, w;
    node(const LL &_v, const LL &_w):
        v(_v), w(_w) {}
};

struct strdis {
    LL v, dis;
    strdis(const LL &_v, const LL &_dis):
        v(_v), dis(_dis) {}
    bool operator < (const strdis &tmp) const
    {
        return this->dis > tmp.dis;
    }
};

vector<node> G[_N];
priority_queue<strdis> Q;

void Dijkstra(int beg)
{
    LL i;
    for (i = 1; i <= n; ++i) dis[i] = dis2[i] = INF;
    dis[beg] = 0;//注意这里不能写 dis2[beg] = 0，想一想为什么（笑 
    while (!Q.empty()) Q.pop();
    Q.push(strdis(beg, dis[beg]));
    while (!Q.empty()) {
        strdis p = Q.top(); Q.pop();
        if (p.dis > dis2[p.v]) continue;////注意这里是 p.dis ，不能写 dis[p.v] ，因为当前取出的 p.dis 表示的也可能是 dis2[p.v] ，这与最短路写法中 p.dis 等价于 dis[p.v]  不同 
        for (i = 0; i < G[p.v].size(); ++i) {
            LL tmp = p.dis + G[p.v][i].w;//注意这里是 p.dis ，不能写 dis[p.v] ，因为当前取出的 p.dis 表示的也可能是 dis2[p.v] ，这与最短路写法中 p.dis 等价于 dis[p.v]  不同 
            if (dis[G[p.v][i].v] > tmp) {
                swap(dis[G[p.v][i].v], tmp);//注意这里最短路更新后，原来的值应该交换到 tmp 中，用于下面的 if 语句里更新次短路
                Q.push(strdis(G[p.v][i].v, dis[G[p.v][i].v]));
            }
            if (dis[G[p.v][i].v] < tmp && dis2[G[p.v][i].v] > tmp) { 
                dis2[G[p.v][i].v] = tmp;
                Q.push(strdis(G[p.v][i].v, dis2[G[p.v][i].v]));//注意 dis2 也应当 push 进队列，例子如下
                //例子：dis[5] = 100, dis2[5] = 200
                //有一条边 5 到 8 的边权值为 50
                //如果不把 dis2 入队，那么之后的算法中 dis[8] = 150, dis2[8] = INF
                //只有当队列里有 200 这个值，才能 200+50 得出 250，然后更新 dis2[8] = 250 
            }
        }
    }
    return ;
}

int main()
{
    LL i, t1, t2, t3;
    scanf("%lld%lld", &n, &m);
    for (i = 1; i <= m; ++i) {
        scanf("%lld%lld%lld", &t1, &t2, &t3);
        G[t1].push_back(node(t2, t3));
        G[t2].push_back(node(t1, t3));
    }
    Dijkstra(1);
    printf("%lld
", dis2[n]);
    return 0;
}