重链剖分&长链剖分

1.重链剖分

做法：令x的儿子中子树节点最多的儿子为重儿子，将一棵树划分成只由重儿子组成的一条条链

性质：

1.每两个点的最短路径最多经过logN条重链：每经过一个节点，子树大小至少减半，故在logN次一定走完

2.遍历一棵树，每次优先遍历重儿子，这棵树的dfn序列中，保证每条重链一定连续，每棵树及其子树的节点一定连续

那么对于维护树上信息的问题就可以把一棵树转化成一条链，然后维护链上的信息就好了

dfs1：先求出一棵树每个节点的重儿子，每个节点的深度（求实际问题时一般要用到深度来确定链的编号），父亲节点

void dfs1(int x,int f){
	sz[x]=1,hs[x]=0;fa[x]=f;
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i];
		if(p==f) continue;
		dep[p]=dep[x]+1;
		dfs1(p,x);
		sz[x]+=sz[p];
		if(sz[p]>sz[hs[x]]) hs[x]=p;
	}
} 

dfs2：求出每个节点的dfs序（为转化成序列问题做准备），每条链的开头

int times=0;
void dfs2(int x,int up){
	top[x]=up,id[x]=++times;
	if(hs[x]!=0) dfs2(hs[x],up);
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i];
		if(p==fa[x]||p==hs[x]) continue;
		dfs2(p,p);
	}
} 

剩下的具体问题具体分析，这里贴出来洛谷板子题的几个操作（变量名很好看）

//ty是线段树
void add_edge(int x,int y,int w){
	while(top[x]!=top[y]){	
		if(dep[top[x]]<dep[top[y]]) swap(x,y);//跳链头较深的
		ty.add(1,1,a,id[top[x]],id[x],w);//记得是用id
		x=fa[top[x]];//到链头已经更新过了，就是这样
	}
	if(dep[x]<dep[y]) swap(x,y);
	ty.add(1,1,a,id[y],id[x],w);
}
int query_edge(int x,int y){//同add_edge
	int ans=0;
	while(top[x]!=top[y]){
		if(dep[top[x]]<dep[top[y]]) swap(x,y);
		ans=(ans+ty.query(1,1,a,id[top[x]],id[x]))%mod;
		x=fa[top[x]];
	}
	if(dep[x]<dep[y]) swap(x,y);
	ans=(ans+ty.query(1,1,a,id[y],id[x]))%mod;
	return ans;
}
void add_tree(int x,int w){//子树编号连续
	ty.add(1,1,a,id[x],id[x]+sz[x]-1,w);
}
int query_tree(int x){
	return ty.query(1,1,a,id[x],id[x]+sz[x]-1);
}

重链剖分边权转点权

将每条边与两端点较靠下的形成映射，然后还是维护节点信息就行了

2.长链剖分

1.做法：令儿子节点到叶子节点最远的点为此节点的长儿子，将一棵树划分成为由长儿子组成的一条条链

性质：每个节点的k倍祖先所在的长链长度>=k（因为这个节点到其k倍祖先的距离为k）

利用这个性质，就有了长链剖分应用1：多次询问一个节点的k倍祖先

思路：先利用倍增找到这个节点的2^n节点，使2^n<=k<=2^(n+1)

然后跳到这个点所在长链的链头

对于每条长度为len的链，记录其向上的len个节点和向下的len个节点

因为len>=k所以记录这么多节点就行了

然后就直接查找

长链剖分：

void dfs1(long long x){
	for(long long i=1;(1<<i)<=a;i++) fa[x][i]=fa[fa[x][i-1]][i-1];
	for(long long i=0;i<tu[x].size();i++){
		long long p=tu[x][i];
		if(p==fa[x][0]) continue;
		d[p]=d[x]+1;
		fa[p][0]=x;
		dfs1(p);
		if(dep[ls[x]]<dep[p]) ls[x]=p;
	}
	dep[x]=dep[ls[x]]+1;
}
long long times=0;
void dfs2(long long x,long long up){
	to_down[up].push_back(x);
	id[x]=++times,mp[times]=x,top[x]=up;
	if(ls[x]) dfs2(ls[x],up);
	for(long long i=0;i<tu[x].size();i++){
		long long p=tu[x][i];
		if(p==fa[x][0]||p==ls[x]) continue;
		dfs2(p,p);
		int nowp=p;
		for(long long j=0;j<dep[p];j++){
			if(!nowp) break;
			to_up[p].push_back(nowp);
			nowp=fa[nowp][0];
		}
		
	}
}

查找：

long long get_ans(long long x,long long k){
	if(!k) return x;
	x=fa[x][Log[k]];
	k-=(1<<Log[k]);
	k-=(id[x]-id[top[x]]);
	x=top[x];
	if(k<=0) return to_down[x][-k];
	else return to_up[x][k];
}

2.长链剖分优化dp

当然优化的是树上dp了

思路：对于一条链的转移一般好分析，那么令每一条长链上的信息一起保存，共用空间

剩下的就暴力好了

题目

暴力好想，dp[x][i]为x节点距离为i的子节点的个数

然后链上的信息每次传递下去就好了

#include<bits/stdc++.h>
using namespace std;
vector<int>tu[1001000];
int buf[2001000];
int a,dep[1001000],ls[1000100],ans[1000100];
int *dp[1001000],*now=buf;
void dfs1(int x,int fa);
void dfs2(int x,int fa);
void write(int x);
int main(){
	scanf("%d",&a);
	for(int i=1;i<a;i++){
		int o,k;
		scanf("%d%d",&o,&k);
		tu[o].push_back(k),tu[k].push_back(o);
	}
	dfs1(1,0);
	dp[1]=now,now+=dep[1];
	dfs2(1,0);
	for(int i=1;i<=a;i++) write(ans[i]),putchar('\n');
	return 0;
}
void dfs1(int x,int fa){
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i];
		if(p==fa) continue;
		dfs1(p,x);
		if(dep[p]>dep[ls[x]]) ls[x]=p;
	}
	dep[x]=dep[ls[x]]+1;
}
void dfs2(int x,int fa){
	dp[x][0]=1;
	if(ls[x]){
		dp[ls[x]]=dp[x]+1;
		dfs2(ls[x],x);
		if(dp[x][ans[x]]<dp[x][ans[ls[x]]+1]) ans[x]=ans[ls[x]]+1;
	}
	for(int i=0;i<tu[x].size();i++){
		int p=tu[x][i];
		if(p==fa||p==ls[x]) continue;
		dp[p]=now,now+=dep[p];
		dfs2(p,x);
		for(int j=1;j<=dep[p];j++){
			dp[x][j]+=dp[p][j-1];
			if((dp[x][j]>dp[x][ans[x]])||(j<ans[x]&&dp[x][j]==dp[x][ans[x]])) ans[x]=j;
		}
	}
}
void write(int x){
	if(x>9) write(x/10);
	putchar(x%10+'0');
}