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;
}