Luogu3613 睡觉困难综合征/BZOJ4811 Ynoi2017 由乃的OJ 树链剖分、贪心

传送门

题意：给出一个$N$个点的树，树上每个点有一个位运算符号和一个数值。需要支持以下操作：修改一个点的位运算符号和数值，或者给出两个点$x,y$并给出一个上界$a$，可以选取一个$[0,a]$内的整数值，在从$x$到$y$的路径上，每走到一个点就与这个点对应的数值进行对应的位运算，求到达$y$点时数字的可能的最大值。$N,\text{操作数} \leq 10^5$，数字在$unsigned long long$范围内。

---

可以先去做NOI2014的起床困难综合征

考虑用起床困难综合征的贪心策略加上树链剖分解决这道题。首先我们需要解决一个问题：在起床困难综合征中，我们每一次枚举一位，就整个跑一边，看当前位取$1$是否会产生更大的贡献；但是在这一道题中显然是不能每一次都跑一边的。我们需要快速地维护每一位为$0$或$1$时这一位运算之后得到的答案。因为每一位之间是不相互冲突的，所以我们可以将$2^{64}-1$和$0$分别带入求解，这样第$i$位为$1$时的贡献就是带入$2^{64}-1$时第$i$位的值，而第$i$位为$0$时的贡献就是带入$0$时第$i$位的值。

接下来我们考虑如何用线段树维护这两个值。可以知道在合并的时候，当前这个区间带入$2^{64}-1$的值时的答案就是左边一半带入$2^{64}-1$时的答案再带到右边得到的答案，$0$同理。所以也可以用位运算很快的表示出来，不是很有思路的可以去看下面的$merge$

然后我们就可以树链剖分然后跳跳跳了。

注意一个细节：因为链可以不是直上直下的，在往上的过程中$dfs$序是在变小的，而在往下的过程中在变大，所以在线段树中需要同时维护从左往右和从右往左计算的值（也就是下面的$ltor$和$rtol$）。

 #include<bits/stdc++.h>
 #define ull unsigned long long
 #define lch (now << 1)
 #define rch (now << 1 | 1)
 #define mid ((l + r) >> 1)
 //This code is written by Itst
 using namespace std;

 inline ull read(){
     ull a = ;
     char c = getchar();
     while(c != EOF && !isdigit(c))
         c = getchar();
     while(c != EOF && isdigit(c)){
         a = (a << ) + (a << ) + (c ^ ');
         c = getchar();
     }
     return a;
 }

 ;
 struct node{
     ull ltor[] , rtol[] , val;
     int op;
     node(){
         ltor[] = rtol[] = -;
         ltor[] = rtol[] = ;
     }
 }Tree[MAXN << ];
 struct Edge{
     int end , upEd;
 }Ed[MAXN << ];
 int head[MAXN] , ind[MAXN] , rk[MAXN] , dep[MAXN] , top[MAXN] , fa[MAXN] , size[MAXN] , son[MAXN] , op[MAXN];
 ull num[MAXN];
 int ts , N , M , cntEd , K;

 inline ull calc(ull a , ull b , int op){
     switch(op){
     :
         return a & b;
     :
         return a | b;
     :
         return a ^ b;
     }
 }

 inline void addEd(int a , int b){
     Ed[++cntEd].end = b;
     Ed[cntEd].upEd = head[a];
     head[a] = cntEd;
 }

 void dfs1(int x , int f){
     fa[x] = f;
     dep[x] = dep[f] + ;
     size[x] = ;
     for(int i = head[x] ; i ; i = Ed[i].upEd)
         if(Ed[i].end != f){
             dfs1(Ed[i].end , x);
             size[x] += size[Ed[i].end];
             if(size[son[x]] < size[Ed[i].end])
                 son[x] = Ed[i].end;
         }
 }

 void dfs2(int x , int t){
     top[x] = t;
     ind[x] = ++ts;
     rk[ts] = x;
     if(!son[x])
         return;
     dfs2(son[x] , t);
     for(int i = head[x] ; i ; i = Ed[i].upEd)
         if(Ed[i].end != fa[x] && Ed[i].end != son[x])
             dfs2(Ed[i].end , Ed[i].end);
 }

 inline node merge(node l , node r){
     node t;
     t.ltor[] = (l.ltor[] & r.ltor[]) | (~l.ltor[] & r.ltor[]);
     t.ltor[] = (l.ltor[] & r.ltor[]) | (~l.ltor[] & r.ltor[]);
     t.rtol[] = (r.rtol[] & l.rtol[]) | (~r.rtol[] & l.rtol[]);
     t.rtol[] = (r.rtol[] & l.rtol[]) | (~r.rtol[] & l.rtol[]);
     return t;
 }

 void init(int now , int l , int r){
     if(l == r){
         Tree[now].op = op[rk[l]];
         Tree[now].val = num[rk[l]];
         Tree[now].ltor[] = Tree[now].rtol[] = calc(- , Tree[now].val , Tree[now].op);
         Tree[now].ltor[] = Tree[now].rtol[] = calc( , Tree[now].val , Tree[now].op);
     }
     else{
         init(lch , l , mid);
         init(rch , mid +  , r);
         Tree[now] =    merge(Tree[lch] , Tree[rch]);
     }
 }

 void modify(int now , int l , int r , int tar){
     if(l == r){
         Tree[now].op = op[rk[l]];
         Tree[now].val = num[rk[l]];
         Tree[now].ltor[] = Tree[now].rtol[] = calc(- , Tree[now].val , Tree[now].op);
         Tree[now].ltor[] = Tree[now].rtol[] = calc( , Tree[now].val , Tree[now].op);
     }
     else{
         if(mid >= tar)
             modify(lch , l , mid , tar);
         else
             modify(rch , mid +  , r , tar);
         Tree[now] = merge(Tree[lch] , Tree[rch]);
     }
 }

 node query(int now , int l , int r , int L , int R){
     if(l >= L && r <= R)
         return Tree[now];
     node p;
     if(mid >= L)
         p = merge(p , query(lch , l , mid , L , R));
     if(mid < R)
         p = merge(p , query(rch , mid +  , r , L , R));
     return p;
 }

 inline void work(int x , int y , ull maxN){
     node l , r;
     int tx = top[x] , ty = top[y];
     while(tx != ty)
         if(dep[tx] > dep[ty]){
             l = merge(query( ,  , N , ind[tx] , ind[x]) , l);
             x = fa[tx];
             tx = top[x];
         }
         else{
             r = merge(query( ,  , N , ind[ty] , ind[y]) , r);
             y = fa[ty];
             ty = top[y];
         }
     if(dep[x] > dep[y])
         l = merge(query( ,  , N , ind[y] , ind[x]) , l);
     else
         r = merge(query( ,  , N , ind[x] , ind[y]) , r);
     swap(l.rtol[] , l.ltor[]);
     swap(l.rtol[] , l.ltor[]);
     l = merge(l , r);
     ull ans =  , now = ;
      ; i >=  ; --i){
         ull t = (ull) << i , p = l.ltor[] & t , q = l.ltor[] & t;
         if(q >= p || now + t > maxN)
             ans += q;
         else{
             now += t;
             ans += p;
         }
     }
     printf("%llu\n" , ans);
 }

 int main(){
 #ifndef ONLINE_JUDGE
     freopen("3613.in" , "r" , stdin);
     //freopen("3613.out" , "w" , stdout);
 #endif
     N = read();
     M = read();
     K = read();
      ; i <= N ; ++i){
         op[i] = read();
         num[i] = read();
     }
      ; i < N ; ++i){
         int a = read() , b = read();
         addEd(a , b);
         addEd(b , a);
     }
     dfs1( , );
     dfs2( , );
     init( ,  , N);
     int o , x , y;
     ull z;
     while(M--){
         o = read();
         x = read();
         y = read();
         z = read();
         )
             work(x , y , z);
         else{
             op[x] = y;
             num[x] = z;
             modify( ,  , N , ind[x]);
         }
     }
     ;
 }