hdu 6181 Two Paths

Problem

acm.hdu.edu.cn/showproblem.php?pid=6181

Reference

Dijkstra应用之次短路
2017 Multi-University Training Contest 10 1011 Two Paths HDU 6181 (次短路)
刷题—— hdu 6181 Two Paths
HDU6181-Two Paths【A*算法】

Meaning

给一幅 n 个点的无重边、无自环的无向图，求从 1 到 n 的次短路。

Analysis

求次短路，就另开一个数组存次短路的值，在求最短路时顺便更新次短路，有几种情况：

• A 的最短路更新 B 的最短路，那 B 原来的最短路变成新的次短路；
• A 的最短路不能更新 B 的最短路，但能更新 B 次短路，则更新它；
• A 的次短路更新 B 的次短路；

借这题记录几种求次短路的写法。

Code

Dijkstra

• 要注意优先队列的第三个参数，之前写成priority_queue<P>超时了，改成priority<P, vector<P>, greater<P> >才过的。它默认是less<P>？总之要注意小于号和这个greater / less共同产生的神奇效果

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <utility>
using namespace std;
const int N = 100000, M = N;

int head[N+1], to[M<<1], w[M<<1], nxt[M<<1];

void add_edge(int f, int t, int l, int sz)
{
    to[sz] = t;
    w[sz] = l;
    nxt[sz] = head[f];
    head[f] = sz;
}

long long one[N+1], two[N+1]; // 最短、次短
typedef pair<long long,int> P; // 距离、点的编号
priority_queue<P, vector<P>, greater<P> > que; // greater<P> !

void Dijkstra()
{
    memset(one, 7, sizeof one);
    memset(two, 7, sizeof two);
    one[1] = 0;
    que.push(P(0LL, 1));
    for(P tp; !que.empty(); que.pop())
    {
        tp = que.top();
        if(tp.first > two[tp.second])
            continue;
        long long d = tp.first;
        int v = tp.second;
        for(int i = head[v]; ~i; i = nxt[i])
        {
            tp.first = d + w[i];
            // 更新最短路
            if(one[to[i]] > tp.first)
            {
                tp.second = to[i];
                que.push(tp);
                // 把原来的最短路长度换出来
                // 在下面用来更新次短路
                swap(one[to[i]], tp.first);
            }
            // 更新次短路
            if(one[to[i]] < tp.first && tp.first < two[to[i]])
            {
                two[to[i]] = tp.first;
                tp.second = to[i];
                que.push(tp);
            }
        }
    }
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int n, m;
        scanf("%d%d", &n, &m);
        memset(head, 0xff, sizeof head);
        for(int i = 0, f, t, l, sz = 0; i < m; ++i)
        {
            scanf("%d%d%d", &f, &t, &l);
            add_edge(f, t, l, sz++);
            add_edge(t, f, l, sz++);
        }
        Dijkstra();
        printf("%I64d\n", two[n]);
    }
    return 0;
}

SPFA

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int N = 100000, M = N;

int head[N+1], to[M<<1], w[M<<1], nxt[M<<1];

void add_edge(int f, int t, int l, int sz)
{
    to[sz] = t;
    w[sz] = l;
    nxt[sz] = head[f];
    head[f] = sz;
}

long long one[N+1], two[N+1]; // 最短、次短
bool inq[N+1];
queue<int> que;

void SPFA()
{
    memset(one, 7, sizeof one);
    memset(two, 7, sizeof two);
    one[1] = 0;
    memset(inq, false, sizeof inq);
    que.push(1);
    inq[1] = true;
    for(int tp; !que.empty(); que.pop())
    {
        tp = que.front();
        bool psh = inq[tp] = false;
        for(int i = head[tp]; ~i; i = nxt[i])
        {
            long long d = one[tp] + w[i];
            // 能更新最短路
            if(one[to[i]] > d)
            {
                two[to[i]] = one[to[i]];
                one[to[i]] = d;
                psh = true;
            }
            // 不能更新最短路
            // 但能更新次短路
            else if(one[to[i]] < d && d < two[to[i]])
            {
                two[to[i]] = d;
                psh = true;
            }
            // 用次短路更新次短路
            // 不能少写这种情况
            if(two[to[i]] > two[tp] + w[i])
            {
                two[to[i]] = two[tp] + w[i];
                psh = true;
            }
            if(psh && !inq[to[i]])
            {
                inq[to[i]] = true;
                que.push(to[i]);
            }
        }
    }
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int n, m;
        scanf("%d%d", &n, &m);
        memset(head, -1, sizeof head);
        for(int i = 0, f, t, l, sz = 0; i < m; ++i)
        {
            scanf("%d%d%d", &f, &t, &l);
            add_edge(f, t, l, sz++);
            add_edge(t, f, l, sz++);
        }
        SPFA();
        printf("%I64d\n", two[n]);
    }
    return 0;
}

A*

• A* 可以用来求 k 短路，相当于第 k 次走到终点。
• A* 首先从终点反向求一次所有点离终点的最短距离，作为估价函数。如果记s(i)：起点到 i 的最短距离、d(i)：点 i 到终点的最短距离，那么f(i) = s(i) + d(i)就是从点 i 走到终点的总距离。
• 然后，从起点出发，把它周围的点都丢进一个堆（优先队列）里，每次都优先取出f(i)值最小的点，又对取出的点重复上面的操作。如果取出来的点是终点，就是到达终点。第 k 次取出终点就是走 k 短路到达终点。

#include <cstdio>
#include <cstring>
#include <queue>
#include <utility>
using namespace std;
const int N = 100000, M = N;

int head[N+1], to[M<<1], w[M<<1], nxt[M<<1];

void add_edge(int f, int t, int l, int sz)
{
    to[sz] = t;
    w[sz] = l;
    nxt[sz] = head[f];
    head[f] = sz;
}

long long h[N+1]; // 估价函数的值，即 i 到终点的最短路
typedef pair<long long,int> P;
priority_queue<P, vector<P>, greater<P> > que; // greater<P> !

void Dijkstra(int n)
{
    memset(h, 7, sizeof h);
    h[n] = 0;
    que.push(P(0LL, n));
    for(P tp; !que.empty(); que.pop())
    {
        tp = que.top();
        if(h[tp.second] < tp.first)
            continue;
        for(int i = head[tp.second]; ~i; i = nxt[i])
            if(h[to[i]] > tp.first + w[i])
            {
                h[to[i]] = tp.first + w[i];
                que.push(P(h[to[i]], to[i]));
            }
    }
}

long long A_star(int n, int k)
{
    // 反向求最短路
    // 当估价函数
    Dijkstra(n);
    que.push(P(h[1], 1));
    long long res = -1;
    for(P tp; !que.empty(); /* que.pop() */)
    {
        tp = que.top();
        que.pop(); // 这句不能写在 for 的步长那里
        if(tp.second == n)
        {
            if(k > 1) // 未足 k 次
                --k;
            else  // 第 k 次取出
            {
                res = tp.first;
                break;
            }
        }
        // 先把当前结点的估价减掉
        // 得到起点到当前结点的最短路
        // 在周围的结点进堆时，再加回那个结点自己的估价
        tp.first -= h[tp.second];
        for(int i = head[tp.second]; ~i; i = nxt[i])
            que.push(P(tp.first + w[i] + h[to[i]], to[i]));
    }
    while(!que.empty())
        que.pop();
    return res;
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int n, m;
        scanf("%d%d", &n, &m);
        memset(head, -1, sizeof head);
        for(int i = 0, f, t, l, sz = 0; i < m; ++i)
        {
            scanf("%d%d%d", &f, &t, &l);
            add_edge(f, t, l, sz++);
            add_edge(t, f, l, sz++);
        }
        printf("%I64d\n", A_star(n, 2));
    }
    return 0;
}