2014-2015 Codeforces Trainings Season 2 Episode 7 G Gophers --线段树

题意： 有n个地鼠，m个CD碟，每个CD碟有一个影响范围，范围内的地鼠都会被吵到，每次有一个操作就是移动CD碟，然后求每次被影响的地鼠有多少只。

解法： 线段树做。我们只关注地鼠有没有被吵到就可以了，之前我还去把所有可能移到的位置都存下来离散化一下，然后维护也维护错了。一堆bug，真是想多了。

线段树维护两个值：  cntS[rt]表示该段被多少个区间所覆盖， NOG[rt]表示此区间内没有被影响到的地鼠有多少个。

那么我们更新到区间，然后直接pushup即可， 因为更新到区间的时候已经可以确定NOG[rt]了：

如果 l == r ： 说明是叶子节点， 那么如果cntS[rt] > 0，NOG[rt]就为0，否则为1

否则，如果cntS[rt] = 0 , 那么 NOG[rt] = NOG[2*rt]+NOG[2*rt+1],  否则说明这段被区间覆盖，NOG[rt] = 0.

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
using namespace std;
#define N 501007
 
int NOG[*N],cntS[*N];
struct Shift{
    int L1,R1,L2,R2;
}sf[];
int x[],b[];
int seg[][];
 
void pushup(int l,int r,int rt)
{
    if(l == r)
    {
        if(cntS[rt]) NOG[rt] = ;
        else         NOG[rt] = ;
        return;
    }
    if(!cntS[rt]) NOG[rt] = NOG[rt<<] + NOG[rt<<|];
    else          NOG[rt] = ;
}
 
void build(int l,int r,int rt)
{
    cntS[rt] = ;
    if(l == r)
    {
        NOG[rt] = ;
        return;
    }
    int mid = (l+r)/;
    build(l,mid,*rt);
    build(mid+,r,*rt+);
    pushup(l,r,rt);
}
 
void update(int l,int r,int aa,int bb,int val,int rt)
{
    if(aa <= l && bb >= r)
    {
        cntS[rt] += val;
        pushup(l,r,rt);
        return;
    }
    int mid = (l+r)/;
    if(aa <= mid)
        update(l,mid,aa,bb,val,*rt);
    if(bb > mid)
        update(mid+,r,aa,bb,val,*rt+);
    pushup(l,r,rt);
}
 
int main()
{
    int n,m,d,l,i,j,val,p,r;
    while(scanf("%d%d%d%d",&n,&m,&d,&l)!=EOF)
    {
        x[] = ;
        for(i=;i<=n;i++)
            scanf("%d",&x[i]);
        for(i=;i<=m;i++)
        {
            scanf("%d",&val);
            seg[i][] = max(,val-l);
            seg[i][] = min(,val+l);
        }
        for(i=;i<=d;i++)
        {
            scanf("%d%d",&p,&r);
            sf[i].L1 = max(,p-l);
            sf[i].R1 = min(,p+l);
            sf[i].L2 = max(,r-l);
            sf[i].R2 = min(,r+l);
        }
        build(,n,);
        for(i=;i<=m;i++)
        {
            int L = lower_bound(x+,x+n+,seg[i][])-x;
            int R = upper_bound(x+,x+n+,seg[i][])-x;
            R--;
            update(,n,L,R,,);
        }
        printf("%d\n",n-NOG[]);
        for(i=;i<=d;i++)
        {
            int L1 = lower_bound(x+,x+n+,sf[i].L1)-x;
            int R1 = upper_bound(x+,x+n+,sf[i].R1)-x-;
            int L2 = lower_bound(x+,x+n+,sf[i].L2)-x;
            int R2 = upper_bound(x+,x+n+,sf[i].R2)-x-;
            update(,n,L1,R1,-,);
            update(,n,L2,R2,,);
            printf("%d\n",n-NOG[]);
        }
    }
    return ;
}