luogu P3178 [HAOI2015]树上操作

题目

题目描述

有一棵点数为 N 的树，以点 1 为根，且树点有边权。然后有 M 个操作，分为三种：

• 操作 1 ：把某个节点 x 的点权增加 a 。
• 操作 2 ：把某个节点 x 为根的子树中所有点的点权都增加 a 。
• 操作 3 ：询问某个节点 x 到根的路径中所有点的点权和。

输入格式

第一行包含两个整数 N, M 。表示点数和操作数。
接下来一行 N 个整数，表示树中节点的初始权值。
接下来 N-1 行每行两个正整数 from, to ， 表示该树中存在一条边 (from, to) 。
再接下来 M 行，每行分别表示一次操作。其中第一个数表示该操作的种类（ 1-3 ） ，之后接这个操作的参数（ x 或者 x a ） 。

输出格式

对于每个询问操作，输出该询问的答案。答案之间用换行隔开。

输入输出样例

输入 #1复制

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

输出 #1复制

6
9
13

说明/提示

对于 100% 的数据， N,M<=100000 ，且所有输入数据的绝对值都不会超过 10^6 。

 

分析

 

• 首先，我们要知道dfs序
• 就是一颗树进出栈的顺序
• 然后我们记录下他们的时间戳
• 就知道他们的左右子树在哪个区间
• 然后用线段树维护
• 还有一个重要的点是
• 我们可以发现1-x点就是x进栈的前缀
• 考虑如何维护线段树
• 首先我们是有x和-x的，我们要一个前缀数组搞出区间正x的个数
• 对于第一个修改x+=x -x+=-x就好了
• 然后主要区间加一定打lazy
• lazy的return 是如果数在区间里面的
• 然后还有

  if (a<=mid) ans+=find(k<<1,a,b);
  if (b>=mid+1) ans+=find(k<<1|1,a,b); 别忘了

 

代码

#include<iostream>
#include<cstdio>
#define ll long long
using namespace std;
ll a[500001];
struct sb
{
    ll l,r,sum,bz,add;
}t[2*200001];
ll id[500001],num,le[500001],ri[500001],vis[500001],ss[500001];
struct node
{
    ll to,nx;
}g[2*200010];
ll list[2*200010],cnt;
void add(ll x,ll y)
{
    g[++cnt].to=y; g[cnt].nx=list[x]; list[x]=cnt;
    g[++cnt].to=x; g[cnt].nx=list[y]; list[y]=cnt;
}
ll val[500001],v,flag[500001];
inline ll read(){
    ll x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}
void dfs(ll x)
{
    vis[x]=1;
    id[x]=++num;
    val[num]=a[x];
    flag[num]=1;
    le[x]=num;
    for (int i=list[x];i;i=g[i].nx)
    {
        ll y=g[i].to;
        if (!vis[y])
            dfs(y);
    }
    ri[x]=++num;
    val[num]=-a[x];
    flag[num]=-1;
}
void build(ll k,ll a,ll b)
{
    t[k].l=a; t[k].r=b;
    if (a==b)
    {
        t[k].sum=val[a];
        t[k].bz=flag[a];
        return;
    }
    ll mid=a+b>>1;
    build(k<<1,a,mid);
    build(k<<1|1,mid+1,b);
    t[k].sum=t[k<<1].sum+t[k<<1|1].sum;
    t[k].bz=t[k<<1].bz+t[k<<1|1].bz;
}
void change(ll k,ll mb,ll z)
{
    t[k].sum+=z; 
    if (t[k].l==t[k].r) return;
    ll mid=t[k].l+t[k].r>>1;
    if (mb<=mid) change(k<<1,mb,z);
    else change(k<<1|1,mb,z);
}
void lazy(ll k,ll a,ll b,ll m)
{
    if (t[k].add!=0)
    {
        t[k<<1].add+=t[k].add;
        t[k<<1|1].add+=t[k].add;
        t[k<<1].sum=t[k<<1].sum+t[k].add*(ss[m]-ss[a-1]);
        t[k<<1|1].sum=t[k<<1|1].sum+t[k].add*(ss[b]-ss[m]);
        t[k].add=0;
    }
}
void change2(ll k,ll a,ll b,ll z)
{
    if (a<=t[k].l&&b>=t[k].r)
    {
        t[k].add+=z;
        t[k].sum=t[k].sum+z*(ss[t[k].r]-ss[t[k].l-1]);
        return;
    }
    ll mid=(t[k].l+t[k].r)>>1;
    lazy(k,t[k].l,t[k].r,mid);
    if (a<=mid) change2(k<<1,a,b,z);
    if (b>=mid+1) change2(k<<1|1,a,b,z);
    t[k].sum=t[k<<1].sum+t[k<<1|1].sum;
}
ll find(ll k,ll a,ll b)
{
    if (t[k].l>=a&&t[k].r<=b)
      return t[k].sum;
    ll mid=t[k].l+t[k].r>>1;
    ll ans=0; 
    lazy(k,t[k].l,t[k].r,mid);
    if (a<=mid) ans+=find(k<<1,a,b);
    if (b>=mid+1) ans+=find(k<<1|1,a,b);
    return ans; 
}
int main ()
{
    ll n,m;
    n=read(); m=read();
    for (int i=1;i<=n;i++)
      a[i]=read();
    for (int i=1,x,y;i<=n-1;i++)
    {
        x=read(); y=read();
        add(x,y);
    }
    dfs(1);
    for (int i=1;i<=num;i++)
      ss[i]=ss[i-1]+flag[i];
    build(1,1,2*n);
    for (int i=1,op,x,y;i<=m;i++)
    {
        op=read();
        if (op==1)
        {
            x=read(); y=read();
            change(1,le[x],y);
            change(1,ri[x],-y);
        }
        if (op==2)
        {
            x=read(); y=read();
            change2(1,le[x],ri[x],y);
        }
        if (op==3)
        {
            x=read();
            printf("%lld\n",find(1,1,le[x]));
        }
    }
}