【HAOI 2015】 树上操作

【题目链接】

点击打开链接

【算法】

树链剖分

子树的DFS序是连续的一段！

【代码】

#include<bits/stdc++.h>
using namespace std;
#define MAXN 100010

struct Edge
{
        int to,nxt;
} e[MAXN*];

int i,opt,n,m,q,x,y,val,tot,timer;
int dfn[MAXN],pos[MAXN],head[MAXN],size[MAXN],
        son[MAXN],top[MAXN],fa[MAXN],dep[MAXN];
long long a[MAXN];

template <typename T> inline void read(T &x)
{
    long long f = ; x = ;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }
    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
    x *= f;
}
template <typename T> inline void write(T x)
{
    if (x < )
    {
        putchar('-');
        x = -x;
    }
    if (x > ) write(x/);
    putchar(x%+'');
}
template <typename T> inline void writeln(T x)
{
    write(x);
    puts("");
}

struct SegmentTree
{
        struct Node
        {
                int l,r;
                long long sum,tag;
        } Tree[MAXN*];
        inline void update(int index)
        {
                Tree[index].sum = Tree[index<<].sum + Tree[index<<|].sum;
        }
        inline void pushdown(int index)
        {
                int l = Tree[index].l,r = Tree[index].r;
                int mid = (l + r) >> ;
                if (Tree[index].tag)
                {
                        Tree[index<<].sum += Tree[index].tag * (mid - l + );
                        Tree[index<<|].sum += Tree[index].tag * (r - mid);
                        Tree[index<<].tag += Tree[index].tag;
                        Tree[index<<|].tag += Tree[index].tag;
                        Tree[index].tag = ;
                }
        }
        inline void build(int index,int l,int r)
        {
                int mid;
                Tree[index].l = l;
                Tree[index].r = r;
                if (l == r)
                {
                        Tree[index].sum = a[pos[l]];
                        return;
                }
                mid = (l + r) >> ;
                build(index<<,l,mid);
                build(index<<|,mid+,r);
                update(index);
        }
        inline void add1(int index,int pos,long long val)
        {
                int mid;
                if (Tree[index].l == Tree[index].r)
                {
                        Tree[index].sum += val;
                        return;
                }
                pushdown(index);
                mid = (Tree[index].l + Tree[index].r) >> ;
                if (mid >= pos) add1(index<<,pos,val);
                else add1(index<<|,pos,val);
                update(index);
        }
        inline void add2(int index,int l,int r,long long val)
        {
                int mid;
                if (Tree[index].l == l && Tree[index].r == r)
                {
                        Tree[index].sum += val * (r - l + );
                        Tree[index].tag += val;
                        return;
                }
                pushdown(index);
                mid = (Tree[index].l + Tree[index].r) >> ;
                if (mid >= r) add2(index<<,l,r,val);
                else if (mid +  <= l) add2(index<<|,l,r,val);
                else
                {
                        add2(index<<,l,mid,val);
                        add2(index<<|,mid+,r,val);
                }
                update(index);
        }
        inline long long query(int index,int l,int r)
        {
                int mid;
                if (Tree[index].l == l && Tree[index].r == r) return Tree[index].sum;
                pushdown(index);
                mid = (Tree[index].l + Tree[index].r) >> ;
                if (mid >= r) return query(index<<,l,r);
                else if (mid +  <= l) return query(index<<|,l,r);
                else return query(index<<,l,mid) + query(index<<|,mid+,r);
        }
} T;

inline void add(int u,int v)
{
        tot++;
        e[tot] = (Edge){v,head[u]};
        head[u] = tot;
}
inline void dfs1(int x)
{
        int i,y;
        size[x] = ;
        for (i = head[x]; i; i = e[i].nxt)
        {
                y = e[i].to;
                if (fa[x] != y)
                {
                        fa[y] = x;
                        dep[y] = dep[x] + ;
                        dfs1(y);
                        size[x] += size[y];
                        if (size[y] > size[son[x]]) son[x] = y;
                }
        }
}
inline void dfs2(int x,int tp)
{
        int i,y;
        top[x] = tp;
        dfn[x] = ++timer;
        pos[timer] = x;
        if (son[x]) dfs2(son[x],tp);
        for (i = head[x]; i; i = e[i].nxt)
        {
                y = e[i].to;
                if (fa[x] != y && son[x] != y) dfs2(y,y);
        }
}
inline long long query(int x)
{
        long long ans = ;
        int tx = top[x];
        while (tx != )
        {
                ans += T.query(,dfn[tx],dfn[x]);
                x = fa[tx]; tx = top[x];
        }
        ans += T.query(,,dfn[x]);
        return ans;
}

int main() {

        read(n); read(q);
        for (i = ; i <= n; i++) read(a[i]);
        for (i = ; i < n; i++)
        {
                read(x); read(y);
                add(x,y);
                add(y,x);
        }
        dfs1();
        dfs2(,);

        T.build(,,timer);
        while (q--)
        {
                read(opt);
                if (opt == )
                {
                        read(x); read(val);
                        T.add1(,dfn[x],val);
                }
                if (opt == )
                {
                        read(x); read(val);
                        T.add2(,dfn[x],dfn[x]+size[x]-,val);
                }
                if (opt == )
                {
                        read(x);
                        writeln(query(x));
                }
        }

        return ;

}