bzoj4817 [Sdoi2017]树点涂色 LCT+线段树

Description

---

Bob有一棵n个点的有根树，其中1号点是根节点。Bob在每个点上涂了颜色，并且每个点上的颜色不同。定义一条路
径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。Bob可能会进行这几种操作：
1 x:
把点x到根节点的路径上所有的点染上一种没有用过的新颜色。
2 x y:
求x到y的路径的权值。
3 x
在以x为根的子树中选择一个点，使得这个点到根节点的路径权值最大，求最大权值。
Bob一共会进行m次操作

1<=n,m<=100000

Solution

---

奇妙

对于操作一我们在LCT上access(x)，这样虚边的含义变成节点与父亲颜色不同，实边表示节点与父亲颜色相同。那么在往上跳的过程中用线段树维护子树内的区间±1，最大值就行了

Code

---

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

const int N=100005;

struct edge {int y,next;} e[N*2];
struct treeNode {int son[2],fa,mn,is_root;} t[N];

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

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) {
	e[++edCnt]=(edge) {y,ls[x]}; ls[x]=edCnt;
	e[++edCnt]=(edge) {x,ls[y]}; ls[y]=edCnt;
}

void push_up(int x) {
	t[x].mn=x;
	if (t[x].son[0]&&dep[t[t[x].son[0]].mn]<dep[t[x].mn]) t[x].mn=t[t[x].son[0]].mn;
	if (t[x].son[1]&&dep[t[t[x].son[1]].mn]<dep[t[x].mn]) t[x].mn=t[t[x].son[1]].mn;
}

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

void rotate(int x) {
	if (t[x].is_root) return ;
	int y=t[x].fa; int z=t[y].fa;
	int k=t[y].son[1]==x;
	t[y].son[k]=t[x].son[!k]; if (t[x].son[!k]) t[t[x].son[!k]].fa=y;
	t[x].son[!k]=y; t[y].fa=x;
	t[x].fa=z;
	if (t[y].is_root) {
		t[x].is_root=1;
		t[y].is_root=0;
	} else t[z].son[t[z].son[1]==y]=x;
	push_up(y); push_up(x);
}

void splay(int x) {
	for (;!t[x].is_root;) {
		int y=t[x].fa; int z=t[y].fa;
		if (!t[y].is_root) {
			if ((t[z].son[1]==y)^(t[y].son[1]==x)) rotate(x);
			else rotate(y);
		}
		rotate(x);
	}
}

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 (size[e[i].y]>size[mx]&&e[i].y!=fa[now]) mx=e[i].y;
	}
	if (!mx) return ;
	dfs2(mx,up);
	for (int i=ls[now];i;i=e[i].next) {
		if (e[i].y!=mx&&e[i].y!=fa[now]) dfs2(e[i].y,e[i].y);
	}
}

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

int query(int now,int tl,int tr,int l,int r) {
	if (r<l) return 0;
	if (tl>=l&&tr<=r) return max[now];
	int mid=(tl+tr)>>1;
	push_down(now);
	int qx=query(now<<1,tl,mid,l,std:: min(r,mid));
	int qy=query(now<<1|1,mid+1,tr,std:: max(mid+1,l),r);
	return std:: max(qx,qy);
}

void change(int x,int v) {
	modify(1,1,pos[0],pos[x],pos[x]+size[x]-1,v);
}

void access(int x) {
	for (int y=0;x;) {
		splay(x);
		change(t[t[x].son[1]].mn,1);
		change(t[y].mn,-1);
		t[t[x].son[1]].is_root=1;
		t[t[x].son[1]=y].is_root=0;
		push_up(x);
		y=x; x=t[x].fa;
	}
}

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

int ask(int x,int y) {
	int lca=get_lca(x,y);
	x=query(1,1,pos[0],pos[x],pos[x]);
	y=query(1,1,pos[0],pos[y],pos[y]);
	lca=query(1,1,pos[0],pos[lca],pos[lca]);
	return x+y-lca*2+1;
}

int main(void) {
	int n=read(),m=read();
	rep(i,2,n) add_edge(read(),read());
	dfs1(dep[1]=1); dfs2(1,1);
	rep(i,1,n) {
		t[i].fa=fa[i];
		t[i].mn=i;
		t[i].is_root=1;
		change(i,1);
	}
	for (int opt,x,y;m--;) {
		opt=read(),x=read();
		if (opt==1) access(x);
		else if (opt==2) {
			y=read();
			printf("%d\n", ask(x,y));
		} else printf("%d\n", query(1,1,n,pos[x],pos[x]+size[x]-1));
	}
	return 0;
}