[luogu P3384] [模板]树链剖分

[luogu P3384] [模板]树链剖分

题目描述

如题,已知一棵包含N个结点的树(连通且无环),每个节点上包含一个数值,需要支持以下操作:

操作1: 格式: 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z

操作2: 格式: 2 x y 表示求树从x到y结点最短路径上所有节点的值之和

操作3: 格式: 3 x z 表示将以x为根节点的子树内所有节点值都加上z

操作4: 格式: 4 x 表示求以x为根节点的子树内所有节点值之和

输入输出格式

输入格式:

第一行包含4个正整数N、M、R、P,分别表示树的结点个数、操作个数、根节点序号和取模数(即所有的输出结果均对此取模)。

接下来一行包含N个非负整数,分别依次表示各个节点上初始的数值。

接下来N-1行每行包含两个整数x、y,表示点x和点y之间连有一条边(保证无环且连通)

接下来M行每行包含若干个正整数,每行表示一个操作,格式如下:

操作1: 1 x y z

操作2: 2 x y

操作3: 3 x z

操作4: 4 x

输出格式:

输出包含若干行,分别依次表示每个操作2或操作4所得的结果(对P取模)

输入输出样例

输入样例#1:

5 5 2 24
7 3 7 8 0
1 2
1 5
3 1
4 1
3 4 2
3 2 2
4 5
1 5 1 3
2 1 3

输出样例#1:

2
21

说明

时空限制:1s,128M

数据规模:

对于30%的数据: N \leq 10, M \leq 10N≤10,M≤10

对于70%的数据: N \leq {10}^3, M \leq {10}^3N≤10?3??,M≤10?3??

对于100%的数据: N \leq {10}^5, M \leq {10}^5N≤10?5??,M≤10?5??

( 其实,纯随机生成的树LCA+暴力是能过的,可是,你觉得可能是纯随机的么233 )

样例说明:

树的结构如下:

各个操作如下:

故输出应依次为2、21(重要的事情说三遍:记得取模)

树剖模板题啊。。。都快不会打树剖了。

显然,对于这种题目,就要将每一个点根据dfs序映射到线性表上,然后用线段树等维护。

对于1,2操作,就是树剖的基本修改-查询操作;

对于3,4操作,也就是在x的子树里修改查询。那么,一个子树内部的点在dfs序对应的线性表上是连续的,也就可以通过线段树维护了。

ps:树剖都是码农题。。不过打得倒还挺爽。

code:

  1 %:pragma GCC optimize(2)
  2 #include<bits/stdc++.h>
  3 #define mid (((l)+(r))>>1)
  4 #define amod(x,y) (((x)+=(y))%=T)
  5 #define LL long long
  6 #define IL inline
  7 using namespace std;
  8 const int N=200005;
  9 int n,m,r,tot,chain,cloc,lnk[N],nxt[N<<1],son[N<<1];
 10 int dep[N],fa[N],si[N],down[N],top[N],bel[N],idl[N],idr[N];
 11 LL v[N],v0[N],a[N<<2],t[N<<2],T;
 12 IL LL read() {
 13     LL x=0; char ch=getchar();
 14     while (ch<‘0‘|ch>‘9‘) ch=getchar();
 15     while (ch>=‘0‘&&ch<=‘9‘) x=x*10+ch-‘0‘,ch=getchar();
 16     return x;
 17 }
 18 IL void add(int x,int y) {nxt[++tot]=lnk[x],lnk[x]=tot,son[tot]=y;}
 19 IL void dfs(int x,int p) {
 20     dep[x]=dep[p]+1,fa[x]=p,si[x]=1,down[x]=n+1;
 21     for (int j=lnk[x]; j; j=nxt[j]) if (son[j]!=p) {
 22         dfs(son[j],x),si[x]+=si[son[j]];
 23         down[x]=(si[down[x]]<si[son[j]])?son[j]:down[x];
 24     }
 25 }
 26 IL void pre(int x,int p) {
 27     idl[x]=++cloc;
 28     if (down[x]!=n+1) top[down[x]]=top[x],bel[down[x]]=bel[x],pre(down[x],x);
 29     for (int j=lnk[x]; j; j=nxt[j]) if (son[j]!=p&&son[j]!=down[x]) {
 30         top[son[j]]=son[j],bel[son[j]]=++chain,pre(son[j],x);
 31     }
 32     idr[x]=cloc;
 33 }
 34 IL LL am(LL x,LL y) {return (x+y)%T;}
 35 IL void pushU(int c) {a[c]=am(a[c<<1],a[c<<1|1]);}
 36 IL void pushD(int c,int l,int r) {
 37     amod(t[c<<1],t[c]);
 38     amod(t[c<<1|1],t[c]);
 39     amod(a[c<<1],t[c]*(LL)(mid-l+1));
 40     amod(a[c<<1|1],t[c]*(LL)(r-mid));
 41     t[c]=0;
 42 }
 43 IL void B(int c,int l,int r) {
 44     if (l==r) {a[c]=v0[l]%T; return;}
 45     B(c<<1,l,mid),B(c<<1|1,mid+1,r);
 46     pushU(c);
 47 }
 48 IL void U(int c,int l,int r,LL v,int liml,int limr) {
 49     if (l>=liml&&r<=limr) {amod(t[c],v),amod(a[c],(LL)v*(r-l+1)),pushD(c,l,r); return;}
 50     pushD(c,l,r);
 51     if (limr<=mid) U(c<<1,l,mid,v,liml,limr);
 52     else if (liml>mid) U(c<<1|1,mid+1,r,v,liml,limr);
 53     else U(c<<1,l,mid,v,liml,mid),U(c<<1|1,mid+1,r,v,mid+1,limr);
 54     pushU(c);
 55 }
 56 IL LL A(int c,int l,int r,int liml,int limr) {
 57     if (l>=liml&&r<=limr) return a[c]%T;
 58     pushD(c,l,r); LL ret=0;
 59     if (limr<=mid) amod(ret,A(c<<1,l,mid,liml,limr));
 60     else if (liml>mid) amod(ret,A(c<<1|1,mid+1,r,liml,limr));
 61     else amod(ret,A(c<<1,l,mid,liml,mid)),amod(ret,A(c<<1|1,mid+1,r,mid+1,limr));
 62     pushU(c); return ret%T;
 63 }
 64 IL void chain_U(int x,int y,LL v) {
 65     while (bel[x]!=bel[y]) {
 66         if (dep[top[x]]>dep[top[y]]) U(1,1,n,v,idl[top[x]],idl[x]),x=fa[top[x]];
 67         else U(1,1,n,v,idl[top[y]],idl[y]),y=fa[top[y]];
 68     }
 69     if (dep[x]>dep[y]) swap(x,y);
 70     U(1,1,n,v,idl[x],idl[y]);
 71 }
 72 IL LL chain_A(int x,int y) {
 73     LL ret=0;
 74     while (bel[x]!=bel[y]) {
 75         if (dep[top[x]]>dep[top[y]]) amod(ret,A(1,1,n,idl[top[x]],idl[x])),x=fa[top[x]];
 76         else amod(ret,A(1,1,n,idl[top[y]],idl[y])),y=fa[top[y]];
 77     }
 78     if (dep[x]>dep[y]) swap(x,y);
 79     amod(ret,A(1,1,n,idl[x],idl[y]));
 80     return ret%T;
 81 }
 82 IL void tree_U(int x,LL v) {U(1,1,n,v,idl[x],idr[x]);}
 83 IL LL tree_A(int x) {return A(1,1,n,idl[x],idr[x])%T;}
 84 int main() {
 85     n=read(),m=read(),r=read(),T=read();
 86     for (int i=1; i<=n; i++) v[i]=read();
 87     for (int i=1,x,y; i<n; i++) x=read(),y=read(),add(x,y),add(y,x);
 88     dep[0]=0,si[n+1]=0,dfs(r,0),pre(r,0);
 89     for (int i=1; i<=n; i++) v0[idl[i]]=v[i];
 90     B(1,1,n);
 91     for (int o,x,y,z; m; m--) {
 92         o=read(),x=read(),y=(o<3)?read():0,z=(o&1)?read():0;
 93         switch (o) {
 94             case 1:chain_U(x,y,(LL)z%T); break;
 95             case 2:printf("%lld\n",chain_A(x,y)%T); break;
 96             case 3:tree_U(x,(LL)z%T); break;
 97             case 4:printf("%lld\n",tree_A(x)%T); break;
 98         }
 99     }
100     return 0;
101 }

时间: 2024-10-07 18:24:17

[luogu P3384] [模板]树链剖分的相关文章

【Luogu P3384】树链剖分模板

树链剖分的基本思想是把一棵树剖分成若干条链,再利用线段树等数据结构维护相关数据,可以非常暴力优雅地解决很多问题. 树链剖分中的几个基本概念: 重儿子:对于当前节点的所有儿子中,子树大小最大的一个儿子就是重儿子(子树大小相同的则随意取一个) 轻儿子:不是重儿子就是轻儿子 重边:连接父节点和重儿子的边 轻边:连接父节点和轻儿子的边 重链:相邻重边相连形成的链 值得注意的还有以下几点: 叶子节点没有重儿子也没有轻儿子: 对于每一条重链,其起点必然是轻儿子: 单独一个轻叶子节点也是一条重链: 结合上面三

luoguP3384 [模板]树链剖分

luogu P3384 [模板]树链剖分 题目 #include<iostream> #include<cstdlib> #include<cstdio> #include<cmath> #include<cstring> #include<iomanip> #include<algorithm> #include<ctime> #include<queue> #define rg register

[模板]树链剖分

原题链接:https://www.luogu.org/problemnew/show/P3384 树链剖分+线段树,备用. 等待补充详细解释中. /* 1 x y z x到y最短路径上加上z 2 x y 求x到y的最短路径上的节点值之和 3 x z 以x为根节点的子树内的所有节点值都加上z 4 x 以x为根节点的所有节点值之和 */ #include<cstdio> void read(int &y) { y=0;char x=getchar();int f=1; while(x<

模板 树链剖分BFS版本

//点和线段树都从1开始 //边使用vector vector<int> G[maxn]; int dfs_clock,que[maxn*2],num[maxn],iii[maxn],b[maxn],a[maxn],top[maxn],deep[maxn],fa[maxn],idx[maxn]; //采用静态链表 //a[i] 是初始时树上每个点的权值 //b[i] 是经过bfs后每个点的权值 //idx[i] 是每个点在全局线段树中的下标 void build_List() { int ft

模板——树链剖分

放个板子而已.. #include<stdio.h> #include<algorithm> #define ls root<<1 #define rs root<<1|1 using namespace std; typedef long long ll; int n,m,r;ll res,p; const int MAXN = 100005; ll a[MAXN]; struct edge{ int v,nxt; }e[MAXN<<1]; s

[模板] 树链剖分找LCA

#include <cstdio> #include <cstring> #define MAX 500005 int d[MAX],fa[MAX],size[MAX],top[MAX],son[MAX]; int N,M,S,tot=0; int head[MAX]; struct edge{ int v,next; }G[MAX<<1]; inline void add(int u,int v){ G[++tot].v=v;G[tot].next=head[u];h

树链剖分[模板](洛谷 P3384)

洛谷·[模板]树链剖分 写在前面 首先,在学树链剖分之前最好先把 LCA.树形DP.DFS序 这三个知识点学了 如果这三个知识点没掌握好的话,树链剖分难以理解也是当然的. 树链剖分 树链剖分 就是对一棵树分成几条链,把树形变为线性,减少处理难度 概念 dfs1() dfs2() 对剖过后的树建线段树 处理问题 概念 重儿子:对于每一个非叶子节点,它的儿子中 儿子数量最多的那一个儿子 为该节点的重儿子 轻儿子:对于每一个非叶子节点,它的儿子中 非重儿子 的剩下所有儿子即为轻儿子 叶子节点没有重儿子

Hdu5044Tree 树链剖分

输入输出挂,扩栈挂,模板树链剖分. #include<iostream> #include<cstdio> #include<cstring> #include<map> #include<vector> #include<stdlib.h> #include<algorithm> using namespace std; const int maxn = 111111; struct Node { int next; i

Luogu P3384 【模板】树链剖分

传送门~ 树链剖分,顾名思义,就是把树分成链. 通过这个方法,可以优化对树上两点间路径.某一点子树的修改和查询的操作,等. 流程 $dfs1()$ 在这个函数中,要处理出每个节点的: 深度dep[] 父亲fa[] 大小siz[] 重儿子编号hson[] 一个节点的siz[],是包括它自己.它的儿子.它儿子的儿子……一共的节点数量. 所谓的重儿子,就是一个节点的儿子中,siz[]最大的那一个. 叶子节点没有儿子,所以也没有重儿子. 这个函数就是普通的遍历整棵树,每到一个点记录dpth[],siz[