cf 1051F 树+图

$des$
给定一张 $n$ 个点 $m$ 条边的带权无向联通图，$q$ 次询问，每次询问 $u_i$ 到 $v_i$ 的最短
路长度。
$n,q <= 10^5, m - n <= 20$

$sol$
首先随便搞一棵生成树，那么会有一些边不在生成树上。
把这些边的端点标记为特殊点。
对于一个询问，如果最短路只经过生成树上的边，就可以直接计算。
否则一定经过了一个特殊点，可以枚举这个特殊点，然后更新答案

$code$

#include <bits/stdc++.h>

using namespace std;

#define gc getchar()
inline int read() {
    int x = ; char c = gc;
    while(c < '' || c > '') c = gc;
    while(c >= '' && c <= '') x = x *  + c - '', c = gc;
    return x;

}

#define LL long long
#define Rep(i, a, b) for(int i = a; i <= b; i ++)

const int N = 1e5 + ;

int Now;
int cnt, head[N], cnt2, head2[N];
struct Node {
    int u, v, w, nxt;
    bool used;
} E[N], Gr[N << ], G[N << ];

int n, m;
int Nottree[], tot;

int fat[N];

int Get(int x) {
    return fat[x] == x ? x : fat[x] = Get(fat[x]);
}

void Link(int u, int v, int w) {
    G[++ cnt].v = v; G[cnt].w = w; G[cnt].nxt = head[u]; head[u] = cnt;
}

void Link_g(int u, int v, int w) {
    Gr[++ cnt2].v = v; Gr[cnt2].w = w; Gr[cnt2].nxt = head2[u]; head2[u] = cnt2;
}

void Kruskal() {
    int js = ;
    Rep(i, , m) {
        int u = E[i].u, v = E[i].v;
        int fau = Get(u), fav = Get(v);
        if(fau != fav) {
            fat[fau] = fav;
            js ++;
            Link(u, v, E[i].w);
            Link(v, u, E[i].w);
            E[i].used = ;
        }
        if(js == n - ) break;
    }
}

struct Short {
    LL u, dis_;
    bool operator < (const Short a) const {
        return this-> dis_ > a.dis_;
    }
};
LL dis[][N];
bool vis[N];
priority_queue <Short> Q;

void Dijkstra(int start) {
    Rep(i, , n) dis[Now][i] = 1e18, vis[i] = ;
    Q.push((Short) {start, dis[Now][start] = });
    while(!Q.empty()) {
        Short tp = Q.top();
        Q.pop();
        if(vis[tp.u]) continue;
        vis[tp.u] = ;
        for(int i = head2[tp.u]; ~ i; i = Gr[i].nxt) {
            int v = Gr[i].v;
            if(dis[Now][v] > dis[Now][tp.u] + Gr[i].w) {
                dis[Now][v] = dis[Now][tp.u] + Gr[i].w;
                Q.push((Short) {v, dis[Now][v]});
            }
        }
    }
}

int fa[N], size[N], son[N], topp[N];
LL deep[N];

void Dfs1(int u, int f_, LL dep) {
    size[u] = ; fa[u] = f_; deep[u] = dep;
    for(int i = head[u]; ~ i; i = G[i].nxt) {
        int v = G[i].v;
        if(v == f_) continue;
        Dfs1(v, u, dep + G[i].w);
        size[u] += size[v];
        if(size[v] > size[son[u]]) son[u] = v;
    }
}

void Dfs2(int u, int tp) {
    topp[u] = tp;
    if(!son[u]) return ;
    Dfs2(son[u], tp);
    for(int i = head[u]; ~ i; i = G[i].nxt) {
        int v = G[i].v;
        if(v != fa[u] && v != son[u]) Dfs2(v, v);
    }
}

inline int Lca(int x, int y) {
    int tpx = topp[x], tpy = topp[y];
    while(tpx != tpy) {
        if(deep[tpx] < deep[tpy]) swap(x, y), swap(tpx, tpy);
        x = fa[tpx], tpx = topp[x];
    }
    if(deep[x] < deep[y]) swap(x, y);
    return y;
}

int main() {
    n = read(), m = read();
    Rep(i, , n) head[i] = -, head2[i] = -;
    Rep(i, , n) fat[i] = i;
    Rep(i, , m) {
        int u = read(), v = read(), w = read();
        E[i] = (Node) {u, v, w, , };
        Link_g(u, v, w), Link_g(v, u, w);
    }

    Kruskal();
    Rep(i, , m) if(E[i].used == ) Nottree[++ tot] = E[i].u, Nottree[++ tot] = E[i].v;

    Rep(i, , tot) {
        Now ++;
        Dijkstra(Nottree[i]);
    }

    Dfs1(, , );
    Dfs2(, );

    for(int q = read(); q; q --) {
        int u = read(), v = read();
        LL Answer = deep[u] + deep[v] -  * deep[Lca(u, v)];
        Rep(i, , tot) {
            Answer = min(Answer, dis[i][u] + dis[i][v]);
        }
        cout << Answer << '\n';
    }

    return ;
}