FZU Problem 2105 Digits Count

Problem 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 <stdio.h>
#include <string.h>
const int N = ;

int c, res, a[N*][], flag[N*][], len[N*];

void pushDown( int rt )
{
    int ls =  * rt; int rs = ls | ;
    for( int i = ; i < ; ++i )
    {
        if( flag[rt][i] == - ) continue;
        if( flag[rt][i] ==  || flag[rt][i] ==  )
        {
            a[ls][i] = ( flag[ls][i] = flag[rt][i] ) * len[ls];
            a[rs][i] = ( flag[rs][i] = flag[rt][i] ) * len[rs];
            flag[rt][i] = -;
        }
        else if( flag[rt][i] ==  )
        {
            flag[rt][i] = -;
        }
        else
        {
            a[ls][i] = len[ls] - a[ls][i];
            if( flag[ls][i] == - ) flag[ls][i] = ;
            else flag[ls][i] ^= ;
            a[rs][i] = len[rs] - a[rs][i];
            if( flag[rs][i] == - ) flag[rs][i] = ;
            else flag[rs][i] ^= ;
            flag[rt][i] = -;
        }

    }
}

void pushUp( int rt )
{
    int ls =  * rt; int rs = ls | ;
    for( int i = ; i < ; ++i )
        a[rt][i] = a[ls][i] + a[rs][i];
}

void build( int l, int r, int rt )
{
    len[rt] = r - l + ;
    if( l == r )
    {
        scanf("%d", &c);
        for( int i = ; i < ; ++i )
            a[rt][i] = (  & (c>>i) );
    }
    else
    {
        int mid = ( l + r ) / ;
        build(l, mid,  * rt);
        build(mid + , r,  * rt + );
        pushUp( rt );
    }
}

void OR( int rt, int opn )
{
    for( int i = ; i < ; ++i )
    {
        if( !( (opn>>i) &  ) ) continue;
        flag[rt][i] = ;
        a[rt][i] = len[rt];
    }
}

void ADD( int rt, int opn )
{
    for( int i = ; i < ; ++i )
    {
        if( (opn>>i) &  ) continue;
        flag[rt][i] = ;
        a[rt][i] = ;
    }
}

void XOR( int rt, int opn )
{
    for( int i = ; i < ; ++i )
    {
        if( !( (opn>>i) &  ) ) continue;
        if( flag[rt][i] == - ) flag[rt][i] = ;
        else flag[rt][i] ^= ;
        a[rt][i] = len[rt] - a[rt][i];
    }
}

void query( int l, int r, int rt, const int aa, const int bb )
{
    if( aa <= l && r <= bb )
    {
        res = res + a[rt][] + a[rt][] *  + a[rt][] *  + a[rt][] * ;
        return;
    }
    pushDown( rt );
    int mid = ( l + r ) / ;
    int ls =  * rt; int rs = ls | ;
    if( mid >= aa ) query( l, mid, ls, aa, bb );
    if( mid < bb ) query( mid + , r, rs, aa, bb );
}

void update( int l, int r, int rt, const int aa, const int bb, const int opn, const int f )
{
    if( aa <= l && r <= bb )
    {
        switch( f )
        {
            case : OR( rt, opn ); break;
            case : ADD( rt, opn ); break;
            case : XOR( rt, opn ); break;
        }
        return;
    }
    pushDown( rt );
    int mid = ( l + r ) / ;
    int ls =  * rt; int rs = ls | ;
    if( mid >= aa ) update( l, mid, ls, aa, bb, opn, f );
    if( mid < bb ) update( mid + , r, rs, aa, bb, opn, f );
    pushUp( rt );
}

int main()
{
    int t, n, m, aa, bb, opn; char cmd[];
    scanf("%d", &t);
    while( t-- )
    {
        memset( flag, -, sizeof(flag) );
        scanf("%d%d", &n, &m);
        build(, n-, );
        while( m-- )
        {
            scanf("%s", cmd);
            if( cmd[] == 'S' )
            {
                scanf("%d%d", &aa, &bb);
                res = ;
                query( , n - , , aa, bb );
                printf("%d\n", res);
            }
            else
            {
                scanf("%d%d%d", &opn, &aa, &bb);
                switch( cmd[] )
                {
                    case 'O': update(, n-, , aa, bb, opn, ); break;
                    case 'A': update(, n-, , aa, bb, opn, ); break;
                    case 'X': update(, n-, , aa, bb, opn, ); break;
                    default : break;
                }
            }
        }
    }
    return ;
}