[HAOI2015]树上操作

嘟嘟嘟

树剖自然可解，就是一道板子题，而且这道题还只问到根节点的距离是多少，而不是树上任意两点距离，就更方便了。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter printf("
")
#define space printf(" ")
#define Mem(a) memset(a, 0, sizeof(a))
typedef long long ll;
#define int long long
typedef double db;
const int INF = 0x3f3f3f3f;
const int eps = 1e-8;
const int maxn = 1e5 + 5;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), last = ' ';
    while(!isdigit(ch)) {last = ch; ch = getchar();}
    while(isdigit(ch))
    {
        ans = ans * 10 + ch - '0'; ch = getchar();
    }
    if(last == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) x = -x, putchar('-');
    if(x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

int n, m;
ll a[maxn];
vector<int> v[maxn];

bool vis[maxn];
int dep[maxn], fa[maxn], son[maxn], size[maxn];
void dfs1(int now)
{
    size[now] = 1; vis[now] = 1;
    for(int i = 0; i < (int)v[now].size(); ++i)
    {
        if(!vis[v[now][i]])
        {
            dep[v[now][i]] = dep[now] + 1;
            fa[v[now][i]] = now;
            dfs1(v[now][i]);
            size[now] += size[v[now][i]];
            if(!son[now] || size[v[now][i]] > size[son[now]]) son[now] = v[now][i];
        }
    }
}

int dfsx[maxn], pos[maxn], top[maxn], cnt = 0;
void dfs2(int now)
{
    vis[now] = 1; dfsx[now] = ++cnt; pos[cnt] = now;
    if(son[now])
    {
        top[son[now]] = top[now];
        dfs2(son[now]);
    }
    for(int i = 0; i < (int)v[now].size(); ++i)
    {
        if(!vis[v[now][i]] && v[now][i] != son[now])
        {
            top[v[now][i]] = v[now][i];
            dfs2(v[now][i]);
        }
    }
}

int l[maxn << 2], r[maxn << 2];
ll sum[maxn << 2], lazy[maxn << 2];
void build(int L, int R, int now)
{
    l[now] = L; r[now] = R;
    if(L == R) {sum[now] = a[pos[L]]; return;}
    int mid = (L + R) >> 1;
    build(L, mid, now << 1);
    build(mid + 1, R, now << 1 | 1);
    sum[now] = sum[now << 1] + sum[now << 1 | 1];
}
void pushdown(int now)
{
    if(lazy[now])
    {
        lazy[now << 1] += lazy[now];
        lazy[now << 1 | 1] += lazy[now];
        sum[now << 1] += lazy[now] * (r[now << 1] - l[now << 1] + 1);
        sum[now << 1 | 1] += lazy[now] * (r[now << 1 | 1] - l[now << 1 | 1] + 1);
        lazy[now] = 0;
    }
}
void update(int L, int R, int now, int d)
{
    if(l[now] == L && r[now] == R) 
    {
        sum[now] += d * (R - L + 1); 
        lazy[now] += d; return;
    }
    pushdown(now);
    int mid = (l[now] + r[now]) >> 1;
    if(R <= mid) update(L, R, now << 1, d);
    else if(L > mid) update(L, R, now << 1 | 1, d);
    else update(L, mid, now << 1, d), update(mid + 1, R, now << 1 | 1, d);
    sum[now] = sum[now << 1] + sum[now << 1 | 1];
}
ll query(int L, int R, int now)
{
    if(l[now] == L && r[now] == R) return sum[now];
    pushdown(now);
    int mid = (l[now] + r[now]) >> 1;
    if(R <= mid) return query(L, R, now << 1);
    else if(L > mid) return query(L, R, now << 1 | 1);
    else return query(L, mid, now << 1) + query(mid + 1, R, now << 1 | 1);
}

ll query_path(int x)
{
    ll ret = 0;
    while(top[x] != top[1])
    {
        ret += query(dfsx[top[x]], dfsx[x], 1);
        x = fa[top[x]];
    }
    ret += query(dfsx[top[1]], dfsx[x], 1);
    return ret;
}

main()
{
    n = read(); m = read();
    for(int i = 1; i <= n; ++i) a[i] = read();
    for(int i = 1; i < n; ++i)
    {
        int x = read(), y = read();
        v[x].push_back(y); v[y].push_back(x);
    }
    dfs1(1); Mem(vis);
    top[1] = 1; dfs2(1);        //别忘top[1] = 1 
    build(1, cnt, 1);
    for(int i = 1; i <= m; ++i)
    {
        int d = read(), x = read();
        if(d == 1) 
        {
            int c = read();
            update(dfsx[x], dfsx[x], 1, c);
        }
        else if(d == 2)
        {
            int c = read();
            update(dfsx[x], dfsx[x] + size[x] - 1, 1, c);
        }
        else write(query_path(x)), enter;
    }
//    return 0;
}

写完树剖后发现线段树也可以，只要先跑一边dfs序，同时维护每一个点到根节点的路径的权值和，然后修改就是正常的区间修改，因为dfs序满足同一棵子树序号连续。然后单点查询。有兴趣的可以自己写一下~~