Tsinsen A1517. 动态树 树链剖分,线段树,子树操作

题目 : http://www.tsinsen.com/A1517

A1517. 动态树

时间限制：3.0s   内存限制：1.0GB   

总提交次数：227   AC次数：67   平均分：49.52

 

将本题分享到：

      

查看未格式化的试题   提交   试题讨论

试题来源

　　中国国家队清华集训 2013-2014 第四天

问题描述

　　小明在楼下种了一棵动态树, 该树每天会在某些节点上长出一些果子. 这棵树的根节点为1, 它有n个节点, n-1条边.

　　别忘了这是一棵动态树, 每时每刻都是动态的. 小明要求你在这棵树上维护两种事件

　　事件0:
　　这棵树长出了一些果子, 即某个子树中的每个节点都会长出K个果子.

　　事件1:
　　小明希望你求出几条树枝上的果子数. 一条树枝其实就是一个从某个节点到根的路径的一段. 每次小明会选定一些树枝, 让你求出在这些树枝上的节点的果子数的和. 注意, 树枝之间可能会重合, 这时重合的部分的节点的果子只要算一次.

　　初始时, 每个节点上都没有果子.

输入格式

　　第一行一个整数n(1<=n<=200,000), 即节点数.
　　接下来n-1行, 每行两个数字u, v. 表示果子u和果子v之间有一条直接的边. 节点从1开始编号.
　　在接下来一个整数nQ(1<=nQ<=200,000), 表示事件.
　　最后nQ行, 每行开头要么是0, 要么是1.
　　如果是0, 表示这个事件是事件0. 这行接下来的2个整数u, delta表示以u为根的子树中的每个节点长出了delta个果子.
　　如果是1, 表示这个事件是事件1. 这行接下来一个整数K(1<=K<=5), 表示这次询问涉及K个树枝. 接下来K对整数u_k, v_k, 每个树枝从节点u_k到节点v_k. 由于果子数可能非常多, 请输出这个数模2^31的结果.

输出格式

　　对于每个事件1, 输出询问的果子数.

样例输入

5
1 2
2 3
2 4
1 5
3
0 1 1
0 2 3
1 2 3 1 1 4

样例输出

13

数据规模和约定

　　对于测试点1, 有1 <= n <= 2,000, 1 <= nQ <= 2,000, K <=5
　　对于测试点{2, 3}, 有1 <= n <= 100,000, 1 <= nQ <= 100,000, K = 1
　　对于测试点{4, 5}, 有1 <= n <= 100,000, 1 <= nQ <= 100,000, K <= 2
　　对于测试点{6, 7}, 有1 <= n <= 100,000, 1 <= nQ <= 100,000, K <= 3
　　对于测试点{8, 9, 10}, 有1 <= n <= 200,000, 1 <= nQ <= 200,000, K = 5.
　　同一组类型的数据有梯度.

　　生成每个树枝的过程是这样的:先在树中随机找一个节点, 然后在这个节点到根的路径上随机选一个节点, 这两个节点就作为树枝的两端.

 

提交   试题讨论

 

题解：

树链剖分＋线段树＋子树操作

修改时将链上的点打标记（注意：初始时这个标记要赋为 -1 ，不能赋为 0 ，因为 0 在之后的操作中要用。）然后查询时，将链上的标记的值相加，边加边取余。（好像可以自然溢出，因为给的数为2^31）

每次询问完要将标记清空。

 #include<bits/stdc++.h>
 using namespace std;
 #define MOD 2147483648LL
 #define MAXN 200010
 #define LL long long
 struct NODE
 {
     int begin,end,next;
 }edge[MAXN*];
 struct node
 {
     int left,right;
     LL sum,tag,tag1,prey;
 }tree[MAXN*];
 int cnt,Head[MAXN],n,deep[MAXN],size[MAXN],P[MAXN][],pos[MAXN],belong[MAXN],ks[MAXN],js[MAXN],SIZE;
 bool vis[MAXN];
 void addedge(int bb,int ee)
 {
     edge[++cnt].begin=bb;edge[cnt].end=ee;edge[cnt].next=Head[bb];Head[bb]=cnt;
 }
 void addedge1(int bb,int ee)
 {
     addedge(bb,ee);addedge(ee,bb);
 }
 int read()
 {
     int s=,fh=;char ch=getchar();
     while(ch<''||ch>''){if(ch=='-')fh=-;ch=getchar();}
     while(ch>=''&&ch<=''){s=s*+(ch-'');ch=getchar();}
     return s*fh;
 }
 void dfs1(int u)
 {
     int i,v;
     size[u]=;vis[u]=true;
     for(i=Head[u];i!=-;i=edge[i].next)
     {
         v=edge[i].end;
         if(vis[v]==false)
         {
             deep[v]=deep[u]+;
             P[v][]=u;
             dfs1(v);
             size[u]+=size[v];
         }
     }
 }
 void Ycl()
 {
     int i,j;
     for(j=;(<<j)<=n;j++)
     {
         for(i=;i<=n;i++)
         {
             if(P[i][j-]!=-)P[i][j]=P[P[i][j-]][j-];
         }
     }
 }
 void dfs2(int u,int chain)
 {
     int k=,i,v;
     pos[u]=++SIZE;belong[u]=chain;ks[u]=SIZE;
     for(i=Head[u];i!=-;i=edge[i].next)
     {
         v=edge[i].end;
         if(deep[v]>deep[u]&&size[v]>size[k])k=v;
     }
     if(k==){js[u]=SIZE;return;}
     dfs2(k,chain);
     for(i=Head[u];i!=-;i=edge[i].next)
     {
         v=edge[i].end;
         if(deep[v]>deep[u]&&v!=k)dfs2(v,v);
     }
     js[u]=SIZE;
 }
 void Pushup(int k)
 {
     tree[k].sum=(tree[k*].sum+tree[k*+].sum)%MOD;
     tree[k].prey=(tree[k*].prey+tree[k*+].prey)%MOD;
 }
 void Build(int k,int l,int r)
 {
     tree[k].left=l;tree[k].right=r;tree[k].tag=-;/*一定要赋为-1*/tree[k].tag1=0LL;tree[k].sum=0LL;
     if(l==r)return;
     int mid=(l+r)/;
     Build(k*,l,mid);Build(k*+,mid+,r);
     Pushup(k);
 }
 void Update(int k,int k1)
 {
     tree[k].tag=(LL)k1;
     tree[k].prey=(tree[k].sum*(LL)k1)%MOD;
 }
 void Update1(int k,int k1)
 {
     tree[k].tag1=(tree[k].tag1+(LL)k1)%MOD;
     tree[k].sum=(tree[k].sum+((LL)tree[k].right-(LL)tree[k].left+1LL)*(LL)k1)%MOD;
 }
 void Pushdown(int k)
 {
     int l=k*,r=k*+;
     if(tree[k].tag1!=0LL)
     {
         Update1(l,tree[k].tag1);
         Update1(r,tree[k].tag1);
         tree[k].tag1=0LL;
     }
     if(tree[k].tag!=-)
     {
         Update(l,tree[k].tag);
         Update(r,tree[k].tag);
         tree[k].tag=-;
     }
 }
 void Add(int k,int l,int r,int A)
 {
     if(l==tree[k].left&&tree[k].right==r){Update1(k,A);return;}
     int mid=(tree[k].left+tree[k].right)/;
     Pushdown(k);
     if(r<=mid)Add(k*,l,r,A);
     else if(l>mid)Add(k*+,l,r,A);
     else {Add(k*,l,mid,A);Add(k*+,mid+,r,A);}
     Pushup(k);
 }
 void Change(int k,int l,int r,int C)
 {
     if(tree[k].tag==C)return;
     if(l==tree[k].left&&tree[k].right==r){Update(k,C);return;}
     int mid=(tree[k].left+tree[k].right)/;
     Pushdown(k);
     if(r<=mid)Change(k*,l,r,C);
     else if(l>mid)Change(k*+,l,r,C);
     else {Change(k*,l,mid,C);Change(k*+,mid+,r,C);}
     Pushup(k);
 }
 void Solve_change(int x,int fa,int C)
 {
     while(belong[x]!=belong[fa])
     {
         //if(deep[belong[x]]<deep[belong[fa]])swap(x,fa);
         Change(,pos[belong[x]],pos[x],C);
         x=P[belong[x]][];
     }
     //if(deep[x]<deep[fa])swap(x,fa);
     Change(,pos[fa],pos[x],C);
 }
 int main()
 {
     int bb,ee,Q,i,zs,s1,s2,s3,j;
     n=read();
     memset(Head,-,sizeof(Head));cnt=;
     for(i=;i<n;i++){bb=read();ee=read();addedge1(bb,ee);}
     memset(P,-,sizeof(P));SIZE=;
     dfs1();Ycl();
     dfs2(,);
     Q=read();
     Build(,,n);
     for(i=;i<=Q;i++)
     {
         zs=read();
         if(zs==){s1=read();s2=read();Add(,ks[s1],js[s1],s2);}
         else
         {
             s1=read();
             for(j=;j<=s1;j++)
             {
                 s2=read();s3=read();
                 if(deep[s2]<deep[s3])swap(s2,s3);
                 Solve_change(s2,s3,);
                 //printf("%d\n",tree[1].prey);
                 //Update(1,0);
             }
             printf("%lld\n",tree[].prey%MOD);
             Update(,);
         }
     }
     fclose(stdin);
     fclose(stdout);
     return ;
 }