树链剖分模板

最新推荐文章于 2022-02-25 16:17:52 发布
置顶 最新推荐文章于 2022-02-25 16:17:52 发布
阅读量134 收藏
点赞数
分类专栏： 数据结构 文章标签： 模板 树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EDGiboy/article/details/103087506
版权

基于点

#include<iostream>
#include<cstdio>
using namespace std;
const int MAX_N=50100;
int size[MAX_N],wson[MAX_N],dfn[MAX_N],deep[MAX_N],pre[MAX_N],top[MAX_N],fa[MAX_N];
int head[MAX_N],Next[2*MAX_N],ver[2*MAX_N];
int tot,cnt;
struct node{
 	int l,r,sum,lazy;
}a[MAX_N*4];
int b[MAX_N];
void update(int k){
 	a[k].sum=a[k<<1].sum+a[k<<1|1].sum;
}
void build(int k,int l,int r){
 	a[k].l=l;a[k].r=r;a[k].lazy=0;
 	if(l==r){
  		a[k].sum=b[pre[l]];
  		return;
 	}
 	int mid=(l+r)>>1;
 	build(k<<1,l,mid);
 	build(k<<1|1,mid+1,r);
 	update(k);
}
void pushdown(int k){
 	if(a[k].lazy==0)
 	return;
 	a[k<<1].lazy+=a[k].lazy;
 	a[k<<1|1].lazy+=a[k].lazy;
 	a[k<<1].sum+=(a[k<<1].r-a[k<<1].l+1)*a[k].lazy;
 	a[k<<1|1].sum+=(a[k<<1|1].r-a[k<<1|1].l+1)*a[k].lazy;
 	a[k].lazy=0;
}
void changeS(int k,int l,int r,int y){
 	if(a[k].l>=l&&a[k].r<=r){
  		a[k].sum+=(a[k].r-a[k].l+1)*y;
  		a[k].lazy+=y;
  		return;
 	}
 	pushdown(k);
 	int mid=(a[k].l+a[k].r)>>1;
 	if(l<=mid)
 	changeS(k<<1,l,r,y);
 	if(r>mid)
 	changeS(k<<1|1,l,r,y);
 	update(k);
}
int query(int k,int l,int r){
 	if(a[k].l>=l&&a[k].r<=r)
 	return a[k].sum;
 	pushdown(k);
 	int mid=(a[k].l+a[k].r)>>1;
 	int x=0;
 	if(l<=mid)
 	x+=query(k<<1,l,r);
 	if(r>mid)
 	x+=query(k<<1|1,l,r);
 	return x;
}
void Add(int x,int y){
    ver[++tot]=y;Next[tot]=head[x];head[x]=tot;
}
void dfs1(int x,int fat){
    size[x]=1;
    for(int i=head[x];i;i=Next[i]){
        int y=ver[i];
        if(y==fat)
            continue;
        deep[y]=deep[x]+1;
        fa[y]=x;
        dfs1(y,x);
        size[x]+=size[y];
        if(size[wson[x]]<size[y])
            wson[x]=y;
    }
}
void dfs2(int x,int tp){
    dfn[x]=++cnt;
    pre[cnt]=x;
    top[x]=tp;
    if(wson[x])
        dfs2(wson[x],tp);
    for(int i=head[x];i;i=Next[i]){
        int y=ver[i];
        if(y!=wson[x]&&y!=fa[x])
            dfs2(y,y);
    }
}
void modify(int x,int y,int d){//修改x到y路径上的值
    while(top[x]!=top[y]){
        if(dfn[top[x]]<dfn[top[y]])
            swap(x,y);
        changeS(1,dfn[top[x]],dfn[x],d);
        x=fa[top[x]];
    }
    if(deep[x]>deep[y])
        swap(x,y);
    changeS(1,dfn[x],dfn[y],d);
}
int Qsum(int x,int y){
    int ret=0;
    while(top[x]!=top[y]){
        if(dfn[top[x]]<dfn[top[y]])
            swap(x,y);
        ret+=query(1,dfn[top[x]],dfn[x]);
        x=fa[top[x]];
    }
    if(deep[x]>deep[y])
        swap(x,y);
    ret+=query(1,dfn[x],dfn[y]);
    return ret;
}
int main(void){
    int i,n,m,q,x,y,c1,c2,k;
    while(scanf("%d%d%d",&n,&m,&q)!=EOF){
    for(i=1;i<=n;i++){
        head[i]=0;
        deep[i]=0;
        wson[i]=0;
    }
    tot=0;
    cnt=0;
    for(i=1;i<=n;i++){
        scanf("%d",&b[i]);
    }
    for(i=0;i<m;i++){
        scanf("%d%d",&x,&y);
        Add(x,y);
        Add(y,x);
    }
    deep[1]=1;
    dfs1(1,0);
    dfs2(1,1);
    build(1,1,n);
    for(i=0;i<q;i++){
        string s;
        cin>>s;
        if(s[0]=='I'){
            scanf("%d%d%d",&c1,&c2,&k);
            modify(c1,c2,k);
        }
        else if(s[0]=='D'){
            scanf("%d%d%d",&c1,&c2,&k);
            modify(c1,c2,-k);
        }
        else{
            scanf("%d",&c1);
            printf("%d\n",Qsum(c1,c1));
        }
    }
    }
    return 0;
}

基于边

#include<iostream>
#include<cstdio>
#include<cmath>
#include<string>
#include<algorithm>
using namespace std;
const int MAX_N=10100;
int size[MAX_N],wson[MAX_N],dfn[MAX_N],deep[MAX_N],pre[MAX_N],top[MAX_N],fa[MAX_N];
int head[MAX_N],Next[2*MAX_N],ver[2*MAX_N],edge[2*MAX_N];
int dp[MAX_N][22];
int tt;
int tot,cnt;
struct node{
 	int l,r,lazy,maxl;
}a[MAX_N*4];
struct skt{
    int u,v,w;
}ed[MAX_N];
int b[MAX_N];
inline void update(int k){
 	a[k].maxl=max(a[k<<1].maxl,a[k<<1|1].maxl);
}
inline void build(int k,int l,int r){
 	a[k].l=l;a[k].r=r;a[k].lazy=0;
 	if(l==r){
  		a[k].maxl=b[pre[l]];
  		return;
 	}
 	int mid=(l+r)>>1;
 	build(k<<1,l,mid);
 	build(k<<1|1,mid+1,r);
 	update(k);
}
inline void pushdown(int k){
 	if(a[k].lazy==0)
 	return;
 	a[k<<1].lazy=a[k<<1|1].lazy=a[k].lazy;
 	a[k<<1].maxl=a[k].lazy;
 	a[k<<1|1].maxl=a[k].lazy;
 	//a[k<<1].sum=(a[k<<1].r-a[k<<1].l+1)*a[k].lazy;
 	//a[k<<1|1].sum=(a[k<<1|1].r-a[k<<1|1].l+1)*a[k].lazy;
 	a[k].lazy=0;
}
inline void changeS(int k,int l,int r,int y){
 	if(a[k].l>=l&&a[k].r<=r){
  		//a[k].sum+=(a[k].r-a[k].l+1)*y;
  		a[k].maxl=y;
  		a[k].lazy=y;
  		return;
 	}
 	pushdown(k);
 	int mid=(a[k].l+a[k].r)>>1;
 	if(l<=mid)
 	changeS(k<<1,l,r,y);
 	if(r>mid)
 	changeS(k<<1|1,l,r,y);
 	update(k);
}
inline int query(int k,int l,int r){
 	if(a[k].l>=l&&a[k].r<=r)
 	return a[k].maxl;
 	pushdown(k);
 	int mid=(a[k].l+a[k].r)>>1;
 	int x=0;
 	if(l<=mid)
 	x=max(x,query(k<<1,l,r));
 	if(r>mid)
 	x=max(x,query(k<<1|1,l,r));
 	return x;
}
inline int LCA(int x,int y){
    if(deep[x]>deep[y])
        swap(x,y);
    for(int i=tt;i>=0;i--)
        if(deep[dp[y][i]]>=deep[x])
        y=dp[y][i];
    if(x==y)
        return x;
    for(int i=tt;i>=0;i--){
        if(dp[x][i]!=dp[y][i]){
            x=dp[x][i];
            y=dp[y][i];
        }
    }
    return dp[x][0];
}
inline void Add(int x,int y,int z){
    ver[++tot]=y;edge[tot]=z;Next[tot]=head[x];head[x]=tot;
}
inline void dfs1(int x,int fat){
    size[x]=1;
    for(int i=head[x];i;i=Next[i]){
        int y=ver[i];
        if(y==fat)
            continue;
        deep[y]=deep[x]+1;
        dp[y][0]=x;
        fa[y]=x;
        b[y]=edge[i];
        dfs1(y,x);
        size[x]+=size[y];
        if(size[wson[x]]<size[y])
            wson[x]=y;
    }
}
inline void dfs2(int x,int tp){
    dfn[x]=++cnt;
    pre[cnt]=x;
    top[x]=tp;
    if(wson[x])
        dfs2(wson[x],tp);
    for(int i=head[x];i;i=Next[i]){
        int y=ver[i];
        if(y!=wson[x]&&y!=fa[x])
            dfs2(y,y);
    }
}
inline void modify(int x,int y,int d){//修改x到y路径上的值
    while(top[x]!=top[y]){
        if(dfn[top[x]]<dfn[top[y]])
            swap(x,y);
        changeS(1,dfn[top[x]],dfn[x],d);
        x=fa[top[x]];
    }
    if(deep[x]>deep[y])
        swap(x,y);
    changeS(1,dfn[x],dfn[y],d);
}
inline int Qsum(int x,int y){
    int ret=0;
    while(top[x]!=top[y]){
        if(dfn[top[x]]<dfn[top[y]])
            swap(x,y);
        ret=max(ret,query(1,dfn[top[x]],dfn[x]));
        x=fa[top[x]];
    }
    if(deep[x]>deep[y])
        swap(x,y);
    ret=max(ret,query(1,dfn[x],dfn[y]));
    return ret;
}
inline int fson(int x,int lca){
    for(int i=tt;i>=0;i--){
        if(deep[dp[x][i]]>deep[lca])
            x=dp[x][i];
    }
    return x;
}
int main(void){
    int T;
    cin>>T;
    int i,j,n,m,q,x,y,u,v,w;
    while(T--){
    scanf("%d",&n);
    tt=(int)(log(n)/log(2))+1;
    for(i=1;i<=n;i++){
        head[i]=0;
        deep[i]=0;
        wson[i]=0;
        fa[i]=0;
    }
    tot=0;
    cnt=0;
    for(i=1;i<n;i++){
        scanf("%d%d%d",&u,&v,&w);
        ed[i].u=u;ed[i].v=v;ed[i].w=w;
        Add(u,v,w);
        Add(v,u,w);
    }
    deep[1]=1;
    dfs1(1,0);
    dfs2(1,1);
    build(1,1,n);
    for(i=1;i<=tt;i++){
        for(j=1;j<=n;j++){
            dp[j][i]=dp[dp[j][i-1]][i-1];
        }
    }
    char s[10];
    while(scanf("%s",s)!=EOF){
        if(s[0]=='C'){
            scanf("%d%d",&x,&y);
            u=ed[x].u;v=ed[x].v;w=ed[x].w;
            ed[x].w=y;
            if(fa[u]!=v)
                swap(u,v);
            modify(u,u,y);
        }
        else if(s[0]=='Q'){
            scanf("%d%d",&x,&y);
            int lca=LCA(x,y);
            //cout<<lca<<" lca\n";
            int ans=0;
            if(x!=lca)
                ans=max(ans,Qsum(fson(x,lca),x));
            if(y!=lca)
                ans=max(ans,Qsum(fson(y,lca),y));
            printf("%d\n",ans);
        }
        else if(s[0]=='D')
            break;
    }
    }
    return 0;
}
赤兔码
关注
专栏目录
树链剖分模板 边权、点权区别
tangzhide123yy的博客
07-29 2461
熟练剖分详解见:https://blog.csdn.net/tangzhide123yy/article/details/77532880 熟练剖分一般有如下几个步骤: 1.dfs1（）求出fa,deep,size,son 2.dfs2（）求出top,p 3.add（）/Query （）树链剖分核心部分 4.updata（）线段树更新操作(如单点修改，区间修改) 5.query（）线段...
树链剖分 模板小记
绫
07-21 144
树链剖分 模板小记树链剖分~模板小记树链剖分 模板小记 Q.Q.Q. 树链剖分的背景？ A.A.A. 连通且无环的树 Q.Q.Q. 树链剖分的作用？ A.A.A. 大幅增加码量 （ A.A.A. 将一棵树变成几条链 树形变成线形 减少处理难度 Q.Q.Q. 树链剖分能处理哪些问题？ A1.A_1.A1​. 修改的有： 将xxx节点+ or×val+~or\times val+ or×val 将xxx到yyy这条路径上所有节点+ or×val+~or\t
树链剖分模板题
qq_44335608的博客
10-03 174
树链剖分的学习，我是从树链剖分-1和树链剖分-2来学会的。 模板题 简单讲一下树链剖分吧，就是它首先第一遍dfs1,就将f[i] ,dep[i] ,sz[i] ,son[i]都预处理好，它们分别代表节点i的父节点，深度，子节点的数量，重节点;第二遍dfs2，就将id[i]，rk[i]，top[i]，分别代表节点i的dfs序，dfs序为i的节点，节点i所在链的顶端节点。如果你有lca和线段树的知识，...
树链剖分——树链剖分模板
fdxgcw的博客
07-25 332
添加链接描述 给定一棵树，树中包含 n 个节点（编号 1∼n），其中第 i 个节点的权值为 ai。 初始时，1 号节点为树的根节点。 现在要对该树进行 m 次操作，操作分为以下 4 种类型： 1 u v k，修改路径上节点权值，将节点 u 和节点 v 之间路径上的所有节点（包括这两个节点）的权值增加 k。 2 u k，修改子树上节点权值，将以节点 u 为根的子树上的所有节点的权值增加 k。 3 u v，询问路径，询问节点 u 和节点 v 之间路径上的所有节点（包括这两个节点）的权值和。 4 u，询问子树，询
树链剖分(一）-重链剖分：模板&例题
Mint_hexagram的博客
02-25 643
重链剖分的模板学习及基础模板练习
【整合】树链剖分模板（线段树维护）
CreationAugust is 14 years old forever
03-05 1234
原题是SDOI2011染色 反正链剖都长得差不多不一样的就是线段树根据题自己在查询和修改里改一改就好了 跟着黄学长学的倍增记录祖先的写法，和网上不太一样求不喷 注释棒棒哒代码又长跑的也不快我也是醉了 注释代码根据题目不同自己修改 #include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<algo
平衡二叉树之Treap树&Splay树
EDGiboy的博客
10-08 637
Treap树就是平衡二叉树，每个点都有两个值，分别是优先级和键值，Treap树满足父节点的优先级大于两个子节点(如果有的话)，而且满足父节点的左子节点的键值小于父节点，右子节点键值大于父节点，所以如果每个节点的优先级已经确定好了的话的话，那么这个Treap树的形态也是确定好的，而优先级这东西是靠随机函数赋值的，所以最坏情况下可能会导致Treap树成为一条链，但是在数学期望下Treap基本是平衡的，...
线段树模板
EDGiboy的博客
08-05 331
单点更新区间查询 struct node{ int l,r,max; }a[MAX_N*4]; int b[MAX_N]; void update(int k){ a[k].max=max(a[k<<1].max,a[k<<1|1].max); } void build(int k,int l,int r){ a[k].l=l;a[k].r=r; if(l==r){...
有向无环图的支配树
EDGiboy的博客
11-16 322
支配树：树上的任何一个点的所有祖先都是在有向无环图中这个点到树根的所有路径的必经点。 有向无环图支配树求法： 由于在有向无环图中可能有很多联通块，所有需要先记录入度，然后从每个入度为0的点开始跑bfs，每个点在支配树上的父亲就是在有向无环图中它的所有父亲的LCA。 有向无环图的支配树模板题 #include<iostream> #include<cstdio> #inclu...
牛客练习赛66 E-骚区间
EDGiboy的博客
06-28 302
骚区间 题意：给一个长度为n的全排列，求有多少个骚区间。骚区间定义，对于[l,r]这个区间满足在这个区间中只有1个数小于al,只有1个数大于ar，那么这个区间就为骚区间。n<=1000000,ai数组为全排列。 思路：明显枚举每个端点作为骚区间的左端点，假设我们枚举ai作为左端点，然后在他右边找到第一个小于ai的数的位置x，然后再在x的右边找第一个小于ai的数的位置y，明显以ai为左端点的骚区间只能在[x,y)这个区间中选择右端点，同理也可以枚举每个数作为右端点，然后找他左边第一个第二个大于ai的数x
李超树
EDGiboy的博客
10-14 299
#include<iostream> #include<cstdio> using namespace std; const int MAX_N=10010; struct line{ double k,b; }a[MAX_N]; int tr[MAX_X]; double f(int id,int x){ return a[id].k*(x-1)+a[id].b; }...
动态主席树
EDGiboy的博客
09-24 279
一般需要离散化 无离散化模板 const int MAX_N=100100; int n,m,num=0,len; int a[MAX_N]; int root[MAX_N],root1[MAX_N],lc[MAX_N],rc[MAX_N],lcnt,rcnt,nn; struct skt{ int l,r,sum; }f[MAX_N*400]; void locate(int l,int r)...
dfs序模板
EDGiboy的博客
09-26 275
列如这个图 seq数组为 1 2 5 3 4 6 7 in数组为1 2 4 5 3 6 7 out数组为7 3 4 3 7 6 7 如果改一个点x的子树上的值，即区间更改seq数组中【in[x]，out[x]】的值。 一般可以存一个pos数组，pos[i]代表i这个数在seq数组的位置，即如果说更改3这个节点的权值，即在线段树中更改pos[3]即4的权值即可，如果更改3的整个子树，那么就是更改区...
Jiu Yuan Wants to Eat 树链剖分和线段树多重标记
EDGiboy的博客
01-20 262
Jiu Yuan Wants to Eat 题意：unsigned long long 型的数，四种操作：操作1树上区间乘以某个数，操作2树上区间加上某个数，操作3树上区间反转，即二进制1变成0，0变成1，操作四求和，由于是unsigned long long，所以变量自动取模。 注意点：线段树多重标记，主要是乘法的lazy标记最好为1，因为在别的题可能为0为1无所谓只要处理好就行，但是这个题只能...
LCA模板
EDGiboy的博客
09-26 259
用vector写的会T,o2优化才过的 改成邻接表应该就不会T了 P3379 【模板】最近公共祖先（LCA） #include<iostream> #include<cstdio> #include<vector> using namespace std; vector<int>edge[501000]; int dp[501000][20],hav...
如果解决区间不重复的数的个数----只维护某个数最后一次出现的位置！！！---E. Messenger Simulator
EDGiboy的博客
01-15 256
E. Messenger Simulator 题意：一开始有一个1到n的数组，然后m个操作，操作输入ai，将ai移动到数组的第一个位置，求在m个操作的过程中每个数的最小位置和最大位置。 思路：首先maxl[i],maxr[i]代表每个数的最小和最大位置，进行初始化，然后遍历一遍操作a数组，然后当第一次碰到一个数时，这个数的maxl即为1，然后maxr即为之前出现过的数中小于这个数的个数+这个数初始...
洛谷P3384树链剖分模板详解与C++实现
本篇笔记主要围绕数据结构中的树链剖分（也称为重链剖分）进行深入讲解。树链剖分是一种将一棵树分解成若干个连续的子树的算法，用于高效地支持查询和修改树中特定路径上的节点值。该技术常用于动态规划和在线问题的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值