jzoj5914 盟主的忧虑 树链剖分

Description

---

江湖由 N 个门派（2≤N≤100,000，编号从 1 到 N）组成，这些门派之间有 N-1 条小道将他们连接起来，每条道路都以“尺”为单位去计量，武林盟主发现任何两个门派都能够直接或者间接通过小道连接。
虽然整个江湖是可以互相到达的，但是他担心有心怀不轨之徒破坏这个武林的安定，破坏小道，于是武林盟主又秘密地修建了 M 条密道（1≤M≤100,000），但每条小道距离都不超过10亿尺。
果不其然，最近一个名叫“太吾”的组织意欲破坏武林的小道，请你帮盟主想想办法，如果门派 A 到门派 B 的直连小道被破坏，从 A 走到 B 的所有路径中，经过密道的距离最少是多少？

30%数据：N<=300,M<=1000
50%数据：N<=1000,M<=1000
70%数据：N<=5000,M<=5000
对于另外15%的数据点：树是一条链
100%数据：N,M<=100,000

Solution

---

其实m次dfs就有70’了

显然只会走一条非树边。我们枚举一条非树边，能够以这条边为答案的树边一定在非树边两端点的路径上
注意到区间取max取min非常难写于是我们可以对非树边排序，这样就变成路径涂色了，虽然是noip模拟但是可以树链剖分直接上

正解是并查集。我们加树边等价于把两端点到它们lca路径上的边缩起来，表明这些边不会再更新答案了。这么做复杂度比较优秀

三天树链剖分一点都不清真好吧。。

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)
#define drp(i,st,ed) for (int i=st;i>=ed;--i)

const int INF=0x3f3f3f3f;
const int N=200005;
const int E=200005;

struct edge {int x,y,w,next;} e[N*2],g[N],h[E];

int fa[N],dep[N],size[N],bl[N],pos[N];
int val[N<<2],tag[N<<2],ls[N],edCnt;

inline int read() {
	int x=0,v=1; char ch=getchar();
	for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):(v),ch=getchar());
	for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
	return x*v;
}

void add_edge(int x,int y,int w) {
	e[++edCnt]=(edge) {x,y,w,ls[x]}; ls[x]=edCnt;
	e[++edCnt]=(edge) {y,x,w,ls[y]}; ls[y]=edCnt;
}

void dfs1(int now) {
	size[now]=1;
	for (int i=ls[now];i;i=e[i].next) {
		if (e[i].y==fa[now]) continue;
		fa[e[i].y]=now; dep[e[i].y]=dep[now]+1;
		dfs1(e[i].y); size[now]+=size[e[i].y];
	}
}

void dfs2(int now,int up) {
	bl[now]=up; pos[now]=++pos[0];
	int mx=0;
	for (int i=ls[now];i;i=e[i].next) {
		if (e[i].y!=fa[now]&&size[e[i].y]>size[mx]) mx=e[i].y;
	}
	if (!mx) return ;
	dfs2(mx,up);
	for (int i=ls[now];i;i=e[i].next) {
		if (e[i].y!=fa[now]&&e[i].y!=mx) dfs2(e[i].y,e[i].y);
	}
}

void push_down(int now) {
	if (!tag[now]) return ;
	int w=tag[now]; tag[now]=0;
	tag[now<<1]=tag[now<<1|1]=w;
	val[now<<1]=val[now<<1|1]=w;
}

int query(int now,int tl,int tr,int x) {
	if (tl==tr) return val[now];
	push_down(now);
	int mid=(tl+tr)>>1;
	if (x<=mid) return query(now<<1,tl,mid,x);
	return query(now<<1|1,mid+1,tr,x);
}

void modify(int now,int tl,int tr,int l,int r,int v) {
	if (r<l) return ;
	if (tl>=l&&tr<=r) return (void) (val[now]=tag[now]=v);
	push_down(now);
	int mid=(tl+tr)>>1;
	modify(now<<1,tl,mid,l,std:: min(r,mid),v);
	modify(now<<1|1,mid+1,tr,std:: max(mid+1,l),r,v);
}

void change(int x,int y,int v) {
	for (;bl[x]!=bl[y];) {
		if (dep[bl[x]]<dep[bl[y]]) std:: swap(x,y);
		modify(1,1,pos[0],pos[bl[x]],pos[x],v);
		x=fa[bl[x]];
	}
	if (pos[x]>pos[y]) std:: swap(x,y);
	modify(1,1,pos[0],pos[x]+1,pos[y],v);
}

int get_lca(int x,int y) {
	for (;bl[x]!=bl[y];) {
		if (dep[bl[x]]<dep[bl[y]]) std:: swap(x,y);
		x=fa[bl[x]];
	}
	return dep[x]<dep[y]?x:y;
}

void build(int now,int tl,int tr) {
	if (tl==tr) return (void) (val[now]=-1);
	int mid=(tl+tr)>>1;
	build(now<<1,tl,mid); build(now<<1|1,mid+1,tr);
}

bool cmp(edge a,edge b) {
	return a.w>b.w;
}

int main(void) {
	freopen("worry.in","r",stdin);
	freopen("worry.out","w",stdout);
	int n=read(),m=read();
	rep(i,1,n-1) {
		int x=read(),y=read();
		add_edge(x,y,0);
		g[i]=(edge) {x,y,0,0};
	}
	rep(i,1,m) {
		int x=read(),y=read(),w=read();
		h[i]=(edge) {x,y,w,0};
	}
	dfs1(dep[1]=1); dfs2(1,1);
	build(1,1,pos[0]);
	std:: sort(h+1,h+m+1,cmp);
	rep(j,1,m) {
		int lca=get_lca(h[j].x,h[j].y);
		change(h[j].x,lca,h[j].w);
		change(h[j].y,lca,h[j].w);
	}
	rep(i,1,n-1) {
		if (dep[g[i].y]>dep[g[i].x]) std:: swap(g[i].x,g[i].y);
		printf("%d\n", query(1,1,pos[0],pos[g[i].x]));
	}
	return 0;
}