FZU 2105Digits Count(线段树 + 成段更新)

Description

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

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].

Now can you solve this easy problem?

Input

The first line of the input contains an integer T, indicating the number of test cases. (T≤100)

Then T cases, for any case, the first line has two integers n and m (1≤n≤1,000,000, 1≤m≤100,000), indicating the number of elements in A and the number of operations.

Then one line follows n integers A[0], A[1], ..., A[n-1] (0≤A[i]<16,0≤i<n).

Then m lines, each line must be one of the 4 operations above. (0≤opn≤15)

Output

For each test case and for each "SUM" operation, please output the result with a single line.

Sample Input

1 4 4 1 2 4 7 SUM 0 2 XOR 5 0 0 OR 6 0 3 SUM 0 2

Sample Output

7 18

Hint

A = [1 2 4 7]

SUM 0 2, result=1+2+4=7;

XOR 5 0 0, A=[4 2 4 7];

OR 6 0 3, A=[6 6 6 7];

SUM 0 2, result=6+6+6=18.

大神说，经过若干次的操作就会出现很多相同的，然后懒惰标记就用来记做 这个区间又没用相同的

 #include <iostream>
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
 using namespace std;
 typedef long long LL;
 const int Max =  + ;
 int n, m;
 struct Node
 {
     int l, r;
     int num;
 };
 Node node[Max * ];
 int A[Max];
 void buildtree(int l, int r, int k)
 {
     node[k].l = l;
     node[k].r = r;
     node[k].num = -;
     if (l == r)
     {
         node[k].num = A[l];
         return;
     }
     int mid = (l + r) / ;
     buildtree(l, mid, k * );
     buildtree(mid + , r, k *  + );
     if (node[k * ].num >=  && node[k * ].num == node[k *  + ].num) // 如果左边区间和右边区间 num 相同，就要更改父节点
     {
         node[k].num = node[k * ].num;
     }
 }
 int getopt(int num, int opn, int opt)
 {
     if (opt == )
         return opn & num;
     if (opt == )
         return opn | num;
     if (opt == )
         return (opn ^ num);
     return ;
 }
 void update(int l, int r, int k, int opn, int opt)
 {
     if (node[k].l == l && node[k].r == r && node[k].num >= )
     {
        // 区间【l, r】上的数是相同的，只需改一次就ok了
         node[k].num = getopt(node[k].num, opn, opt);
         return;
     }
    // 不相同的话就继续往左右两边改
     if (node[k].num >= )  // 在改的过程中发现该点标记过，分给子节点，去掉自己的标记
     {
         node[k * ].num = node[k *  + ].num = node[k].num;
         node[k].num = -;
     }
     int mid = (node[k].l + node[k].r) / ;
     if (r <= mid)
         update(l, r, k * , opn, opt);
     else if (mid < l)
     {
         update(l, r, k *  + , opn, opt);
     }
     else
     {
         update(l, mid, k * , opn, opt);
         update(mid + , r, k *  + , opn, opt);
     }
     if (node[k * ].num >=  && node[k * ].num == node[k *  + ].num)
         node[k].num = node[k * ].num;
 }
 LL querry(int l, int r, int k)
 {
     if (node[k].l == l && node[k].r == r && node[k].num >= )
     {
         return (LL) node[k].num * (LL) (node[k].r - node[k].l + );
     }
     if (node[k].num >= )
     {
         node[k * ].num = node[k *  + ].num = node[k].num;
         node[k].num = -;
     }
     int mid = (node[k].r + node[k].l) / ;
     if (r <= mid)
     {
         return querry(l, r, k * );
     }
     else if (mid < l)
     {
         return querry(l, r, k *  + );
     }
     else
         return querry(l, mid, k * ) + querry(mid + , r, k *  + );
 }
 int main()
 {
     int t;
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d%d", &n, &m);
         for (int i = ; i <= n; i++)
             scanf("%d", &A[i]);
         buildtree(, n, );
         while (m--)
         {
             char opt[];
             int opn, a, b;
             scanf("%s", opt);
             if (opt[] == 'S')
             {
                 scanf("%d%d", &a, &b);
                 printf("%I64d\n", querry(a + , b + , ));
             }
             else
             {
                 scanf("%d%d%d", &opn, &a, &b);
                 if (opt[] == 'A')
                 {
                     update(a + , b + , , opn, );
                 }
                 else if (opt[] == 'O')
                 {
                     update(a + , b + , , opn, );
                 }
                 else
                     update(a + , b + , , opn, );
             }
         }
     }
     return ;
 }