Light on or off

最新推荐文章于 2020-05-19 23:02:57 发布

原创最新推荐文章于 2020-05-19 23:02:57 发布 · 933 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#query #numbers #output #integer #build #each

线段树专栏收录该内容

11 篇文章

订阅专栏

本文解析了一道关于线段树的经典题目，通过实例详细介绍了如何使用线段树进行区间更新和查询操作，特别关注了区间反转操作的实现细节。

一道曾经校赛的题目，也算是线段树的一道很好的题。

http://222.196.33.254/oj/showproblem?problem_id=1684

Description

There is N lights on the wall of Dreamone’s house from left to right.Initially,some lights on and some lights
off, and we use ‘1’ represented the light on, use ‘0’ represented the light off. As we know, there is a cat in
dremone’s house, and she is very naught. She always change the status continuously from Ath light to Bth
one. (1<=A, B<=N).If the light is on, then the light will be off, If the light is off, then the light will be on.
Actually, she can do it K times like this. Then the cat puts forward another problem: How many lights on
from Cth light to Dth (1<=C, D<=N) one? For example:
When N=4 K=2, and the initial status is assumed as:
1 0 1 1
‘1’ represented on,’0’ represented off.
From the initial status we can get: There is 3 lights on from 1st light to 4th, 2 lights on from 2nd to 4th and so
on. Then we assume the first operation that we change the status from 2nd to 4th, and then the status will be:
1 1 0 0
Then there are 2 lights on from 1st light to 4th one, 1 light on from 2nd to 4th one and so on. Then the second
operation is assumed as from the 1st to 2nd .Then the status will be 0 0 0 0. And there will be no lights on.
Can you get the main idea? Can you help the naught cat?

Input

The first line of input will be a positive integer indicating how many test cases will be included (T) and T
will be less than 10. Each of the next T cases will contain two parts:
The first part: two integer N, K (1<=N<=100000, 1<=K<=100000)
The second part: N numbers (which is ‘0’ or ‘1’) represented the initial status from left to right.
Then third part: K lines. Each line will be X C D (1<=C, D<=N) X is a letter which is either ‘Q’ or ‘C’. If
X=’Q’, you will be output the numbers of lights on from Cth to Dth, and if X=’C’, you will be change the
status of lights as the rules described above.

Output

For each query,(when X=’Q’)，you should output the numbers of lights on. What’s more, you must output a
blank line after you have processed a test case.

Sample Input

Sample Output

/* 
 * File:   main.cpp
 * Author: Mi
 *这个题需要成端更新，但有一个特点是，在改变一段线段时需要改变到节点
 *其实仔细想想不用修改到最底层，因为只有两种状态开灯和关灯，开一次关一次又回到了以前的状态
 * 所以只用一个state(0,表示和原来一样，1表示要修改)保存是不是需要修改这条线段，sum保存有多少个灯开
 * 这样想就很简单的变成了线段的成段更新，如果在查找时发现T[root].l==l&&T[root].r==r不满足，
 * 需要往下找，如果T[root].state=1，那么就要改变左右子树的状态，这个题和其他的成段更新不同的地方就在
 * 这里，一般的题直接把父亲的状态传给左右儿子，因为那样的题不存在对最底层的修改，直接往下传递就可以了
 *而这个题需要更新到最底层，所以在只能根据左右子树自己的状态来更新自己，就只是求一个反
 * T[root<<1].state=1-T[root<<1].state,T[root<<1].sum=T[root<<1].r-T[root].l+1-T[root<<1].sum
 * 右子树跟新方法类似
 * 其它的地方和一般的线段树成段更新一样
 * Created on 2011年3月16日, 下午10:24
 */
#include <cstdlib>
#include <stdio.h>
#include <string.h>
#define N 100500
/*
 * 
 */
int v[N];
void swap(int &a,int &b)
{
    a^=b;
    b^=a;
    a^=b;
}
struct tree
{
    int l,r,sum,state;
    int mid()
    {
        return (l+r)>>1;
    }
}T[N*4];
void build(int l,int r,int root)
{
    T[root].l=l,T[root].r=r;
    T[root].state=0;
    if(l==r)
    {
        T[root].sum=v[l];
        return ;
    }
    int mid=T[root].mid();
    build(l,mid,root<<1);
    build(mid+1,r,root<<1|1);
    T[root].sum=T[root<<1].sum+T[root<<1|1].sum;
}
void modify(int l,int r,int root)
{
    if(T[root].l==l&&T[root].r==r)
    {
        T[root].state=1-T[root].state;
        T[root].sum=T[root].r-T[root].l+1-T[root].sum;
        return ;
    }
    if(T[root].state)
    {
        T[root<<1].state=1-T[root<<1].state;
        T[root<<1|1].state=1-T[root<<1|1].state;
        T[root<<1].sum=T[root<<1].r-T[root<<1].l+1-T[root<<1].sum;
        T[root<<1|1].sum=T[root<<1|1].r-T[root<<1|1].l+1-T[root<<1|1].sum;
        T[root].state=0;
    }
    int mid=T[root].mid();
    if(r<=mid)
        modify(l,r,root<<1);
    else if(l>=mid+1)
        modify(l,r,root<<1|1);
    else
    {
        modify(l,mid,root<<1);
        modify(mid+1,r,root<<1|1);
    }
    T[root].sum=T[root<<1].sum+T[root<<1|1].sum;
}
void query(int l,int r,int root,int &ans)
{
    if(T[root].l==l&&T[root].r==r)
    {
        ans+=T[root].sum;
        return ;
    }
    if(T[root].state)
    {
        T[root<<1].state=1-T[root<<1].state;
        T[root<<1|1].state=1-T[root<<1|1].state;
        T[root<<1].sum=T[root<<1].r-T[root<<1].l+1-T[root<<1].sum;
        T[root<<1|1].sum=T[root<<1|1].r-T[root<<1|1].l+1-T[root<<1|1].sum;
        T[root].state=0;
    }
    int mid=T[root].mid();
    if(r<=mid)
        query(l,r,root<<1,ans);
    else if(l>=mid+1)
        query(l,r,root<<1|1,ans);
    else
    {
        query(l,mid,root<<1,ans);
        query(mid+1,r,root<<1|1,ans);
    }
}
int main(int argc, char** argv) 
{
    int t,n,q,i;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&q);        
        for(i=1;i<=n;i++)
            scanf("%d",&v[i]);
        build(1,n,1);
        while(q--)
        {
        char str[2];
        int a,b,ans=0;
        scanf("%s%d%d",str,&a,&b);
        if(a>b)
            swap(a,b);
        if(str[0]=='Q')
        {
            query(a,b,1,ans);
            printf("%d/n",ans);
        }
        else
            modify(a,b,1);
        }
        puts("");
    }
    return 0;
}