BZOJ3732 Network（最小生成树+树链剖分）

传送门

【题目分析】

首先是要最大路径最小，那么很容易想到可以用最小生成树来实现，留下最小的n-1条边，保证了图的联通。

然后我们就得到了一颗最小生成树，要询问任意两点路径最大值，就是树链剖分维护就好了。

整体较板，但注意做最小生成树的时候因为一开始我存了双向边结果一排序就T的飞起，所以注意最小生成树的边并不用双向，做kruskal连边的时候才建双向边。

【代码~】

#include<bits/stdc++.h>
using namespace std;
const int MAXN=2e4+10;
const int MAXM=6e4+10;
const int INF=0x3f3f3f3f;
typedef long long LL;

int n,m,q,cnt;
int a[MAXN];
int head[MAXN],fa[MAXN];
int depth[MAXN],son[MAXN],father[MAXN],siz[MAXN],top[MAXN];
int dfn[MAXN],ys[MAXN],tot;
struct Edge{
	int from,to,nxt;
	LL w;
	friend inline bool operator<(const Edge &a,const Edge &b){
		return a.w<b.w;
	}
}edge[MAXM],e[MAXM];
struct Tree{
	int l,r;
	int maxx;
}tr[MAXN<<2];

int Read(){
	int i=0,f=1;
	char c;
	for(c=getchar();(c>'9'||c<'0')&&c!='-';c=getchar());
	if(c=='-')
	  f=-1,c=getchar();
	for(;c>='0'&&c<='9';c=getchar())
	  i=(i<<3)+(i<<1)+c-'0';
	return i*f;
}

void addedge(int x,int y,int z){
	edge[cnt].from=x;
	edge[cnt].to=y;
	edge[cnt].w=z;
	cnt++;
}

void add(int x,int y,int z){
	e[cnt].nxt=head[x];
	head[x]=cnt;
	e[cnt].to=y;
	e[cnt].w=z;
	cnt++;
}

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

void kruskal(){
	for(int i=1;i<=n;++i)
	  fa[i]=i;
	sort(edge,edge+cnt);
	int tot=0;
	for(int i=0;i<cnt;++i){
		int u=edge[i].from,v=edge[i].to;
		u=find(u),v=find(v);
		if(u==v)
		  continue;
		else{
			tot++;
			add(edge[i].from,edge[i].to,edge[i].w);
			add(edge[i].to,edge[i].from,edge[i].w);
			fa[v]=u;
		}
		if(tot==n-1)
		  break;
	}
}

void dfs1(int u,int f){
	siz[u]=1;
	for(int i=head[u];i!=-1;i=e[i].nxt){
		int v=e[i].to;
		if(v==f)
		  continue;
		depth[v]=depth[u]+1,fa[v]=u;
		a[v]=e[i].w;
		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;
	dfn[u]=++tot;
	ys[tot]=u;
	if(!son[u])
	  return ;
	dfs2(son[u],tp);
	for(int i=head[u];i!=-1;i=e[i].nxt){
		int v=e[i].to;
		if(v==fa[u]||v==son[u])
		  continue;
		dfs2(v,v);
	}
}

void push_up(int root){
	tr[root].maxx=max(tr[root<<1].maxx,tr[root<<1|1].maxx);
}

void build(int root,int l,int r){
	tr[root].l=l,tr[root].r=r;
	if(l==r){
		tr[root].maxx=a[ys[l]];
		return ;
	}
	int mid=l+r>>1;
	build(root<<1,l,mid);
	build(root<<1|1,mid+1,r);
	push_up(root);
}

int query(int root,int l,int r,int L,int R){
	if(l>R||r<L)
	  return 0;
	if(L<=l&&r<=R)
	  return tr[root].maxx;
	int mid=l+r>>1;
	if(R<=mid)
	  return query(root<<1,l,mid,L,R);
	else{
		if(L>mid)
		  return query(root<<1|1,mid+1,r,L,R);
		else
		  return max(query(root<<1,l,mid,L,mid),query(root<<1|1,mid+1,r,mid+1,R));
	}
}

int querypath(int x,int y){
	int ret=-INF;
	while(top[x]!=top[y]){
		if(depth[top[x]]<depth[top[y]])
		  swap(x,y);
		ret=max(ret,query(1,1,n,dfn[top[x]],dfn[x]));
		x=fa[top[x]];
	}
	if(depth[x]<depth[y])
	  swap(x,y);
	ret=max(ret,query(1,1,n,dfn[y]+1,dfn[x]));
	return ret;
}

int main(){
	memset(head,-1,sizeof(head));
	n=Read(),m=Read(),q=Read();
	for(int i=1;i<=m;++i){
		int x=Read(),y=Read(),z=Read();
		addedge(x,y,z);
	}
	kruskal();
	dfs1(1,-1);
	dfs2(1,1);
	build(1,1,n);
	while(q--){
		int x=Read(),y=Read();
		cout<<querypath(x,y)<<'\n';
	}
	return 0;
}