HDU 3397 Sequence operation

Sequence operation

Time Limit: 5000ms

Memory Limit: 32768KB

This problem will be judged on HDU. Original ID: 3397
64-bit integer IO format: %I64d      Java class name: Main

lxhgww got a sequence contains n characters which are all '0's or '1's.
We have five operations here:
Change operations:
0 a b change all characters into '0's in [a , b]
1 a b change all characters into '1's in [a , b]
2 a b change all '0's into '1's and change all '1's into '0's in [a, b]
Output operations:
3 a b output the number of '1's in [a, b]
4 a b output the length of the longest continuous '1' string in [a , b]

 

Input

T(T<=10) in the first line is the case number.
Each case has two integers in the first line: n and m (1 <= n , m <= 100000).
The next line contains n characters, '0' or '1' separated by spaces.
Then m lines are the operations:
op a b: 0 <= op <= 4 , 0 <= a <= b < n.

 

Output

For each output operation , output the result.

 

Sample Input

1
10 10
0 0 0 1 1 0 1 0 1 1
1 0 2
3 0 5
2 2 2
4 0 4
0 3 6
2 3 7
4 2 8
1 0 5
0 5 6
3 3 9

Sample Output

5
2
6
5

Source

HDOJ Monthly Contest – 2010.05.01

 

解题：线段树。。。

 

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct node {
    int lt,rt,cover;
} tree[maxn<<2];
inline void pushup(int v) {
    if(tree[v<<1].cover == tree[v<<1|1].cover)
        tree[v].cover = tree[v<<1].cover;
    else tree[v].cover = -1;
}
inline void pushdown(int v) {
    if(tree[v].cover >= 0) {
        tree[v<<1].cover = tree[v<<1|1].cover = tree[v].cover;
        tree[v].cover = -1;
    }
}
void build(int L,int R,int v) {
    tree[v].lt = L;
    tree[v].rt = R;
    if(L == R) {
        scanf("%d",&tree[v].cover);
        return;
    }
    int mid = (L + R)>>1;
    build(L,mid,v<<1);
    build(mid+1,R,v<<1|1);
    pushup(v);
}
void update(int lt,int rt,int val,int v) {
    if(tree[v].cover == val) return;
    if(lt <= tree[v].lt && rt >= tree[v].rt) {
        tree[v].cover = val;
        return;
    }
    pushdown(v);
    if(lt <= tree[v<<1].rt) update(lt,rt,val,v<<1);
    if(rt >= tree[v<<1|1].lt) update(lt,rt,val,v<<1|1);
    pushup(v);
}
void update(int lt,int rt,int v) {
    if(lt <= tree[v].lt && rt >= tree[v].rt && tree[v].cover >= 0) {
        tree[v].cover ^= 1;
        return;
    }
    pushdown(v);
    if(lt <= tree[v<<1].rt) update(lt,rt,v<<1);
    if(rt >= tree[v<<1|1].lt) update(lt,rt,v<<1|1);
    pushup(v);
}
int ret;
void query(int lt,int rt,int v) {
    if(!tree[v].cover) return;
    if(lt <= tree[v].lt && rt >= tree[v].rt && tree[v].cover >= 0) {
        ret += tree[v].cover?tree[v].rt - tree[v].lt + 1:0;
        return;
    }
    pushdown(v);
    if(lt <= tree[v<<1].rt) query(lt,rt,v<<1);
    if(rt >= tree[v<<1|1].lt) query(lt,rt,v<<1|1);
    pushup(v);
}
void query(int lt,int rt,int &r,int &ans,int v) {
    if(!tree[v].cover) return;
    if(lt <= tree[v].lt && rt >= tree[v].rt && tree[v].cover >= 0) {
        if(tree[v].cover) {
            if(r == tree[v].lt - 1) ans += tree[v].rt - tree[v].lt + 1;
            else ans = tree[v].rt - tree[v].lt + 1;
            r = tree[v].rt;
            ret = max(ret,ans);
        }
        return;
    }
    pushdown(v);
    if(lt <= tree[v<<1].rt) query(lt,rt,r,ans,v<<1);
    if(rt >= tree[v<<1|1].lt) query(lt,rt,r,ans,v<<1|1);
    pushup(v);
}
int main() {
    int T,n,m,op,a,b;
    scanf("%d",&T);
    while(T--) {
        scanf("%d %d",&n,&m);
        build(0,n-1,1);
        while(m--) {
            scanf("%d %d %d",&op,&a,&b);
            switch(op) {
            case 0:
            case 1:
                update(a,b,op,1);
                break;
            case 2:
                update(a,b,1);
                break;
            case 3:
                ret = 0;
                query(a,b,1);
                printf("%d
",ret);
                break;
            case 4:int ans = ret = 0,r = -1;
                query(a,b,r,ans,1);
                printf("%d
",ret);
                break;
            }
        }
    }
    return 0;
}