最小生成树&LCA之：【除了dis[]以外，两个点之间新的维护】【求两点之间经过的最小边权】【树上倍增DP的思考方式】【树上倍增原理的剖析】【倍增法对到祖宗节点的某个东西的维护】

原型是：最近公共祖先之：【严格次小生成树 o(nlogn)写法】【利用倍增2^k步拆成两个2^(k-1)】【维护树上路径中边权的最大值和次大值】【a和b跳到最近公共祖先过程中的弧(每跳一次形成一个弧)】_bei2002315的博客-CSDN博客 

一.小TIP 

 二.关于森林的注意

 三.树上倍增DP的思考路线总结 （重要在画图）

下面有详细的画图过程，也能帮助理解倍增的过程 

/*
step1:先把最大生成树实际建立出来
step2:由于要利用最近公共祖先，求两个点x,y之间遇到的最小边权
所以用 bfs初始化倍增数组 
*/
#include <bits/stdc++.h>
using namespace std;
const int N=1e4+10;
const int M=5e4+10;
int p[N];
int e[M],ne[M],h[N],w[M],idx;
int depth[N];
int fa[N][20];
int s[N][20];

void add(int a,int b,int c)
{
	e[idx]=b;
	ne[idx]=h[a];
	w[idx]=c;
	h[a]=idx++;
}

struct Node
{
	int x,y;
	int w;
	
	bool operator<(const Node & W)const
	{
	 	return w>W.w;
	}
}edges[M];

int find(int x)
{
	if(x!=p[x])
	{
		p[x]=find(p[x]);
    }
    
    return p[x];
}

void bfs(int root)
{
	memset(depth,0x3f,sizeof depth);
	depth[0]=0;
	depth[1]=1;
	queue<int> q;
	q.push(root);
	while(!q.empty())
	{
		auto u=q.front();
		q.pop();
		
		for(int i=h[u];i!=-1;i=ne[i])
		{
			int j=e[i];
			if(depth[j]>depth[u]+1)
			{
			depth[j]=depth[u]+1;
			q.push(j);
			
			fa[j][0]=u;
			s[j][0]=w[i];
			
			for(int k=1;k<=19;k++)
			{
				fa[j][k]=fa[fa[j][k-1]][k-1];
			    s[j][k]=min(s[j][k-1],s[fa[j][k-1]][k-1]);
			}
			
	     	}
		}
	}
}




//这个函数里面就不需要出现k-1这样的分布了，因为在bfs里面本来就初始化完毕了  
int lca(int a,int b)
{
	int minv=0x3f3f3f;   //存两点之间的边权的最小值，根据图来更新  
	if(depth[a]<depth[b])
	{
		swap(a,b);
    }
	
	//先是a在跳 ，要用a的路径更新minv 
	for(int k=19;k>=0;k--)
	{
		if(depth[fa[a][k]]>=depth[b])
		{
			minv=min(minv,s[a][k]);
			a=fa[a][k];	
		}
	} 
	
	if(a==b) return minv;
	
	//然后a,b一起跳，要用两边来更新 minv 
	for(int k=19;k>=0;k--)
	{
		if(fa[a][k]!=fa[b][k])
		{
			minv=min(minv,s[a][k]);
			minv=min(minv,s[b][k]);
			a=fa[a][k];
			b=fa[b][k];
		}
	}
	
	//最后一起一步跳向祖宗 
	minv=min(minv,s[a][0]);
	minv=min(minv,s[b][0]);
	//return fa[a][0];
	
	
	return  minv;
}

int main()
{
	int n,m;
	scanf("%d%d",&n,&m);  //n座城市，m条道路
	
	for(int i=0;i<=n;i++)
	{
		p[i]=i;
	}
	
	for(int i=1;i<=m;i++)
	{
		int x,y,z;
		scanf("%d%d%d",&x,&y,&z);
		edges[i]={x,y,z};
	} 
	
	sort(edges+1,edges+1+m);
	
	
	//建立出最大生成树 
	memset(h,-1 ,sizeof h);
	for(int i=1;i<=m;i++)
	{
		int a=edges[i].x;
		int b=edges[i].y;
		int w=edges[i].w;
		
		int pa=find(a);
		int pb=find(b);
		
		if(pa!=pb)
		{
			p[pa]=pb;
			
			add(a,b,w);
			add(b,a,w);
		}
	}
	
    //注意了，由于可能是个最小生成森林，所以1不一定能跑到所有独立的联通块，所以要用个for循环
	for(int i=1;i<=n;i++)
	{
		if(!depth[i])  //如果该联通块没被动过 
     	bfs(i);  
    }
	
	
	//枚举询问：找两个点之间路过边权的最小值 
	int q;
	scanf("%d",&q);
	while(q--)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		if(find(x)==find(y))
		printf("%d\n",lca(x,y)); 
	    else puts("-1");
	}
	
	
	return 0; 
}