CF 1051F

题意：给定一张n个点，m条边的无向联通图，其中m-n<=20，共q次询问，每次询问求给定两点u，v间的最短路长度

第一眼看见这题的时候，以为有什么神奇的全图最短路算法，满心欢喜的去翻了题解，发现就四个字“树上套环”！

其实这题的提示很明显：m-n<=20！

这说明，如果我们对这个图做一次生成树，那么非树边最多只会有20条！

那么，我们在求任意两点间最短路时，可以分类讨论进行：

①：如果这两点间的最短路只经过树边，那么我们可以直接在树上预处理，利用lca（树上两点距离公式）

②：如果这两点间的最短路会经过非树边，那么由于非树边只有20条，所以产生非树边的点最多只有40个，那这样的话我们可以枚举所有有非树边的点，对全图求最短路，然后在每次询问时枚举每个有非树边的点，每找出一个有非树边的点就去求一遍最短路，最后对找出的所有结果求出最小值即可。

#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <queue>
#include <stack>
#define ll long long
using namespace std;
struct Edge
{
    int next;
    int to;
    ll val;
}edge[200005];
bool used[100005];
int num[100005];
ll dis[100005][55];
int que[55];
struct node
{
    int lx,rx;
}e[100005];
struct tt
{
    int p;
    ll v;
};
bool operator < (tt a,tt b)
{
    return a.v>b.v;
}
int head[100005];
bool vis[100005];
int deep[100005];
int cnt=1;
int n,m;
void init()
{
    memset(head,-1,sizeof(head));
    memset(dis,0x3f,sizeof(dis));
    cnt=1;
}
void add(int l,int r,ll w)
{
    edge[cnt].next=head[l];
    edge[cnt].to=r;
    edge[cnt].val=w;
    head[l]=cnt++;
}
ll dep[100005];
int f[100005][30];
void dfs(int x,int fx)
{
    deep[x]=deep[fx]+1;
    f[x][0]=fx;
    for(int i=head[x];i!=-1;i=edge[i].next)
    {
        int to=edge[i].to;
        if(to==fx)
        {
            continue;
        }
        if(f[to][0])
        {
            continue;
        }
        dep[to]=dep[x]+edge[i].val;
        dfs(to,x);
    }
}
void getf()
{
    for(int i=1;i<=25;i++)
    {
        for(int j=1;j<=n;j++)
        {
            f[j][i]=f[f[j][i-1]][i-1];
        }
    }
}
inline int read()
{
    int f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
void diji(int rt,int typ)
{
    memset(vis,0,sizeof(vis));
    dis[rt][typ]=0;
    priority_queue <tt> M;
    tt s;
    s.p=rt;
    s.v=0;
    M.push(s);
    while(!M.empty())
    {
        tt uu=M.top();
        M.pop();
        int u=uu.p;
        if(vis[u])
        {
            continue;
        }
        vis[u]=1;
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int to=edge[i].to;
            if(vis[to])
            {
                continue;
            }
            if(dis[to][typ]>dis[u][typ]+edge[i].val)
            {
                dis[to][typ]=dis[u][typ]+edge[i].val;
                tt temp;
                temp.p=to;
                temp.v=dis[to][typ];
                M.push(temp);
            }
        }
    }
}
int LCA(int x,int y)
{
    if(deep[x]>deep[y])
    {
        swap(x,y);
    }
    for(int i=25;i>=0;i--)
    {
        if(deep[f[y][i]]>=deep[x])
        {
            y=f[y][i];
        }
    }
    if(x==y)
    {
        return x;
    }
    int ret;
    for(int i=25;i>=0;i--)
    {
        if(f[x][i]!=f[y][i])
        {
            x=f[x][i];
            y=f[y][i];
        }else
        {
            ret=f[x][i];
        }
    }
    return ret;
}
int main()
{
    n=read(),m=read();
    init();
    for(int i=1;i<=m;i++)
    {
        int x=read(),y=read(),z=read();
        add(x,y,(ll)z);
        add(y,x,(ll)z);
        e[i].lx=x;
        e[i].rx=y;
    }
    dfs(1,1);
    getf();
    for(int i=1;i<=m;i++)
    {
        if(f[e[i].lx][0]!=e[i].rx&&f[e[i].rx][0]!=e[i].lx)
        {
            used[e[i].lx]=1;
            used[e[i].rx]=1;
        }
    }
    int cct=0;
    for(int i=1;i<=n;i++)
    {
        if(used[i])
        {
            que[++cct]=i;;
            diji(i,cct);
        }
    }
    int q=read();
    for(int i=1;i<=q;i++)
    {
        int x=read(),y=read();
        int f1=LCA(x,y);
        ll ret=dep[x]+dep[y]-2*dep[f1];
        for(int j=1;j<=cct;j++)
        {
            ret=min(ret,dis[x][j]+dis[y][j]);
        }
        printf("%lld\n",ret);
    }
    return 0;
}