树链剖分是数据结构在树上的推广,其实就是把树hash到几段连续的区间,然后用其它数据结构进行维护,相当于对树进行一个预处理
dfs1()求出fa,deep,size,son
dfs2()求出top,p
注意:重编号后,要注意编号区间是多少
关键数组:
int deep[maxn];
int size[maxn];
int fa[maxn];
int p[maxn];
int son[maxn];
int fp[maxn];
int top[maxn];
树链剖分 分为基于点权,基于边权
基于点权(hdu3966),给树上的点重新编号,p[u]表示u对应的位置
基于边权(spoj375),给树上的边重新编号,p[u]表示u与其父亲节点的连边的位置,则根结点与其父亲节点的连边是不能用的
const int maxn=10010;
using namespace std;
/*-----------------------------树链剖分---------------------*/
struct node{
int v,next;
}edges[maxn<<1];int tot,head[maxn],n;
inline void addedge(int u,int v){//邻接表 记录边
edges[tot].next=head[u];
edges[tot].v=v;
head[u]=tot++;
}
int deep[maxn],size[maxn],top[maxn],fa[maxn],p[maxn],son[maxn],fp[maxn];
//深度,结点数,重链的顶端结点,父亲节点,v与其父亲节点的连边在线段树中的位置(v所在的位置),重儿子,与p数组相反
int pos;
void Init(){
memset(son,-1,sizeof(son));
memset(head,-1,sizeof(head));
tot=pos=0;
}
void dfs1(int u,int pre,int d){//第一遍dfs求出fa,deep,size,son
deep[u]=d;
fa[u]=pre;
size[u]=1;
for(int i=head[u];i!=-1;i=edges[i].next){
int v=edges[i].v;
if(v!=pre){
dfs1(v,u,d+1);
size[u]+=size[v];
if(son[u]==-1||size[son[u]]<size[v]) son[u]=v;
}
}
}
void getpos(int u,int sp){//第二遍dfs求出top和p
top[u]=sp;
p[u]=pos++;
fp[p[u]]=u;
if(son[u]==-1) return ;
getpos(son[u],sp);
for(int i=head[u];i!=-1;i=edges[i].next){
int v=edges[i].v;
if(v!=son[u]&&v!=fa[u]) getpos(v,v);
}
}
修改:
每次选择深度大的重链进行修改,然后将u提到LCA,直到f1==f2
。
当f1=f2后,说明u,v在同一条链上:
1.当基于点权时,即使u==v,也要将路径(u,v)上的每个点进行修改,因为每个点都代表树上的一个编号
2.当基于边权时,将路径(son[u],v)上的边进行修改,因为每个点v的位置表示v到其父节点连边的编号
基于点权:
void change(int u,int v,int val){
int f1=top[u],f2=top[v];
while(f1!=f2){
if(deep[f1]<deep[f2]){
swap(f1,f2);
swap(u,v);
}
add(p[f1],val);
add(p[u]+1,-val);
u=fa[f1];f1=top[u];
}
//没有(u==v)的特判
if(deep[u]>deep[v]) swap(u,v);
add(p[u],val);
add(p[v]+1,-val);
}
基于边权:
int find(int u,int v){
int f1=top[u],f2=top[v];
int ans=0;
while(f1!=f2){
if(dep[f1]<dep[f2]){
swap(f1,f2);
swap(u,v);
}
ans=max(ans,query(p[f1],p[u],1,pos-1,1));
u=fa[f1];f1=top[u];
}
if(u==v) return ans;//有关于u==v的特判
if(dep[u]>dep[v]) swap(u,v);
return max(ans,query(p[son[u]],p[v],1,pos-1,1));
}