hdu 5267 pog loves szh IV（点分治+线段树）

好久之前写的题了。现在要重新开始写题解了。就从这题开始吧。

题意：一棵树，两点之间的权值为路径上的值异或得到，求任意两点之间的权值和，有修改操作，每次都要输出任意两点间的权值和。

做法：当时写这题写了好久。就说下一些关键的思路，因为细节部分真的是太多。首先不同的位独立考虑，然后任意两点我们肯定会想到点分治，点分治时会dfs求出子树里每个点到根节点的权值，然后进行配对求经过根节点的权值和。

那么这个题我们可以把分治的的过程给保存下来，因为修改一个点的权值就意味着在某一个点分治的阶段，那个点其下的点到根节点的权值全都异或1（因为按位不同考虑，假设那个位跟原来不一样）。所以可以弄出dfs序，然后区间更新即可。然后每一次分治的根节点我们要保存：其下1和0的个数，1和1配对的个数，0个0配对的个数，1和0配对的个数。那么在修改时，我们先把那颗子树上0和1对于这个根节点的贡献给消除，再去在子树上区间更新得到新的0和1的个数，再去重新计算根节点我要维护的那几个值。这样答案就可以重新知道了。

具体思路就是这样，但是比较繁琐，比如得维护每个点的每一次分治是属于哪个线段树，以及它在这个线段树中所能影响的范围（即他的子树dfs序的范围）。以及每次分治过程根节点的信息（就是刚才说的）。细节注意下就可以了。

PS：8.5k的代码也是写的很醉人。

AC代码：

#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<ctype.h>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
#include<cstdlib>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<cmath>
#include<ctime>
#include<string.h>
#include<string>
#include<sstream>
#include<bitset>
using namespace std;
#define ll __int64
#define ull unsigned __int64
#define eps 1e-8
#define NMAX 30000
#define MOD 998244353
//#define lson l,mid,rt<<1,d
//#define rson mid+1,r,rt<<1|1,d
#define PI acos(-1)
template<class T>
inline void scan_d(T &ret)
{
    char c;
    int flag = 0;
    ret=0;
    while(((c=getchar())<'0'||c>'9')&&c!='-');
    if(c == '-')
    {
        flag = 1;
        c = getchar();
    }
    while(c>='0'&&c<='9') ret=ret*10+(c-'0'),c=getchar();
    if(flag) ret = -ret;
}
const int maxn = 10000+10;

struct Edge
{
    int v,next;
}e[maxn*2];
int head[maxn],ecnt;

void add_edge(int u, int v)
{
    e[ecnt].v = v;
    e[ecnt].next = head[u];
    head[u] = ecnt++;
}

int point;
int Pos[maxn],Size[maxn];

int dp[maxn],mi,pp,sz;

struct Tree
{
    int zero,one,zz,oo,zo;
}Tree[15][maxn];

int ans[15];
bool data[15][maxn],vis[maxn];

void gao1(int u, int fa)
{
    dp[u] = 1;
    sz++;
    for(int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].v;
        if(v == fa || vis[v]) continue;
        gao1(v,u);
        dp[u] += dp[v];
    }
}

void gao2(int u, int fa)
{
    int tmp = sz-dp[u];
    for(int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].v;
        if(v == fa || vis[v]) continue;
        gao2(v,u);
        tmp = max(tmp,dp[v]);
    }
    if(tmp < mi)
    {
        mi = tmp;
        pp = u;
    }
}

int getbarycenter(int u)
{
    sz = 0;
    gao1(u,u);
    mi = 1000000;
    gao2(u,u);
    return pp;
}


struct node
{
    int root, ge, l, r;
    node(){}
    node(int _root, int _ge, int _l, int _r):root(_root),ge(_ge),l(_l),r(_r) {}
};

vector<node>vec[maxn];

bool a[15][maxn];
void solve(int u, int fa, int w, int rt, int tou, int flag)
{
    sz++;
    a[flag][sz] = w;
    int tmp = sz;
    for(int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].v;
        if(v == fa || vis[v]) continue;
        solve(v,u,w^data[flag][v],rt,tou,flag);
    }
    if(flag == 0) vec[u].push_back(node(rt,tou,tmp,sz));
}

int tot;
int lson[maxn*30],rson[maxn*30];
struct SegmentTree
{
    int zero,one;
    bool flag;
}T[15][maxn*30];

int build(int l, int r)
{
    int rt = ++tot;
    for(int i = 0; i <= 14; i++)
        T[i][rt].flag = 0;
    if(l == r)
    {
//        T[rt].lson = T[rt].rson = 0;
        for(int i = 0; i <= 14; i++)
        {
            T[i][rt].zero = T[i][rt].one = 0;
            if(a[i][l] == 1) T[i][rt].one = 1;
            else T[i][rt].zero = 1;
        }
        return rt;
    }
    int mid = (l+r)>>1;
    lson[rt] = build(l,mid);
    rson[rt] = build(mid+1,r);
    for(int i = 0; i <= 14; i++)
    {
        T[i][rt].one = T[i][lson[rt]].one + T[i][rson[rt]].one;
        T[i][rt].zero = T[i][lson[rt]].zero + T[i][rson[rt]].zero;
    }
    return rt;
}

void dfs(int u)
{
    u = getbarycenter(u);
//        cout<<"tree:"<<u<<" "<<sz<<endl;
    if(sz == 1)
    {
        for(int i = 0; i <= 14; i++)
            Tree[i][u].one = Tree[i][u].zero = Tree[i][u].oo = Tree[i][u].zz = Tree[i][u].zo = 0;
//        vec[u].push_back(node(u,0,0,0));
        return;
    }
    int z[15] = {0}, o[15] = {0}, oo[15] = {0}, zz[15] = {0}, zo[15] = {0};
    for(int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].v;
        if(vis[v]) continue;
        for(int j = 0; j <= 14; j++)
        {
            sz = 0;
            solve(v,u,data[j][v],u,point,j);
        }
        int pos = build(1,sz);
//        cout<<"shit1:"<<v<<" "<<sz<<" "<<T[0][pos].one<<endl;
        Pos[point] = pos;
        Size[point++] = sz;
        for(int j = 0; j <= 14; j++)
        {
            oo[j] += T[j][pos].one*o[j];
            zz[j] += T[j][pos].zero*z[j];
            zo[j] += T[j][pos].one*z[j]+T[j][pos].zero*o[j];
            o[j] += T[j][pos].one;
            z[j] += T[j][pos].zero;
        }
    }
    for(int i = 0; i <= 14; i++)
    {
        Tree[i][u].one = o[i];
        Tree[i][u].zero = z[i];
        Tree[i][u].oo = oo[i];
        Tree[i][u].zz = zz[i];
        Tree[i][u].zo = zo[i];
        if(data[i][u] == 1) ans[i] += oo[i]+zz[i]+z[i];
        else ans[i] += zo[i]+o[i];
    }
    vis[u] = 1;
    for(int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].v;
        if(vis[v]) continue;
        dfs(v);
    }
}

void init(int n)
{
    memset(ans,0,sizeof(ans));
    memset(vis,0,sizeof(vis));
    for(int i = 1; i <= n; i++)
        vec[i].clear();
}

void pushdown(int rt, int flag)
{
    if(T[flag][rt].flag)
    {
        swap(T[flag][lson[rt]].zero,T[flag][lson[rt]].one);
        swap(T[flag][rson[rt]].zero,T[flag][rson[rt]].one);
        T[flag][lson[rt]].flag ^= 1;
        T[flag][rson[rt]].flag ^= 1;
        T[flag][rt].flag = 0;
    }
}

void update(int L, int R, int l, int r, int rt, int flag)
{
    if(L <= l && R >= r)
    {
        T[flag][rt].flag ^= 1;
        swap(T[flag][rt].zero,T[flag][rt].one);
        return;
    }
    pushdown(rt,flag);
    int mid = (l+r)>>1;
    if(L <= mid) update(L,R,l,mid,lson[rt],flag);
    if(R > mid) update(L,R,mid+1,r,rson[rt],flag);
    T[flag][rt].one = T[flag][lson[rt]].one + T[flag][rson[rt]].one;
    T[flag][rt].zero = T[flag][lson[rt]].zero + T[flag][rson[rt]].zero;
}

void rilegou(int x, int flag)
{
    int num = vec[x].size();
    for(int i = 0; i < num; i++)
    {
        int rt = vec[x][i].root,ge = vec[x][i].ge;
        if(data[flag][rt] == 1) ans[flag] -= Tree[flag][rt].zero+Tree[flag][rt].oo+Tree[flag][rt].zz;
        else ans[flag] -= Tree[flag][rt].one+Tree[flag][rt].zo;
        int z = T[flag][Pos[ge]].zero, o = T[flag][Pos[ge]].one;
        Tree[flag][rt].oo -= (Tree[flag][rt].one-o)*o;
        Tree[flag][rt].zz -= (Tree[flag][rt].zero-z)*z;
        Tree[flag][rt].zo -= (Tree[flag][rt].one-o)*z+(Tree[flag][rt].zero-z)*o;
        Tree[flag][rt].one -= o;
        Tree[flag][rt].zero -= z;
        update(vec[x][i].l,vec[x][i].r,1,Size[ge],Pos[ge],flag);
        z = T[flag][Pos[ge]].zero;
        o = T[flag][Pos[ge]].one;
        Tree[flag][rt].oo += o*Tree[flag][rt].one;
        Tree[flag][rt].zz += z*Tree[flag][rt].zero;
        Tree[flag][rt].zo += o*Tree[flag][rt].zero+z*Tree[flag][rt].one;
        Tree[flag][rt].one += o;
        Tree[flag][rt].zero += z;
        if(data[flag][rt] == 1) ans[flag] += Tree[flag][rt].zero+Tree[flag][rt].oo+Tree[flag][rt].zz;
        else ans[flag] += Tree[flag][rt].one+Tree[flag][rt].zo;
    }
    if(data[flag][x] == 1)
    {
        ans[flag] -= Tree[flag][x].zero+Tree[flag][x].oo+Tree[flag][x].zz;
        ans[flag] += Tree[flag][x].one+Tree[flag][x].zo;
        data[flag][x] = 0;
    }
    else
    {
        ans[flag] -= Tree[flag][x].one+Tree[flag][x].zo;
        ans[flag] += Tree[flag][x].zero+Tree[flag][x].oo+Tree[flag][x].zz;
        data[flag][x] = 1;
    }
}

int main()
{
#ifdef GLQ
    freopen("input.txt","r",stdin);
//    freopen("o.txt","r",stdin);
#endif
    int n,q;
    while(~scanf("%d%d",&n,&q))
    {
        memset(head,-1,sizeof(head));
        ecnt = point = tot = 0;
        init(n);
        for(int i = 1; i <= n; i++)
        {
            int tmp;
            scanf("%d",&tmp);
            for(int j = 0; j <= 14; j++)
                data[j][i] = !!(tmp&(1<<j));
        }
        for(int i = 1; i < n; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v);
            add_edge(v,u);
        }
        dfs(1);
//        cout<<vec[2].size()<<endl;
        ll ret = 0;
        for(int i = 0; i <= 14; i++)
            ret += (ll)ans[i]*(1LL<<i);
//        cout<<ret<<endl;
        while(q--)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            for(int i = 0; i <= 14; i++)
            {
                if(data[i][x] == !!(y&(1<<i))) continue;
                ret -= (ll)ans[i]*(1LL<<i);
                rilegou(x,i);
                ret += (ll)ans[i]*(1LL<<i);
            }
            printf("%I64d\n",ret*2LL);
        }
    }
    return 0;
}