17.4.4 数据结构 校内赛（setmod）（area）（intkth）

这一回是远在上海交大的idy002给我们出题，这里遥祝他永远健康！
下面我们来看题：

1.setmod

【解题报告】
这道题一看就给人一种线段树区间修改+区间赋值的感觉。但问题是，我们知道，这两个操作都需要不同的pushdown函数来处理，这也就意味着flag的修改方式是不同的。一个是+=，另一个是=。那么怎么办呢？我们再线段树里面再加一个type参数，type记录其现在的标记类型（是被赋值，修改还是不动）。不难看出，多个操作下其类型的判断是有多种情况的：
• 空标记+赋值操作=赋值标记
• 空标记+增量操作=增量标记
• 增量标记+赋值操作=赋值标记
• 增量标记+增量操作=增量标记
• 赋值标记+增量操作=赋值标记
• 赋值标记+赋值操作=赋值标记
下面来看看具体的代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#define NAME "setmod"
#ifdef WIN32
#define Auto "%I64d"
#else
#define Auto "%lld"
#endif
using namespace std;
const int N=100000;
int a[N+5];
int n,m;
struct node;
void modify(node *nd,int lf,int rg,int L,int R,long long value);
void change(node *nd,int lf,int rg,int L,int R,long long delta);//先定义是因为pushdown里面要调用 
struct node
{
    long long sum,delta,value;
    int type;//type有三种状态：0,1,2，分别表示无标记，更改标记，赋值标记 
    node *lson,*rson;
    void pushdown(int lf,int rg)
    {   
        if(type==0)return ;
        int mid=(lf+rg)>>1;
        if(type==1)
        {
            change(lson,lf,mid,lf,mid,delta);
            change(rson,mid+1,rg,mid+1,rg,delta);
            type=0;     
        }
        else
        {
            modify(lson,lf,mid,lf,mid,value);
            modify(rson,mid+1,rg,mid+1,rg,value);
            type=0;
        }
    }
    void update()
    {
        sum=lson->sum+rson->sum;
    }
};
node dizhi[2*N+5],*root,*tail=dizhi;
node *build(int lf,int rg)
{
    node *nd=++tail;
    if(lf==rg)
    {
        nd->sum=a[lf];
        nd->type=0;
    }
    else
    {
        int mid=(lf+rg)>>1;
        nd->lson=build(lf,mid);
        nd->rson=build(mid+1,rg);
        nd->update();
        nd->type=0;
    }
    return nd;
}
void modify(node *nd,int lf,int rg,int L,int R,long long value)
{
    if(L<=lf&&rg<=R)
    {
        nd->sum=(long long)(rg-lf+1)*value;
        nd->type=2;
        nd->value=value;
        return ;
    }
    int mid=(lf+rg)>>1;
    nd->pushdown(lf,rg);
    if(L<=mid)modify(nd->lson,lf,mid,L,R,value);
    if(R>mid)modify(nd->rson,mid+1,rg,L,R,value);
    nd->update();
}
void change(node *nd,int lf,int rg,int L,int R,long long delta)
{
    if(L<=lf&&rg<=R)
    {
        nd->sum+=(long long)(rg-lf+1)*delta;
        if(nd->type==0)//空标记+增量操作=增量标记
        {
            nd->type=1;
            nd->delta=delta;
        } else if(nd->type==1)//增量标记+增量操作=增量操作 
        {
            nd->delta+=delta;
        }else if(nd->type==2)//赋值标记+增量操作=赋值操作 
        {
            nd->value+=delta;
        }
        return ;
    }
    int mid=(lf+rg)>>1;
    nd->pushdown(lf,rg);
    if(L<=mid)change(nd->lson,lf,mid,L,R,delta);
    if(R>mid)change(nd->rson,mid+1,rg,L,R,delta);
    nd->update();
}
long long query(node *nd,int lf,int rg,int L,int R)
{
    if(L<=lf&&rg<=R)return nd->sum;
    int mid=(lf+rg)>>1;
    nd->pushdown(lf,rg);
    long long rt=0;
    if(L<=mid)rt+=query(nd->lson,lf,mid,L,R);
    if(R>mid)rt+=query(nd->rson,mid+1,rg,L,R);
    nd->update();
    return rt;
}
int main()
{
    freopen(NAME".in","r",stdin);
    freopen(NAME".out","w",stdout);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    scanf("%d",&a[i]);
    root=build(1,n);
    while(m--)
    {
        char s[105];
        scanf("%s",s);
        if(s[0]=='c')
        {
            int L,R,d;
            scanf("%d%d%d",&L,&R,&d);
            change(root,1,n,L,R,d);
        }
        if(s[0]=='m')
        {
            int L,R,v;
            scanf("%d%d%d",&L,&R,&v);
            modify(root,1,n,L,R,v);
        }
        if(s[0]=='q')
        {
            int L,R;
            scanf("%d%d",&L,&R);
            printf(Auto"\n",query(root,1,n,L,R));
        }
    }
    return 0;
}

2.area

【解题报告】
这道题是要用扫描线+线段树优化：
扫描线，对于一个举行(x1,y1,x2,y2)，将它看成两个事件：在x1 这个时间将
(y1,y2) 这个区间加一，在x2+1 这个时间将(y1,y2) 这个区间减一。
这样，我们遍历整个时间，并在执行完这个时间的操作后看看有多少位置非
0, 将其数量加到答案中，就完了，当然时间不能傻傻地一个一个枚，因为关键
的时间点最多2n 个，其它时候面积是没有变的，所以要一段一段地算。
至于怎么用线段树实现那么查看有多少个非零的位置，需要注意对于任何一
个减一操作，前面一定有一个和它一样的加一操作，就只需要维护一下每个节
点被完全覆盖的次数。再用另一个来统计子树中的那些修改导致这个节点还有
多少个非零。有点像标记永久化（我们讲的第二种区间修改的写法）。
具体代码：

#include <cstdio>
#include <algorithm>

#ifdef WIN32 
#define Auto "%I64d"
#else
#define Auto "%lld"
#endif

const int N = 100000 + 10;
const int Ins = 1;
const int Del = 2;

typedef long long dnt;

struct Event {
    int type;   //  1 ins 2 del
    int time;   //  x
    int lf, rg; //  y1 y2
    Event(){}
    Event( int type, int time, int lf, int rg )
        :type(type),time(time),lf(lf),rg(rg){}
};
bool operator<( const Event &r, const Event &s ) {
    return r.time < s.time;
}
struct Node {
    int cnt,    
        sum;    
    Node *ls, *rs;
    int query( int lf, int rg ) {
        return cnt ? rg - lf + 1 : sum;
    }
    void update( int lf, int rg ) {
        int mid = (lf + rg) >> 1;
        sum = ls->query(lf,mid) + rs->query(mid+1,rg);
    }
}pool[N*2], *tail = pool, *root;

int n;
int total;
Event events[N*2]; 

Node *build( int lf, int rg ) {
    Node *nd = ++tail;
    if( lf == rg ) {
        nd->cnt = nd->sum = 0;
    } else {
        int mid = (lf + rg) >> 1;
        nd->ls = build( lf, mid );
        nd->rs = build( mid+1, rg );
        nd->cnt = nd->sum = 0;
    }
    return nd;
}
void modify( Node *nd, int lf, int rg, int L, int R, int delta ) {
    if( L <= lf && rg <= R ) {
        nd->cnt += delta;
        return;
    }
    int mid = (lf + rg) >> 1;
    if( L <= mid ) modify( nd->ls, lf, mid, L, R, delta );
    if( R > mid ) modify( nd->rs, mid+1, rg, L, R, delta );
    nd->update(lf,rg);
}

int main() {
    freopen("area.in","r",stdin);
    freopen("area.out","w",stdout);
    scanf( "%d", &n );
    for( int i = 1; i <= n; i++ ) {
        int x1, y1, x2, y2;
        scanf( "%d%d%d%d", &x1, &y1, &x2, &y2 );
        events[total++] = Event( Ins, x1, y1, y2 );
        events[total++] = Event( Del, x2+1, y1, y2 );
    }
    std::sort( events, events + total );
    root = build( 1, n );
    dnt area = 0;
    for( int i = 0,j; i < total; i = j + 1 ) {
        for( j = i; j + 1 < total && events[j+1].time == events[i].time; j++ );
        for( int k = i; k <= j; k++ ) {
            modify( root, 1, n, events[k].lf, events[k].rg, events[k].type == Ins ? +1 : -1 );
        }
        if( j != total-1 ) {
            area += (dnt)root->query(1,n) * (events[j+1].time - events[i].time);
        }
    }
    printf( Auto"\n", area );
}

3.intkth

【解题报告】
我们以前做过一个值域区间第k大的查找，我们知道这个要用值域线段树解决。可这个地方是区间第k大，显然就不能如法炮制了。std的做法是这样的：树状数组套可持久化值域线段树，每次询问就是对O(logn) 棵树加加减减后求第k大。修改也会同时修改O(logn) 棵树，所以总的复杂度是：O((m+n)log2n)。
具体代码如下：

#include <cstdio>
#include <vector>
using namespace std;
const int N = 100010;
struct Node 
{
    int cnt;
    Node *ls, *rs;
}pool[N*200],*tail=pool,*roots[N],*null;
int n,q;
int aa[N];
Node *va[10000],*vb[10000];
int ca,cb;
void init()
{
    null=++tail;
    null->ls=null;
    null->rs=null;
    null->cnt=0;
}
Node *newnode()
{
    Node *nd=++tail;
    nd->ls=null;
    nd->rs=null;
    nd->cnt=0;
    return nd;
}
void modify(int lf,int rg,int pos,int delta)
{
    for(int t=0;t<ca;t++)
    va[t]->cnt+=delta;
    if(lf==rg)return ;
    int mid=(lf+rg)>>1;
    if(pos<=mid)
    {
        for(int t=0;t<ca;t++)
        {
            if(va[t]->ls==null) 
            va[t]->ls=newnode();
            va[t]=va[t]->ls;
        }
        modify(lf,mid,pos,delta);
    }else
    {
        for(int t=0;t<ca;t++)
        {
            if(va[t]->rs==null)
            va[t]->rs=newnode();
            va[t]=va[t]->rs;
        }
        modify(mid+1,rg,pos,delta);
    }
}
int query_seg(int lf,int rg,int k)
{
    if(lf==rg)return lf;
    int mid=(lf+rg)>>1;
    int lz=0;
    for(int t=0;t<ca;t++)lz+=va[t]->ls->cnt;
    for(int t=0;t<cb;t++)lz-=vb[t]->ls->cnt;
    if(k<=lz)
    {
        for(int t=0;t<ca;t++)
        va[t]=va[t]->ls;
        for(int t=0;t<cb;t++)
        vb[t]=vb[t]->ls;
        return query_seg(lf,mid,k);
    }
    else
    {
        for(int t=0;t<ca;t++)
        va[t]=va[t]->rs;
        for(int t=0;t<cb;t++)
        vb[t]=vb[t]->rs;
        k-=lz;
        return query_seg(mid+1,rg,k);
    }
}
void modify(int u,int x,int delta)
{
    ca=0;
    for(int i=u;i<=n;i+=i&-i) 
    va[ca++]=roots[i];
    modify(1,n,x,delta);
}
void modify(int u,int x)
{
    modify(u,aa[u],-1);
    modify(u,x,+1);
    aa[u]=x;
}
int query(int l,int r,int k)
{
    ca=cb=0;
    for(int i=r;i;i-=i&-i)
    va[ca++]=roots[i];
    for(int i=l-1;i;i-=i&-i)
    vb[cb++]=roots[i];
    return query_seg(1,n,k);
}

int main() {
    freopen("intkth.in","r",stdin);
    freopen("intkth.out","w",stdout);
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++)
    scanf("%d",aa+i);
    init();
    for(int i=1;i<=n;i++)
    roots[i]=newnode();
    for(int i=1;i<=n;i++)
    modify(i,aa[i],+1);
    while(q--)
    {
        char ss[100];
        scanf("%s",ss);
        if(ss[0]=='q')
        {
            int l,r,k;
            scanf("%d%d%d",&l,&r,&k);
            printf("%d\n",query(l,r,k));
        }
        else
        {
            int pos,val;
            scanf("%d%d",&pos,&val);
            modify(pos,val);
        }
    }

}