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