BZOJ 5312: 冒险

首先我们考虑，对于And 和 Or 操作，对于操作位上只有And 0 和 Or 1 是有效果的。

我们注意到如果区间内需要改动的操作位上的数字都相同，那么是可以区间取与以及区间取或的。

那其实可以维护出这个区间的$区间与x和区间或y$

我们考虑 $某一位上 x\;  xor \; y == 1 时$

必定是$x 那一位上 是0 \; y 那一位上是1$

因为显然 $如果x那一位上是1，那么y那一位上必然是1， y那一位上是0， x 那一位上必然是0$

那我们再考虑区间与的操作，我们令 $S = (1 << 31) - 1, 令val 表示需要与的数$

当 $(x \; xor \; y) \; and \; (S - val) == 0 的时候$

这个时候可以理解为在不需要与0的位置上，这个区间内都是1或者都是0，即这些不相关位对我们的区间取与操作不会有影响。

再考虑如何标记$lazy, 对And 和 Or 分别设置一个lazyA 和 lazyO $

$我们注意到，要取与的时候，把lazyA 一并与上， 并且把lazyO也要与上$

取或的时候只给$lazyO$取或就可以。

区间取或的操作分析同理。

再简陋的证明一下复杂度：

假设我们考虑要处理的一段区间不能进行区间处理，需要一位一位处理，但是我们这次处理之后这一段区间就可以区间处理了

再考虑，对于一段已经完好的区间，我们对它区间处理，它就会分成三段，但实际上这次的处理是$log的$

再考虑下一次处理，实际上两头又是好的，感觉又是$log$..

好吧 不口胡了，还是放官方的复杂度证明吧。。

https://csacademy.com/contest/round-70/task/and-or-max/solution

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

 #define N 200010
 int n, q, arr[N], S = ( << ) - ; 

 struct SEG
 {
     struct node
     {
         int Max, A, O, lazyA, lazyO;
         node() {}
         node(int x)
         {
             Max = A = O = x;
             lazyA = S;
             lazyO = ;
         }
         node operator + (const node &r) const
         {
             node res = node();
             res.Max = max(Max, r.Max);
             res.A = A & r.A;
             res.O = O | r.O;
             return res;
         }
         void add(int And, int Or)
         {
             Max = Max & And | Or;
             A = A & And | Or;
             O = O & And | Or;
             lazyA = lazyA & And;
             lazyO = lazyO & And | Or;
         }
     }a[N << ];
     void build(int id, int l, int r)
     {
         if (l == r)
         {
             a[id] = node(arr[l]);
             return;
         }
         int mid = (l + r) >> ;
         build(id << , l, mid);
         build(id <<  | , mid + , r);
         a[id] = a[id << ] + a[id <<  | ];
     }
     void pushdown(int id)
     {
         if (a[id].lazyA != S || a[id].lazyO)
         {
             a[id << ].add(a[id].lazyA, a[id].lazyO);
             a[id <<  | ].add(a[id].lazyA, a[id].lazyO);
             a[id].lazyA = S;
             a[id].lazyO = ;
         }
     }
     void updateA(int id, int l, int r, int ql, int qr, int val)
     {
         if (l >= ql && r <= qr && !((a[id].A ^ a[id].O) & (S ^ val)))
         {
             a[id].add(val, );
             return;
         }
         pushdown(id);
         int mid = (l + r) >> ;
         if (ql <= mid) updateA(id << , l, mid, ql, qr, val);
         if (qr > mid) updateA(id <<  | , mid + , r, ql, qr, val);
         a[id] = a[id << ] + a[id <<  | ];
     }
     void updateO(int id, int l, int r, int ql, int qr, int val)
     {
         if (l >= ql && r <= qr && !((a[id].A ^ a[id].O) & val))
         {
             a[id].add(S, val);
             return;
         }
         pushdown(id);
         int mid = (l + r) >> ;
         if (ql <= mid) updateO(id << , l, mid, ql, qr, val);
         if (qr > mid) updateO(id <<  | , mid + , r, ql, qr, val);
         a[id] = a[id << ] + a[id <<  | ];
     }
     int query(int id, int l, int r, int ql, int qr)
     {
         if (l >= ql && r <= qr) return a[id].Max;
         pushdown(id);
         int mid = (l + r) >> ;
         int res = ;
         if (ql <= mid) res = max(res, query(id << , l, mid, ql, qr));
         if (qr > mid) res = max(res, query(id <<  | , mid + , r, ql, qr));
         a[id] = a[id << ] + a[id <<  | ];
         return res;
     }
 }seg;

 void Run()
 {
     while (scanf("%d%d", &n, &q) != EOF)
     {
         for (int i = ; i <= n; ++i) scanf("%d", arr + i);
         seg.build(, , n);
         for (int qq = , op, l, r, x; qq <= q; ++qq)
         {
             scanf("%d%d%d", &op, &l, &r);
             if (op == ) printf("%d\n", seg.query(, , n, l, r));
             else
             {
                 scanf("%d", &x);
                 if (op == ) seg.updateA(, , n, l, r, x);
                 else seg.updateO(, , n, l, r, x);
             }
         }
     }
 }

 int main()
 {
     #ifdef LOCAL
         freopen("Test.in", "r", stdin);
     #endif 

     Run();
     return ;
 }