LOJ2269 [SDOI2017] 切树游戏 【FWT】【动态DP】【树链剖分】【线段树】

题目分析：

好题。本来是一道好的非套路题，但是不凑巧的是当年有一位国家集训队员正好介绍了这个算法。 

首先考虑静态的情况。这个的DP方程非常容易写出来。

接着可以注意到对于异或结果的计数可以看成一个FWT的过程，进一步地可以注意到FWT在中途没有还原的必要。从FWT的过程中我们可以发现FWT具有可加性和交换律结合律。

这样原问题可以在静态的情况下通过树形DP做到$O(nm)$。

考虑动态的问题。根据《神奇的子图》命题报告及其拓展中描述的算法五，我们应该不难想到基于树链剖分的这样的做法。

首先对树进行轻重路径剖分，构建一棵重链树。接着将树中轻子树的影响放进对应的重链父节点(不是top节点)上。接着在线段树上合并问题的答案。

对于一个线段树中的结点，经过分析我们应该可以知道需要记录的信息有这么几个：

L:从这个线段树区间所对应的子重链的顶端开始延伸出的包含轻边子树的所有情况的FWT值。

R:从这个线段树区间所对应的子重链的底端开始延伸出的包含轻边子树的所有情况的FWT值。

C:这个线段树区间所对应的子重链上的所有点都被选择，接着往子树方向延伸的所有情况的FWT值。

tot:这个线段树区间所对应的子重链以及它的所有轻边子树看作一个整体的树的答案的FWT值。 

有了这些信息之后线段树的合并答案就不难写出来了。我们用下标$0$表示左子树，下标$1$表示右子树。

$L = L_0+C_0*L_1$

$R = R_1+C_1*R_0$

$C = C_0*C_1$

$tot = tot_0+tot_1+L_1*R_0$

我们还提到了线段树中的叶子结点是包含它的所有轻边子树信息的。根据《神奇的子图》命题报告及其拓展中的描述，我们能够想到通过普通的DP来转移答案。

下面我们用H来表示它的一个轻边儿子，Now表示叶子对应的原树上的点，Base为128个单位FWT之一。注意到对于叶子结点，他的L和R和C是相同的。所以忽略R和C。这样叶子的转移可以这样写：

$Leaf_L = Base[v[Now]]*prod_{i in son}(H_L+Base[0])$可以理解为01背包的选和不选。

$Leaf_{tot} = sum_{i in son}tot_i + Leaf_L$. 

 有了它们，我们现在可以进行修改了。

对于一次修改，我们要做的是，沿着重链树往上跳，遇到一条重链则更改重链在线段树中的信息。这样做只会经过$O(logn)$条重链，每条重链只会修改一个点，对应的在线段树上只会修改一个点，线段树每次修改时间复杂度为$O(logn)$，所以这是$O(log^2n)$的。

除以0的问题可以另外建一棵线段树解决，但大家好像都说可以记录0的个数，我不会，希望会的可以留个言。

时间复杂度$O(nmlog^2n)$，树链剖分常数较小，可以通过所有数据。

upd:LOJ时间倒数第三。。。

代码：

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

const int maxn = 30200;
const int maxm = 128;
const int mod = 10007;

int n,m,num,num2,bfsnum;
int v[maxn];
vector <int> g[maxn];

vector <int> Chain[maxn];

int dep[maxn],fa[maxn],top[maxn],number[maxn],sz[maxn],son[maxn];
int tail[maxn],where[maxn],im[maxn],bfsin[maxn],bfsout[maxn];

struct func{
    int cont[maxm]; 
    func operator * (func b){
    for(int i=0;i<=maxm;i++) b.cont[i] = (b.cont[i]*cont[i])%mod;
    return b;
    }
    func operator + (func b){
    for(int i=0;i<=maxm;i++) b.cont[i] = (b.cont[i]+cont[i])%mod;
    return b;
    }
    func operator - (func b){
    for(int i=0;i<=maxm;i++) b.cont[i] = (cont[i]-b.cont[i]+mod)%mod;
    return b;
    }
}base[maxm],T2[maxn<<2],Newnumber;

struct node{
    func L,R,C,tot;
    //左端延伸，右端延伸，总和
}T[maxn<<2];

void push_up(int now){
    T[now].L = T[now<<1].C*T[now<<1|1].L + T[now<<1].L;
    T[now].R = T[now<<1|1].C*T[now<<1].R + T[now<<1|1].R;
    T[now].C = T[now<<1].C*T[now<<1|1].C;
    T[now].tot = T[now<<1].tot+T[now<<1|1].tot+T[now<<1].R*T[now<<1|1].L;
}

void dfs1(int now,int f,int dp){
    dep[now] = dp; fa[now] = f;
    for(int i=0;i<g[now].size();i++){
    if(g[now][i] == f) continue;
    dfs1(g[now][i],now,dp+1);
    sz[now] += sz[g[now][i]];
    if(sz[son[now]] < sz[g[now][i]]) son[now] = g[now][i];
    }
    sz[now]++;
}

void dfs2(int now,int tp){
    top[now] = tp; number[now] = ++num; where[num] = now;
    if(now == tp && now!=1){Chain[top[fa[now]]].push_back(now);}
    if(sz[now] != sz[son[now]] + 1){
    bfsin[now] = bfsnum+1;
    if(fa[now] != 0) bfsout[now] = bfsnum+g[now].size()-2;
    else bfsout[now] = bfsnum+g[now].size()-1;
    }else bfsin[now] = 1,bfsout[now] = -1;
    for(int i=0;i<g[now].size();i++){
    if(g[now][i] == fa[now] || g[now][i] == son[now]) continue;
    im[g[now][i]] = ++bfsnum;
    }
    if(son[now]) {dfs2(son[now],tp);tail[now]=tail[son[now]];}
    else tail[now] = now;
    for(int i=0;i<g[now].size();i++){
    if(g[now][i] == fa[now] || g[now][i] == son[now]) continue;
    dfs2(g[now][i],g[now][i]);
    }
}

node merge(node alpha,node beta){
    node gamma; gamma.L = alpha.L + beta.L*alpha.C;
    gamma.R = beta.R + alpha.R*beta.C;
    gamma.C = alpha.C*beta.C;
    gamma.tot = alpha.tot+beta.tot+alpha.R*beta.L;
    return gamma;
}

node Query(int now,int tl,int tr,int l,int r){
    if(tl >= l && tr <= r) return T[now];
    int mid = (tl+tr)/2;
    if(mid >= r) return Query(now<<1,tl,mid,l,r);
    if(mid < l) return Query(now<<1|1,mid+1,tr,l,r);
    node ans1 = Query(now<<1,tl,mid,l,r);
    node ans2 = Query(now<<1|1,mid+1,tr,l,r);
    return merge(ans1,ans2);
}

void build_tree(int now,int tl,int tr,int l,int r){
    if(tl > r || tr < l) return;
    if(tl == tr){
    tl = where[tl]; T[now].L = base[v[tl]];
    for(int i=0;i<g[tl].size();i++){
        if(g[tl][i] == fa[tl] || g[tl][i] == son[tl]) continue;
        int SS = g[tl][i];
        node forw = Query(1,1,n,number[SS],number[tail[SS]]);
        T[now].tot = T[now].tot + forw.tot;
        T[now].L = T[now].L*(base[0]+forw.L);
    }
    T[now].R = T[now].C = T[now].L;
    T[now].tot = T[now].tot + T[now].L;
    }else{
    int mid = (tl+tr)/2;
    build_tree(now<<1,tl,mid,l,r);
    build_tree(now<<1|1,mid+1,tr,l,r);
    push_up(now);
    }
}

void dfs3(int now){
    for(int i=0;i<Chain[now].size();i++){ dfs3(Chain[now][i]); } //sub
    int p = tail[now];
    build_tree(1,1,n,number[now],number[tail[now]]);
}

void read(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&v[i]);
    for(int i=1;i<n;i++){
    int x,y; scanf("%d%d",&x,&y);
    g[x].push_back(y); g[y].push_back(x);
    }
}

void FWT(func &now,int data){
    now.cont[data] = 1;
    for(int i=2;i<=maxm;i<<=1){
    int yum = maxm/i;
    for(int j=0;j<maxm;j+=yum*2){
        for(int k=0;k<yum;k++){
        int x = now.cont[j+k],y = now.cont[j+k+yum];
        now.cont[j+k] = x+y; now.cont[j+k+yum] = (x-y+mod)%mod;
        }
    }
    }
}

void IFWT(func &now){
    for(int i=1;i<maxm;i<<=1){
    for(int j=0;j<=maxm;j+=i*2){
        for(int k=0;k<i;k++){
        int x = now.cont[j+k],y = now.cont[j+k+i];
        now.cont[j+k] = ((x+y)*5004)%mod;
        now.cont[j+k+i] = ((x-y+mod)*5004)%mod;
        }
    }
    }
}

func VQuery(int now,int tl,int tr,int l,int r){
    if(tl >= l && tr <= r) return T2[now];
    if(tl > r || tr < l) return base[0];
    int mid = (tl+tr)/2;
    return VQuery(now<<1,tl,mid,l,r)*VQuery(now<<1|1,mid+1,tr,l,r);
}

void VModify(int now,int tl,int tr,int place){
    if(tl == tr){
    T2[now] = Newnumber;
    }else{
    int mid = (tl+tr)/2;
    if(place <= mid) VModify(now<<1,tl,mid,place);
    else VModify(now<<1|1,mid+1,tr,place);
    T2[now] = T2[now<<1]*T2[now<<1|1];
    }
}

void Modify(int now,int tl,int tr,int place){
    if(tl == tr){
    tl = where[tl];
    func res = VQuery(1,1,bfsnum,bfsin[tl],bfsout[tl]);
    T[now].tot = T[now].tot - T[now].L;
    T[now].L = T[now].R = T[now].C = res*base[v[tl]];
    T[now].tot = T[now].tot + T[now].L;
    }else{
    int mid = (tl+tr)/2; 
    if(place <= mid) Modify(now<<1,tl,mid,place);
    else Modify(now<<1|1,mid+1,tr,place);
    push_up(now);
    }
}

void Erase(int now,int tl,int tr,int place,int dr){
    if(tl == tr){
    tl = where[tl];
    if(dr == 1)T[now].tot = T[now].tot - Newnumber;
    else T[now].tot = T[now].tot + Newnumber;
    }else{
    int mid = (tl+tr)/2; 
    if(place <= mid) Erase(now<<1,tl,mid,place,dr);
    else Erase(now<<1|1,mid+1,tr,place,dr);
    push_up(now);
    }
}

void work(){
    for(int i=0;i<maxm;i++) FWT(base[i],i);
    dfs1(1,0,1);
    dfs2(1,1);
    dfs3(1);
    for(int i=1;i<=n;i++){
    if(im[i]){
        Newnumber=Query(1,1,n,number[i],number[tail[i]]).L + base[0];
        VModify(1,1,bfsnum,im[i]);
    }
    }
    int q; scanf("%d",&q);
    for(int i=1;i<=q;i++){
    char str[10]; scanf("%s",str);
    if(str[0] == 'C'){
        int x,y; scanf("%d%d",&x,&y);
        int now = x;v[x] = y;
        stack<int> sta;
        while(fa[top[now]]!=0){sta.push(top[now]); now=fa[top[now]];}
        while(!sta.empty()){ // clear tot
        int hd = sta.top();sta.pop();
        Newnumber = Query(1,1,n,number[hd],number[tail[hd]]).tot;
        Erase(1,1,n,number[fa[hd]],1);
        } now = x;
        while(now != 0){
        Modify(1,1,n,number[now]);
        now = top[now];
        Newnumber = Query(1,1,n,number[now],number[tail[now]]).tot;
        if(fa[top[now]]) Erase(1,1,n,number[fa[now]],0);
        Newnumber=base[0]+Query(1,1,n,number[now],number[tail[now]]).L;
        if(im[now]) VModify(1,1,bfsnum,im[now]);
        now = fa[now];
        }
    }else{
        int k; scanf("%d",&k);
        func ans = Query(1,1,n,number[1],number[tail[1]]).tot;
        IFWT(ans);
        printf("%d
",ans.cont[k]);
    }
    }
}

int main(){
    read();
    work();
    return 0;
}