CF1051F The Shortest Statement Dijkstra + 性质分析

动态询问连通图任意两点间最短路，单次询问.
显然，肯定有一些巧妙地性质（不然你就发明了新的最短路算法了233）
有一点很奇怪：边数最多只比点数多 $20$ 个，那么就可以将这个图看作是一个生成树，上面连了不到 $20$ 条边.
考虑两个点之间地最短路只有两种情况：经过所有只在生成树上的点，或者经过一些连着生成树外的点.
第一个情况非常好求，随便搞一个生成树然后求个距离就行.
对于第二种情况，由于连着生成树外的边的点最多只有 $20$ 个，所以可以对这些点都跑一遍最短路，然后依次枚举即可.
每次询问的复杂度为 $O(log$ $n+20 )$

#include<bits/stdc++.h>
using namespace std;
void setIO(string s) {
    string in=s+".in";
    freopen(in.c_str(),"r",stdin);
}
typedef long long ll;
const int maxn=100005;
const ll inf=10000000000000;
struct Union {
    int p[maxn];
    void init() {
        for(int i=0;i<maxn;++i) p[i]=i;
    }
    int find(int x) {
        return p[x]==x?x:p[x]=find(p[x]);
    }
    int merge(int x,int y) {
        int a=find(x),b=find(y);
        if(a==b) return 0;
        p[a]=b;
        return 1;
    }
}ufs;
struct Edge {
    int u,v,c;
}ed[maxn];
namespace tree {
    int edges;
    int val[maxn<<1],hd[maxn],to[maxn<<1],nex[maxn<<1];
    int dep[maxn],fa[maxn],top[maxn],siz[maxn],son[maxn];
    ll dis[maxn];
    void addedge(int u,int v,int c) {
        nex[++edges]=hd[u],hd[u]=edges,to[edges]=v,val[edges]=c;
    }
    void dfs1(int u,int ff) {
        fa[u]=ff,dep[u]=dep[ff]+1,siz[u]=1;
        for(int i=hd[u];i;i=nex[i]) {
            int v=to[i];
            if(v==ff) continue;
            dis[v]=dis[u]+1ll*val[i];
            dfs1(v,u), siz[u]+=siz[v];
            if(siz[v]>siz[son[u]]) son[u]=v;
        }
    }
    void dfs2(int u,int tp) {
        top[u]=tp;
        if(son[u]) dfs2(son[u],tp);
        for(int i=hd[u];i;i=nex[i]) {
            int v=to[i];
            if(v==fa[u]||v==son[u]) continue;
            dfs2(v,v);
        }
    }
    int LCA(int x,int y) {
        while(top[x]^top[y]) {
            dep[top[x]] > dep[top[y]] ? x = fa[top[x]] : y = fa[top[y]];
        }
        return dep[x] < dep[y] ? x : y;
    }
    ll Dis(int x,int y) {
        return dis[x]+dis[y]-(dis[LCA(x,y)]*2);
    }
};
namespace Dijkstra {
    struct Node {
        ll dis;  int u;
        Node(ll dis=0,int u=0):dis(dis),u(u){}
        bool operator<(Node b) const {
            return dis>b.dis;
        }
    };
    priority_queue<Node>Q;
    int edges;
    int done[maxn], hd[maxn],to[maxn<<1],nex[maxn<<1],val[maxn<<1];
    ll d[maxn];
    ll dis[50][maxn];
    void addedge(int u,int v,int c) {
        nex[++edges]=hd[u],hd[u]=edges,to[edges]=v,val[edges]=c;
    }
    void dijkstra(int s,int idd) {
        for(int i=0;i<maxn;++i) d[i]=inf,done[i]=0;
        d[s]=0, dis[idd][s]=0, Q.push(Node(0,s));
        while(!Q.empty()) {
            Node e=Q.top(); Q.pop();
            int u=e.u;
            if(done[u]) continue;
            done[u]=1, dis[idd][u]=d[u];
            for(int i=hd[u];i;i=nex[i]) {
                int v=to[i];
                if(d[u]+val[i]<d[v]) {
                    d[v]=d[u]+1ll*val[i];
                    Q.push(Node(d[v], v));
                }
            }
        }
    }
};
int n,m;
int mk[maxn],ne[maxn];
int main() {
    // setIO("input");
    scanf("%d%d",&n,&m);
    ufs.init();
    for(int i=1;i<=m;++i) {
        scanf("%d%d%d",&ed[i].u,&ed[i].v,&ed[i].c);
        if(ufs.merge(ed[i].u, ed[i].v)) {
            tree::addedge(ed[i].u, ed[i].v, ed[i].c);
            tree::addedge(ed[i].v, ed[i].u, ed[i].c);
            mk[i]=1;
        }
    }
    int cnt=0;
    tree::dfs1(1,0);
    tree::dfs2(1,1);
    for(int i=1;i<=m;++i) if(mk[i]==0) ne[ed[i].u]=ne[ed[i].v]=1;
    for(int i=1;i<=m;++i) Dijkstra::addedge(ed[i].u, ed[i].v, ed[i].c), Dijkstra::addedge(ed[i].v,ed[i].u,ed[i].c);
    for(int i=1;i<=n;++i) if(ne[i]) ++cnt, Dijkstra::dijkstra(i,cnt);
    int Q;
    scanf("%d",&Q);
    for(int cas=1;cas<=Q;++cas) {
        int u,v;
        scanf("%d%d",&u,&v);
        ll ans=tree::Dis(u,v);
        for(int i=1;i<=cnt;++i) ans=min(ans,Dijkstra::dis[i][u]+Dijkstra::dis[i][v]);
        printf("%I64d\n",ans);
    }
    return 0;
}