[hdu 6181 Two Paths] Dijkstra求次短路

[hdu 6181 Two Paths] Dijkstra求次短路

分类：Graph Dijkstra

1. 题目链接

[hdu 6181 Two Paths]

2. 题意描述

给定一个$N$个顶点$M$条边的无向图。求图中从点$1$到点$N$的次短路。（次短路上一条边允许经过多次）。

3. 解题思路

首先，以点$1$、点$N$为源点分别跑一次最短路。设点$1$到点$u$的最短路为$d1[u]$,点$N$到点$u$的最短路为$dn[u]$。
然后，次短路的取值，分以下情况进行讨论：

1. 当图中从$1$到$N$有两条以上最短路径的时候，那么最短路与次短路相等；
2. 当图中从$1$到$N$有两条以上最短路径的时候，次短路又有以下两种情况：
   
   • 最短路+最短路路径上边长最小的边的边长两倍。
   • 经过一条非最短路路径上的边，假设为$(u→v)$，此时次短路长度=$len(1,u)+len(u,v)+len(v, n)$=$d1[u]+len(u,v)+dn[v]$。

可以dfs求出最短路径的条数、最短路径上最小边长，并标记在最短路径上的边；
然后，枚举所有不在最短路径上的边，求出$d1[u]+len(u,v)+dn[v]$并更新答案即可。

4. 实现代码

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
typedef long double LB;
typedef unsigned int uint;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<int, LL> PIL;
typedef pair<LL, LL> PLL;
typedef pair<LB, LB> PLB;
typedef vector<int> VI;

const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
const long double PI = acos(-1.0);
const long double eps = 1e-4;
void debug() { cout << endl; }
template<typename T, typename ...R> void debug (T f, R ...r) { cout << "[" << f << "]"; debug (r...); }
template<typename T> inline void umax(T &a, T b) { a = max(a, b); }
template<typename T> inline void umin(T &a, T b) { a = min(a, b); }
template <typename T> inline bool scan_d (T &ret) {
    char c; int sgn;
    if (c = getchar(), c == EOF) return 0; //EOF
    while (c != '-' && (c < '0' || c > '9') ) if((c = getchar()) == EOF) return 0;
    sgn = (c == '-') ? -1 : 1;
    ret = (c == '-') ? 0 : (c - '0');
    while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
    ret *= sgn;
    return 1;
}
template<typename T> void print(T x) {
    static char s[33], *s1; s1 = s;
    if (!x) *s1++ = '0';
    if (x < 0) putchar('-'), x = -x;
    while(x) *s1++ = (x % 10 + '0'), x /= 10;
    while(s1-- != s) putchar(*s1);
}
template<typename T> void println(T x) { print(x); putchar('\n'); }
template<typename T> T randIntv(T a, T b) { return rand() % (b - a + 1) + a; } /*[a, b]*/

const int MAXN = 100005;
const int MAXE = 100005;

int T, n, m;
template<class T>
struct Dijkstra {
    struct Edge {
        T w;
        int v, next;
    } edge[MAXE << 1];
    typedef pair<T, int> QNode;
    int head[MAXN], tot;
    T d1[MAXN], dn[MAXN], INF;
    void init() {
        tot = 0;
        memset(head, -1, sizeof(head));
    }
    void add(int u, int v, T w) {
        edge[tot].v = v;
        edge[tot].w = w;
        edge[tot].next = head[u];
        head[u] = tot++;
    }
    void run(LL d[], int u) {
        priority_queue<QNode, vector<QNode>, greater<QNode> >q;
        memset(d, 0x3f, sizeof(T) * (n + 1)); INF = d[0];
        q.push(QNode(0, u)); d[u] = 0;
        while(!q.empty()) {
            QNode ftp = q.top(); q.pop();
            int u = ftp.second;
            if(ftp.first > d[u]) continue;
            for(int i = head[u]; ~i; i = edge[i].next) {
                int v = edge[i].v; T w = edge[i].w;
                if(d[u] + w < d[v]) {
                    d[v] = d[u] + w;
                    q.push(QNode(d[v], v));
                }
            }
        }
    }

    bool flag[MAXE << 1];
    bool judge(int u, T & minw) {
        int v, cnt = 0; bool ret = false;
        for(int i = head[u]; ~i; i = edge[i].next) {
            v = edge[i].v;
            if(d1[u] + edge[i].w + dn[v] == d1[n]) {
                umin(minw, edge[i].w);
                ret |= judge(v, minw);
                cnt += (d1[v] + dn[v] == d1[n]);
                flag[i] = true;
            }
        }
        return ret | cnt >= 2;
    }
    bool vis[MAXN];
    void dfs(int u, T& ans) {
        if(vis[u]) return;
        vis[u] = true;
        int v;
        for(int i = head[u]; ~i; i = edge[i].next) {
            if(flag[i]) continue;
            v = edge[i].v;
            umin(ans, d1[u] + edge[i].w + dn[v]);
            dfs(v, ans);
        }
    }
};
Dijkstra<LL> dij;

int main() {
#ifdef ___LOCAL_WONZY___
    freopen ("input.txt", "r", stdin);
#endif // ___LOCAL_WONZY___
    int u, v; LL w;
    scan_d(T);
    while(T --) {
        scan_d(n), scan_d(m);
        dij.init();
        for(int i = 1; i <= m; ++i) {
            scan_d(u), scan_d(v), scan_d(w);
            dij.add(u, v, w);
            dij.add(v, u, w);
        }
        dij.run(dij.d1, 1);
        dij.run(dij.dn, n);
        LL ans = INFL, minw = INFL;
        memset(dij.flag, false, sizeof(dij.flag));
        bool two = dij.judge(1, minw);
        if(two) {
            ans =  dij.d1[n];
        } else {
            ans = dij.d1[n] + 2 * minw;
            memset(dij.vis, false, sizeof(dij.vis));
            dij.dfs(1, ans);
        }
        println(ans);
    }
#ifdef ___LOCAL_WONZY___
    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif // ___LOCAL_WONZY___
    return 0;
}