迷宫花坛

Description

圣玛格丽特学园的一角有一个巨大、如迷宫般的花坛。大约有一个人这么高的大型花坛，做成迷宫的形状，深受中世纪贵族的喜爱。维多利加的小屋就坐落在这迷宫花坛的深处。某一天早晨，久城同学要穿过这巨大的迷宫花坛，去探望感冒的维多利加。
整个迷宫可以用 $N$ 个路口与 $M$ 条连接两个不同路口的无向通道来描述。路口被标号为 $1$ 到 $N$ ，每条通道有各自的长度。整个迷宫一定是连通的，迷宫中可能存在若干个环路，但是，出于美观考虑，每个路口最多只会属于一个简单环路。
你需要回答多个这样的询问：假如久城处在路口 $x$ ，维多利加的小屋处在路口 $y$ ，久城最
短需要走多少距离才能到达小屋？

Input

第一行 $2$ 个整数 $N,M$ ，表示迷宫花坛的路口数和通道数；
接下来 $M$ 行，每行 $3$ 个整数 $x,y,z$ ，描述一条连接路口 $x$ 与路口 $y$ ，长度为 $z$ 的通道；
再接下来 $1$ 行包含一个整数 $Q$，表示询问数量；
之后 $Q$ 行，每行 $2$ 个整数 $x,y$ ，描述一个询问。

Output

对于每个询问输出一行一个整数，表示最短距离。

Sample input

4 4
1 2 1
2 3 2
1 3 2
3 4 1
2
2 4
1 3

Sample Output

3
2

数据范围

对于 $30\%$ 的数据，$N≤100$；
另有 $30\%$ 的数据，保证 $N=M$ ；
对于 $100\%$ 的数据，$1≤N≤100000,Q≤2000001≤x,y≤N，1≤z≤1000$

Solution

这是一道仙人掌最短路裸题，代码解释一切。

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

#define N 100001
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define drp(i, a, b) for (int i = a; i >= b; i--)
#define fech(i, x) for (int i = 0; i < x.size(); i++)

inline int read() {
    int x = 0, flag = 1; char ch = getchar(); while(!isdigit(ch)) { if(!(ch ^ '-')) flag = -1; ch = getchar(); }
    while(isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = getchar(); return x * flag;
}
inline void write(int x) {
    if(!x) { putchar(' '); return; } if(x < 0) putchar('-'), x = -x;
    char buf[30] = "", top = 0; while(x) buf[++top] = x % 10 + '0', x /= 10; while(top) putchar(buf[top--]);
}

int n, m;
struct edgeType { int to, dis; }eg[1000001]; int tot;
vector<int> g[N];
int dis[N];
deque<int> q; bool inQue[N];
int dfn[N], ind, dfnDis[N], from[N], fromLen[N], come[N];
bool tag[1000001]; int cnt, Size[N], belong[N];
int fa[N][18], dep[N];

inline void addEdge(int u, int v, int w) {
    eg[tot].to = v, eg[tot].dis = w; tot++;
    eg[tot].to = u, eg[tot].dis = w; tot++;
    g[u].push_back(tot - 2); g[v].push_back(tot - 1);
}

inline void spfa() {
    memset(dis, 0x3f3f3f3f, sizeof dis); dis[1] = 0; q.push_back(1); inQue[1] = 1;
    while (!q.empty()) {
        int u = q.front(), v, w; q.pop_front(); inQue[u] = 0;
        fech(i, g[u]) {
            int v = eg[g[u][i]].to, w = eg[g[u][i]].dis;
            if (dis[v] > dis[u] + w) {
                dis[v] = dis[u] + w;
                if (!inQue[v]) {
                    if (!q.empty() && dis[v] > dis[q.front()]) q.push_back(v);
                    else q.push_front(v);
                }
            }
        }
    }
}

inline void getCir(int u, int targ) {
    if (!(u ^ targ)) return;
    belong[u] = cnt, Size[cnt] += fromLen[u];
    addEdge(u, targ, 0), tag[from[u]] = tag[from[u] ^ 1] = 1;
    getCir(come[u], targ);
}

inline void dfs(int u, int f) {
    dfn[u] = ++ind; int v, w;
    fech(i, g[u]) {
        edgeType e = eg[g[u][i]]; if (!(e.to ^ f) || g[u][i] >= (m << 1)) continue;
        if (!dfn[e.to])
            dfnDis[e.to] = dfnDis[u] + e.dis,
            from[e.to] = g[u][i], come[e.to] = u, fromLen[e.to] = e.dis,
            dfs(e.to, u);
        else if (dfn[e.to] < dfn[u])
            tag[g[u][i]] = tag[g[u][i] ^ 1] = 1,
            Size[++cnt] = e.dis, getCir(u, e.to);
    }
}

inline void dfs2(int u, int f) {
    dep[u] = dep[f] + 1; fa[u][0] = f;
    rep(i, 1, 17) { if (!fa[u][i - 1]) break; fa[u][i] = fa[fa[u][i - 1]][i - 1]; }
    fech(i, g[u]) {
        edgeType e = eg[g[u][i]]; if (!(e.to ^ f) || tag[g[u][i]] || dep[e.to]) continue;
        dfs2(e.to, u);
    }
}

inline int query(int u, int v) {
    if (dep[u] < dep[v]) swap(u, v); int a = u, b = v;
    drp(i, 17, 0) if (dep[fa[u][i]] >= dep[v]) u = fa[u][i]; if (u == v) return dis[a] - dis[b];
    drp(i, 17, 0) if (fa[u][i] ^ fa[v][i]) u = fa[u][i], v = fa[v][i]; int t = fa[u][0];
    if (belong[u] && !(belong[u] ^ belong[v])) {
        int r = abs(dfnDis[u] - dfnDis[v]);
        return dis[a] - dis[u] + dis[b] - dis[v] + min(r, Size[belong[u]] - r);
    }
    return dis[a] + dis[b] - (dis[t] << 1);
}

int main() {
    n = read(); m = read();
    rep(i, 1, m) { int u = read(), v = read(); addEdge(u, v, read()); }
    spfa(); dfs(1, 0); dfs2(1, 0);
    int que = read(); while (que--) {
        int u = read(), v = read();
        if(u == v) { puts("0"); continue; }
        write(query(u, v)), puts("");
    }
    return 0;
}