bzoj3786

splay维护dfs序

我们发现有移动子树这种操作，树剖是做不了了，又要实现子树加，lct又维护不了了，这时我们用splay维护入栈出栈序来支持这些操作。我们记录每个点的入栈时间和出栈时间，这样一个闭合的区间就表示了一个节点的子树，于是我们可以支持更换父亲了。然后是子树加，这里我们把要加的区间提取出来，打标记，但是我们还得维护一个符号总和，因为入栈时间加，出栈时间要减去加的值，因为出栈时间之后得序列就不属于这棵子树了。最后是查询，查询我们只要把查询节点的入栈时间和1号节点提取出来，然后总和就是答案。注意提取区间时不是in[x]-1,out[x]+1,虽然这里节点编号就是对应排名，但是因为这里是出栈入栈序，所以+1-1不一定是序列中下一个节点，所以我们要查询前继后继，也就是提取pre(in[x])和nxt(out[x])

然后还卡时间，我用fread卡过去了

#include<bits/stdc++.h>
using namespace std;
const int N = , Maxlen =  * N;
int n, m, dfs_clock = , root;
int in[N], out[N];
long long w[N];
vector<int> G[N];
char buf[Maxlen], *C = buf;
int Len;
inline int read()
{
     int x = ;
     while (*C < '' || '' < *C) ++C;
     while ('' <= *C && *C <= '') x = x *  + *C - '', ++C;
     return x;
}
namespace Splay_tree
{
    int cnt;
    int child[N][], fa[N], st[N];
    long long sum[N], key[N], tag[N], tim[N], sum_tim[N];
    inline bool wh(int x)
    {
        return child[fa[x]][] == x;
    }
    inline void update(int x)
    {
        sum[x] = sum[child[x][]] + sum[child[x][]] + key[x];
        sum_tim[x] = sum_tim[child[x][]] + sum_tim[child[x][]] + tim[x];
    }
    inline void pushdown(int x)
    {
        if(tag[x] == ) return;
        tag[child[x][]] += tag[x];
        tag[child[x][]] += tag[x];
        key[child[x][]] += tag[x] * tim[child[x][]];
        key[child[x][]] += tag[x] * tim[child[x][]];
        sum[child[x][]] += tag[x] * sum_tim[child[x][]];
        sum[child[x][]] += tag[x] * sum_tim[child[x][]];
        tag[x] = ;
    }
    inline void rotate(int x)
    {
        int y = fa[x], z = fa[y], t = wh(x);
        fa[x] = z;
        child[z][wh(y)] = x;
        child[y][t] = child[x][t ^ ];
        fa[child[x][t ^ ]] = y;
        child[x][t ^ ] = y;
        fa[y] = x;
        update(y);
        update(x);
    }
    inline void up(int x)
    {
        int top = , now = x;
        while(now != root)
        {
            st[++top] = now;
            now = fa[now];
        }
        st[++top] = root;
        for(int i = top; i; --i) pushdown(st[i]);
    }
    inline void splay(int x, int t)
    {
        up(x);
        for(int f; (f = fa[x]) != t; rotate(x))
            if(fa[f] != t) rotate(wh(x) == wh(f) ? f : x);
        if(!t) root = x;
    }
    inline void build(int l, int r, int &x, int last)
    {
        if(l > r) return;
        int mid = (l + r) >> ;
        x = mid;
        fa[x] = last;
        build(l, mid - , child[x][], x);
        build(mid + , r, child[x][], x);
        update(x);
    }
    inline int pre(int x)
    {
        splay(x, );
        x = child[x][];
        while(child[x][]) x = child[x][];
        return x;
    }
    inline int nxt(int x)
    {
        splay(x, );
        x = child[x][];
        while(child[x][]) x = child[x][];
        return x;
    }
    inline void change(int x, int y)
    {
        int a = pre(in[x]), b = nxt(out[x]);
        splay(a, );
        splay(b, root);
        int t = child[child[root][]][];
        fa[t] = child[child[root][]][] = ;
        update(child[root][]);
        update(root);
        a = nxt(in[y]);
        splay(in[y], );
        splay(a, root);
        fa[t] = child[root][];
        child[child[root][]][] = t;
        update(child[root][]);
        update(root);
    }
    inline void ask(int x)
    {
        x = nxt(in[x]);
        splay(, );
        splay(x, root);
        int t = child[child[root][]][];
        printf("%lld\n", sum[t]);
    }
    inline void add(int x, int delta)
    {
        int a = pre(in[x]), b = nxt(out[x]);
        splay(a, );
        splay(b, root);
        int t = child[child[root][]][];
        tag[t] += delta;
        sum[t] += delta * sum_tim[t];
        key[t] += delta * tim[t];
    }
} using namespace Splay_tree;
void dfs(int u)
{
    in[u] = ++dfs_clock;
    tim[in[u]] = ;
    key[in[u]] = w[u];
    for(int i = ; i < G[u].size(); ++i)
    {
        int v = G[u][i];
        dfs(v);
    }
    out[u] = ++dfs_clock;
    key[out[u]] = -w[u];
    tim[out[u]] = -;
}
int main()
{
//    freopen("galaxy20.in", "r", stdin);
//    freopen("output.txt", "w", stdout);
    Len = fread(C, , Maxlen, stdin);
    buf[Len] = '\0';
    n = read();
    for(int i = ; i <= n; ++i)
    {
        int u = read();
        G[u].push_back(i);
    }
    for(int i = ; i <= n; ++i) w[i] = read();
    dfs();
    ++dfs_clock;
    build(, dfs_clock, root, );
    m = read();
    while(m--)
    {
        char c;
        int x, y;
        for(c = *C; c < 'A' || c > 'Z'; ++C, c = *C);
        if(c == 'Q')
        {
            x = read();
            ask(x);
        }
        if(c == 'C')
        {
            x = read();
            y = read();
            change(x, y);
        }
        if(c == 'F')
        {
            x = read();
            y = read();
            add(x, y);
        }
    }
//    fclose(stdin);
//    fclose(stdout);
    return ;
}