FZU2105 线段树 （按位操作）

题目：

Given N integers A={A[0],A[1],...,A[N-1]}. Here we have some operations:

（元素和操作元素 < 16）

Operation 1: AND opn L R

Here opn, L and R are integers.

For L≤i≤R, we do A[i]=A[i] AND opn (here "AND" is bitwise operation).

Operation 2: OR opn L R

Here opn, L and R are integers.

For L≤i≤R, we do A[i]=A[i] OR opn (here "OR" is bitwise operation).

Operation 3: XOR opn L R

Here opn, L and R are integers.

For L≤i≤R, we do A[i]=A[i] XOR opn (here "XOR" is bitwise operation).

Operation 4: SUM L R

We want to know the result of A[L]+A[L+1]+...+A[R].

这个题用线段树解决主要在于两个问题：

1、标记表示：如果简单设置3个布尔类型的变量表示3个操作的标记的话，要考虑标记对自己本身的影响和标记间的相互影响，程序会反而复杂，而如果用一个数组记录区间内所有数中每一位（二进制位，共4位）的1的个数，则可以省略and和or两个标记以及sum变量，空间节省不少，程序也简单很多（主要是考虑标记下传的时候方便一些）

说明：

区间的和可以表示为，每一位上1的总个数 * 对应位的权值（1， 2， 4， 8）的和

and操作和or操作都是把当前节点的1的个数置0或者赋为cnt（区间内数的个数），同时又可以通过判断节点的1的个数是否为0或者cnt来表示是否有标记（and或者or，但已不重要，最终只关心1的个数）

2：pushDown()函数的设计：pushDown()函数是区间修改的核心，作用是线段树标记下传过程中维护标记以及节点的它信息，使线段树时时刻刻保持“正确有序”的姿态, 具体参见代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#define mem0(a) memset(a, 0, sizeof(a))
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define lr rt << 1
#define rr rt << 1 | 1
using namespace std;
#define LL __int64
struct seg_tree{
        int mark;// xor operations' mark
        int cnt[4];//four digits' count(used for other operations)
}tree[1000010 << 2];

void pushUp(int rt)
{
        for(int i = 0; i < 4; i++) {
                tree[rt].cnt[i] = tree[rt << 1].cnt[i] + tree[rt << 1 | 1].cnt[i];
        }
}

void pushDown(int rt, int cnt)
{
        seg_tree &t = tree[rt], &tl = tree[rt << 1], &tr = tree[rt << 1 | 1];
        int lc = cnt - (cnt >> 1), rc = cnt >> 1;
        for(int i = 0; i < 4; i++) {                             // 按位处理
                if(t.cnt[i] == cnt || t.cnt[i] == 0) {           // 是否全部是0或1
                        tl.mark &= (~(1 << i));                  // 左右儿子的标记清0，因为此时以前xor标记不起作用了
                        tr.mark &= (~(1 << i));
                        tl.cnt[i] = t.cnt[i] > 0 ? lc : 0;      // 儿子的1的个数与当前对应
                        tr.cnt[i] = t.cnt[i] > 0 ? rc : 0;
                        t.mark &= (~(1 << i));                  // 当前的xor标记清0， 因为子孙的1的个数与当前对应, 当前标记不对当前起作用，
                                                                //那么也不会对子孙起作用
                }
                if(t.mark & (1 << i)) {
                        tl.cnt[i] = lc - tl.cnt[i];
                        tr.cnt[i] = rc - tr.cnt[i];
                        tl.mark ^= (1 << i);
                        tr.mark ^= (1 << i);
                        t.mark &= (~(1 << i));
                }
        }
}

void work(int x, int k, int rt, int cnt)
{
        for(int i = 0; i < 4; i++) {
                if(x & (1 << i)) {
                        if(k == 0) tree[rt].cnt[i] = cnt - tree[rt].cnt[i], tree[rt].mark ^= (1 << i);
                        if(k == 1) tree[rt].cnt[i] = cnt, tree[rt].mark &= (~(1 << i));
                }
                else {
                        if(k == 2) tree[rt].cnt[i] = 0, tree[rt].mark &= (~(1 << i));
                }
        }
}

int calc(int cnt[])
{
        int sum = 0;
        for(int i = 0; i < 4; i++) {
                sum += cnt[i] * (1 << i);
        }
        return sum;
}

void build(int l, int r, int rt)
{
        tree[rt].mark = 0;
        if(l == r) {
                int x;
                scanf("%d", &x);
                for(int i = 0; i < 4; i++) {
                        tree[rt].cnt[i] = ((x & (1 << i)) > 0);
                }
                return;
        }
        int m = (l + r) >> 1;
        build(lson);
        build(rson);
        pushUp(rt);
}
int query(int L, int R, int l, int r, int rt)
{
        if(L <= l && r <= R) {
                return calc(tree[rt].cnt);
        }
        int m = (l + r) >> 1, res = 0;
        pushDown(rt, r - l + 1);
        if(L <= m) res += query(L, R, lson);
        if(R > m) res += query(L, R, rson);
        return res;
}

void update(int L, int R, int x, int k, int l, int r, int rt)
{
        if(L <= l && r <= R) {
                work(x, k, rt, r - l + 1);
                return;
        }
        int m = (l + r) >> 1;
        pushDown(rt, r - l + 1);
        if(L <= m) update(L, R, x, k, lson);
        if(R > m) update(L, R, x, k, rson);
        pushUp(rt);
}

int main(){
        //freopen("input.txt", "r", stdin);
        int T;
        cin >> T;
        while(T--) {
                int n, m;
                cin >> n >> m;
                build(1, n, 1);
                for(int i = 1; i <= m; i++) {
                        int a, b;
                        char s[10];
                        scanf("%s%d%d", s, &a, &b);
                        char ch = s[0];
                        if(s[0] == 'S') printf("%d
", query(a + 1, b + 1, 1, n, 1));
                        else {
                                int c;
                                scanf("%d", &c);
                                if(ch == 'X') update(b + 1, c + 1, a, 0, 1, n, 1);
                                if(ch == 'O') update(b + 1, c + 1, a, 1, 1, n, 1);
                                if(ch == 'A') update(b + 1, c + 1, a, 2, 1, n, 1);
                        }
                }
        }
}