[BZOJ3052][WC2013]糖果公园-树上带修改莫队算法

糖果公园

Description

Input

Output

Sample Input

4 3 5
1 9 2
7 6 5 1
2 3
3 1
3 4
1 2 3 2
1 1 2
1 4 2
0 2 1
1 1 2
1 4 2

Sample Output

84
131
27
84

HINT

---

心中的剧本:花了N久写完然后调错调到心态爆炸
事情的真相:写了1h+，卡了1h常，然后就过了???
（这里的“过了”指洛谷而非BZOJ 总时限大法好不用卡常就能过）

---

思路:
树上带修改莫队~
考试时咱肯定想不出来~

首先，在树上使用莫队之前，得先分好块。
那么这里有一个被称为“王室联邦分块”的方法:
(这个名字来源于BZOJ的题目“王室联邦”)

首先，dfs遍历整棵树。
维护一个栈，每个节点将在回溯时被加入栈中。

对于每个节点，记录刚到达这个节点时栈顶的位置。
为方便描述，将这个记录的位置以上的栈的部分叫做这个节点的局部栈。
若当处理完某个儿子时，发现当前节点局部栈大小超过分块大小，那么弹空当前局部栈，令所有这次被弹出的元素形成一个块。

可以发现，每次回溯后，相当于当前节点的局部栈中剩余元素合并到了父亲节点的局部栈中。
这样分块好处是保证了块的直径和大小，坏处是块内元素不保证连通。
然而它很符合咱们的需求~

然后，是考虑如何像原版莫队移动区间一样，移动当前处理的路径位置。
首先，对于单点存在性取反，即当前答案中是否选中这个点，可以维护一个桶快速处理。

因为lca很麻烦，因此假设不考虑维护询问路径的lca，而是最后再单独加上其贡献。
可以发现，如果要将$ans(u,v)$移动到$ans(newu,newv)$，可行的一种移动方法为:
将$(u,newu)$路径上的点的存在性取反，再将$(v,newv)$路径上的点的存在性取反。
画图就会发现这种移动方法是正确的。

于是具备了分块和移动，带修改莫队直接上!

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

typedef long long ll;
const int N=100009;
const int K=18;

int n,m,q,b,qtop,ctop;
int stk[N],bid[N],id[N],dfn,top,rot;
int to[N<<1],nxt[N<<1],beg[N],tot;
int fa[N][K],dep[N],buc[N],mem[N];
int v[N],w[N],c[N];
int curt,curu,curv;
ll ans[N],curval;
bool vis[N];

struct query
{
    int tim,x,y,z;
}qu[N],ch[N];

inline bool qcmp(query a,query b)
{
    if(bid[a.x]!=bid[b.x])
        return bid[a.x]<bid[b.x];
    if(bid[a.y]!=bid[b.y])
        return bid[a.y]<bid[b.y];
    return a.tim<b.tim;
}

inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')x=x*10+(ch^48),ch=getchar();
    return x;
}

inline void write(ll x)
{
    if(x>=10)write(x/10);
    putchar('0'+x%10);
}

inline void add(int u,int v)
{
    to[++tot]=v;
    nxt[tot]=beg[u];
    beg[u]=tot;
}

inline void dfs(int u)
{
    id[u]=++dfn;int rtop=top;
    for(int i=beg[u],v;i;i=nxt[i])
        if((v=to[i])!=fa[u][0])
        {
            fa[v][0]=u;
            dep[v]=dep[u]+1;
            dfs(v);
            if(top-rtop>=b)
            {
                rot++;
                while(top!=rtop)
                    bid[stk[top--]]=rot;
            }
        }
    stk[++top]=u;
}

inline int lca(int a,int b)
{
    if(dep[a]>dep[b])swap(a,b);
    for(int i=K-1;i>=0;i--)
        if(dep[fa[b][i]]>=dep[a])
            b=fa[b][i];
    if(a==b)return a;
    for(int i=K-1;i>=0;i--)
        if(fa[a][i]!=fa[b][i])
            a=fa[a][i],b=fa[b][i];
    return fa[a][0];
}

inline void init()
{
    b=pow(n,0.60);
    dfs(dep[1]=1);
    for(int i=1;i<K;i++)
        for(int j=1;j<=n;j++)
            fa[j][i]=fa[fa[j][i-1]][i-1];
    sort(qu+1,qu+qtop+1,qcmp);

    for(int i=1;i<=ctop;i++)
    {
        mem[i]=c[ch[i].x];
        c[ch[i].x]=ch[i].y;
    }
    for(int i=ctop;i>=1;i--)
        c[ch[i].x]=mem[i];
    curu=curv=1,curt=0;
}

inline void pxor(int x)
{
    if(!vis[x])
        curval+=(ll)v[c[x]]*w[++buc[c[x]]];
    else
        curval-=(ll)v[c[x]]*w[buc[c[x]]--];
    vis[x]^=1;
}

inline void timeinc(int tim)
{
    for(bool flag=0;curt<ctop && curt<tim;curt++,flag=0)
    {
        if(vis[ch[curt+1].x])flag=1;
        if(flag)pxor(ch[curt+1].x);
        c[ch[curt+1].x]=ch[curt+1].y;
        if(flag)pxor(ch[curt+1].x);
    }
}

inline void timedec(int tim)
{
    for(bool flag=0;1<=curt && tim<curt;curt--,flag=0)
    {
        if(vis[ch[curt].x])flag=1;
        if(flag)pxor(ch[curt].x);
        c[ch[curt].x]=mem[curt];
        if(flag)pxor(ch[curt].x);
    }
}

inline void pathx(int u,int v)
{
    if(dep[u]<dep[v])swap(u,v);
    int dlt=dep[u]-dep[v];
    while(dlt--)
        pxor(u),u=fa[u][0];
    if(v==u)return;
    while(u!=v)
    {
        pxor(u),u=fa[u][0];
        pxor(v),v=fa[v][0];
    }
}

int main()
{
    n=read();m=read();q=read();
    for(int i=1;i<=m;i++)
        v[i]=read();
    for(int i=1;i<=n;i++)
        w[i]=read();
    for(int i=1,x,y;i<n;i++)
    {
        x=read();y=read();
        add(x,y);add(y,x);
    }
    for(int i=1;i<=n;i++)
        c[i]=read();
    for(int i=1,ty,x,y;i<=q;i++)
    {
        ty=read();x=read();y=read();
        if(id[x]>id[y])swap(x,y);
        if(ty==0)
            ch[++ctop]=(query){i,x,y,0};
        else
            qu[++qtop]=(query){ctop,x,y,i};
        ans[i]=-1;
    }

    init();
    for(int i=1,lcas;i<=qtop;i++)
    {
        timeinc(qu[i].tim);
        timedec(qu[i].tim);
        pathx(qu[i].x,curu);curu=qu[i].x;
        pathx(qu[i].y,curv);curv=qu[i].y;
        lcas=lca(qu[i].x,qu[i].y);
        pxor(lcas);
        ans[qu[i].z]=curval;
        pxor(lcas);
    }

    for(int i=1;i<=q;i++)
        if(~ans[i])
            write(ans[i]),putchar('\n');
    return 0;
}