[BZOJ3786]星系探索(伪ETT)

3786: 星系探索

Time Limit: 40 Sec  Memory Limit: 256 MB
Submit: 1638  Solved: 506
[Submit][Status][Discuss]

Description

物理学家小C的研究正遇到某个瓶颈。

他正在研究的是一个星系，这个星系中有n个星球，其中有一个主星球(方便起见我们默认其为1号星球)，其余的所有星球均有且仅有一个依赖星球。主星球没有依赖星球。

我们定义依赖关系如下：若星球a的依赖星球是b,则有星球a依赖星球b.此外，依赖关系具有传递性，即若星球a依赖星球b,星球b依赖星球c,则有星球a依赖星球c.

对于这个神秘的星系中，小C初步探究了它的性质，发现星球之间的依赖关系是无环的。并且从星球a出发只能直接到达它的依赖星球b.

每个星球i都有一个能量系数wi.小C想进行若干次实验，第i次实验，他将从飞船上向星球di发射一个初始能量为0的能量收集器，能量收集器会从星球di开始前往主星球，并收集沿途每个星球的部分能量，收集能量的多少等于这个星球的能量系数。

但是星系的构成并不是一成不变的，某些时刻，星系可能由于某些复杂的原因发生变化。

有些时刻，某个星球能量激发，将使得所有依赖于它的星球以及他自己的能量系数均增加一个定值。还有可能在某些时刻，某个星球的依赖星球会发生变化，但变化后依然满足依赖关系是无环的。

现在小C已经测定了时刻0时每个星球的能量系数,以及每个星球(除了主星球之外)的依赖星球。接下来的m个时刻，每个时刻都会发生一些事件。其中小C可能会进行若干次实验，对于他的每一次实验，请你告诉他这一次实验能量收集器的最终能量是多少。

Input

第一行一个整数n,表示星系的星球数。

接下来n-1行每行一个整数,分别表示星球2-n的依赖星球编号。

接下来一行n个整数，表示每个星球在时刻0时的初始能量系数wi.

接下来一行一个整数m,表示事件的总数。

事件分为以下三种类型。

(1)"Q di"表示小C要开始一次实验,收集器的初始位置在星球di.

(2)"C xi yi"表示星球xi的依赖星球变为了星球yi.

(3)"F pi qi"表示星球pi能量激发，常数为qi.

Output

对于每一个事件类型为Q的事件，输出一行一个整数，表示此次实验的收集器最终能量。

 

Sample Input

3
1
1
4 5 7
5
Q 2
F 1 3
Q 2
C 2 3
Q 2

Sample Output

9
15
25

HINT

n<=100000,m<=300000,1<di,xi<=n,wi,qi<=100000.保证操作合法。注意w_i>=0

Source

By 佚名上传

[Submit][Status][Discuss]

ETT三题：

[BZOJ4825 HNOI2017 单旋]

[BZOJ3729 Gty的游戏]

[BZOJ3785]星系探索

 

Euler Tour Tree（欧拉游览树）是一种可以支持比LCT更多的操作的数据结构，但其无论从功能还是复杂度方面都远不如TopTree和Self Adjust Tree好。

真正的ETT的操作有很多，但一般只需要用到伪ETT，实际上就是splay维护DFS序。

以此题为例，如果没有子树修改，就是LCT模板，如果没有在线Link-Cut，就是DFS序+线段树模板。同时有的时候就需要一种支持在线DFS区间修改的数据结构，且支持区间平移操作，splay无疑是最好的选择。

具体做法是维护DFS括号序列（也就是欧拉序），进栈值为v，出栈值为-v，所以u到v的路径上的所有数之和就是DFS序上L[u]到L[v]的数之和了（所以这题可以支持查询任意树上路径和而不只是某个点到根的路径和），树上莫队应该也是类似的思想。

那么C操作如何支持呢？考虑到一个子树移到另一个位置后，整棵树的DFS序正是原DFS序中L[u]到R[u]的区间平移到新的位置，区间平移操作直接用splay支持即可，复杂度不变。

 

于是这题就1h就写完且答案正确了，但是BZOJ上无限TLE，一直以为是哪里死循环了不停查错，幸亏发现良心出题人在网上放出了数据才知道是常数问题。发现各种常数优化都无济于事，最后才知道：把splay上的信息存在一个struct里常数会缩小将近一倍！究其原因应该是访问同一个节点的不同信息的时候要在好几个数组里查找，大幅增加了寻址时间。看来以后splay等数据结构要考虑全部换成结构体写法了。

那就正好趁这个机会总结一下各种卡常技巧：

　　1. register是最好用的（但有时没有效果），非递归函数参数也可以用。

　　2. 多维数组从前往后大小依次递增效果最好。相应地，寻址时在高维的循环变量应位于外层循环（如矩乘）。

　　3. 数组开2^k+1据说很有用，但好像从来没有收到良好效果。

　　4. 多次用到的define换成函数会更快，多次用到的数组元素应用temp存下。

　　5. 排序不应使用cmp函数，应在结构体内部重载<运算符。

　　6. 多用struct好像可以加快一些访问的速度。

　　7. 能用位运算的不要取模。循环展开大概4位或8位。

　　8. 根据情况多加循环中止判断语句，这个剩至可以降低理论复杂度。

#include<cstdio>
#include<algorithm>
#define ls t[x].ch[0]
#define rs t[x].ch[1]
#define rep(i,l,r) for (int i=l; i<=r; i++)
typedef long long ll;
using namespace std;

const int N=200100;
int cnt,x,y,n,Q,rt,tim,L[N],R[N],val[N],a[N],to[N<<1],lst[N<<1],h[N];
struct T{ int sl,sr,v,fa,type,ch[2]; ll sum,tag; }t[N];
char op;
void add(int u,int v){ to[++cnt]=v; lst[cnt]=h[u]; h[u]=cnt; }

void upd(int x){
    t[x].sum=t[ls].sum+t[rs].sum+t[x].v;
    t[x].sl=t[ls].sl+t[rs].sl+(t[x].type==1);
    t[x].sr=t[ls].sr+t[rs].sr+(t[x].type==-1);
}

void put(int x,int k){ t[x].sum+=1ll*k*(t[x].sl-t[x].sr); t[x].v+=k*t[x].type; t[x].tag+=k; }
void push(int x){
    if (t[x].tag){
        if (ls) put(ls,t[x].tag);
        if (rs) put(rs,t[x].tag);
        t[x].tag=0;
    }
}
void mdf(int x){ if (t[x].fa) mdf(t[x].fa); push(x); }

void rot(int &rt,int x){
    int y=t[x].fa,z=t[y].fa,w=t[y].ch[1]==x;
    if (y==rt) rt=x; else t[z].ch[t[z].ch[1]==y]=x;
    t[x].fa=z; t[y].fa=x; t[t[x].ch[w^1]].fa=y;
    t[y].ch[w]=t[x].ch[w^1]; t[x].ch[w^1]=y; upd(y);
}

void splay(int &rt,int x){
    mdf(x);
    while (x!=rt){
        int y=t[x].fa,z=t[y].fa;
        if (y!=rt) rot(rt,(t[z].ch[1]==y)^(t[y].ch[1]==x) ? x : y);
        rot(rt,x);
    }
    upd(x);
}

void dfs(int x){
    L[x]=++tim; val[tim]=x;
    for (int i=h[x]; i; i=lst[i]) dfs(to[i]);
    R[x]=++tim; val[tim]=-x;
}

void build(int &x,int L,int R,int f){
    int mid=(L+R)>>1; x=mid; t[x].fa=f;
    if (val[x]>0) t[x].type=1,t[x].v=a[val[x]]; else t[x].type=-1,t[x].v=-a[-val[x]];
    if (L<mid) build(ls,L,mid-1,x);
    if (mid<R) build(rs,mid+1,R,x);
    upd(x);
}

int pre(int x){ x=ls; while (rs) x=rs; return x; }
int nxt(int x){ x=rs; while (ls) x=ls; return x; }

void split(int &l,int &r){
    splay(rt,l); l=pre(l);
    splay(rt,r); r=nxt(r);
    splay(rt,l); splay(t[l].ch[1],r);
}

ll que(int x){ int l=L[1],r=L[x]; split(l,r); return t[t[r].ch[0]].sum; }

void plus(int x,int k){ int l=L[x],r=R[x]; split(l,r); put(t[r].ch[0],k); }

void change(int x,int f){
    int l=L[x],r=R[x]; split(l,r);
    int q=t[r].ch[0]; t[r].ch[0]=t[q].fa=0; upd(r); upd(l);
    int p=L[f]; splay(rt,p);
    int s=nxt(p); splay(t[p].ch[1],s);
    t[s].ch[0]=q; t[q].fa=s; upd(s); upd(p);
}

int main(){
    freopen("bzoj3786.in","r",stdin);
    freopen("bzoj3786.out","w",stdout);
    scanf("%d",&n);
    rep(i,2,n) scanf("%d",&x),add(x,i);
    rep(i,1,n) scanf("%d",&a[i]);
    tim=1; dfs(1); build(rt,1,tim+1,0);
    for (scanf("%d",&Q); Q--; ){
        scanf(" %c",&op); scanf("%d",&x);
        if (op=='Q') printf("%lld\n",que(x));
        else if (op=='C') scanf("%d",&y),change(x,y); else scanf("%d",&y),plus(x,y);
    }
    return 0;
}