HYSBZ - 3732 最小生成树+倍增Lca

题目：http://www.lydsy.com/JudgeOnline/problem.php?id=3732
码了一个星期终于过了这一题。（渣是原罪...）
最小生成树+倍增lca 
思路不难，但这是我第一次写lca的题目。下面一步步来解释这题。
题意:给你m条无向边，有k个查询，问从a到b所有路径上的最长边的最小值。
首先，从a到b所有路径上的最长边的最小值所对应的边一定在最小生成树上。
为什么？
现在来回忆一下Kru的做法。把所有边从小到大排序，接着从小到大使用这些边去联通每个点，当使用一条边x时，若x的两个端点在此之前已经联通，则说明这两个点在此之前已经被更短的边联通。可以想象，最小生成树上每两个点都是被最短的边联通的。即当两个点联通时的最长边不可能更小。
所以，现在问题转化为从a到b的在最小生成树上的路径的最长边是多少。
可知从a到b的最长边等于max(a->最近公共祖先c的最长边,b->c的最长边)，即题目转化为lca问题。
至此，思路就很明确了。先构建最小生成树，再寻找两个点的最近公共祖先。
本蒟蒻用倍增lca寻找最近公共祖先，关于倍增lca的解释可以看以下博客(https://riteme.github.io/blog/2016-2-1/lca.html)。
我们设mx[i][j]表示点i到fa[i][j]的最长边，与fa[i][j]=fa[fa[i][j-1]][j-1]相似mx[i][j]=max(mx[i][j-1],mx[fa[i][j-1]][j-1])，即点i到fa[i][j]的最长边等于点i到fa[i][j-1]的最长边与点u(fa[i][j-1])到点fa[u][j-1]的最长边的最大值。(如图)



代码：#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <string>
#include <queue>
#include <map>
#include <vector>
#include <bitset>
#include <set>

using namespace std;

typedef long long LL;
typedef pair<int,int> pii;
const int maxn=3e4+20;
const int maxm=2700+10;
const int maxb=25;
const int mod=1e9+7;
const int inf=1e9+7;
const double infD=1000000007.0;
const double eps=0.00000001;

typedef struct Edge
{
int x,y,w;
Edge() {}
Edge(int _x,int _y,int _w)
{
x=_x;
y=_y;
w=_w;
}
bool operator <(const struct Edge &r)const
{
return w<r.w;
}
} Edge;
typedef struct Node
{
int v,w;
Node() {}
Node(int _v,int _w)
{
v=_v;
w=_w;
}
} Node;
int n,m,Q;
int p[maxn];
Edge e[maxn];
vector<Node> G[maxn];
bool vis[maxn];
int deep[maxn],fa[maxn][maxb],mx[maxn][maxb];

int Find(int x)
{
if(p[x]==x) return x;
else return p[x]=Find(p[x]);
}

void Kru()
{
for(int i=1; i<=n; i++) p[i]=i,G[i].clear();
sort(e,e+m);
int cnt=0;
for(int i=0; i<m; i++)
{
if(cnt==n-1) break;
int x=Find(e[i].x),y=Find(e[i].y);
if(x==y) continue;
cnt++;
p[y]=x;
G[e[i].x].push_back(Node(e[i].y,e[i].w));
G[e[i].y].push_back(Node(e[i].x,e[i].w));
}
}

void dfs(int u,int d)
{
vis[u]=1;
deep[u]=d;
int len=G[u].size();
for(int i=0; i<len; i++)
{
int v=G[u][i].v;
if(!vis[v])
{
fa[v][0]=u;
mx[v][0]=G[u][i].w;
dfs(v,d+1);
}
}
}

void init()
{
for(int j=1; j<maxb; j++)
{
for(int i=1; i<=n; i++)
{
int x=i;
if(~fa[x][j-1])
{
fa[x][j]=fa[fa[x][j-1]][j-1];
mx[x][j]=max(mx[x][j-1],mx[fa[x][j-1]][j-1]);
}
}
}
}

int lca(int u,int v)
{
int ans=0;
if(deep[u]<deep[v]) swap(u,v);
for(int i=maxb-1; i>=0; i--)
{
if(deep[fa[u][i]]>=deep[v])
{
ans=max(ans,mx[u][i]);
u=fa[u][i];
}
}
if(u==v) return ans;
for(int i=maxb-1; i>=0; i--)
{
if(fa[u][i]!=fa[v][i])
{
ans=max(ans,mx[u][i]);
ans=max(ans,mx[v][i]);
u=fa[u][i];
v=fa[v][i];
}
}
ans=max(ans,mx[u][0]);
ans=max(ans,mx[v][0]);
return ans;
}

void work()
{
for(int i=0; i<m; i++)
scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].w);
Kru();

memset(vis,0,sizeof(vis));
memset(fa,0xff,sizeof(fa));
memset(mx,0,sizeof(mx));
memset(deep,0,sizeof(deep));
dfs(1,1);
init();

while(Q--)
{
int a,b;
scanf("%d%d",&a,&b);
printf("%d\n",lca(a,b));
}
}

int main()
{
#ifdef LOCAL
freopen("input.in","r",stdin);
#endif // LOCAL
// while(~scanf("%d%d%d",&n,&m,&Q))
// work();
scanf("%d%d%d",&n,&m,&Q);
work();
return 0;
}后记：
这道题听师兄说是可以直接构造出最小生成树，构造的时候和并查集一样，按秩合并，就能保证树高是logn的，就不用写倍增lca了。但是本蒟蒻实在是太渣了，写了很久都还是TLE，有兴趣的大佬可以试一下，随便教下弱弱的我。