sdut 2159 Ivan comes again!(2010年山东省第一届ACM大学生程序设计竞赛) 线段树+离散

先看看上一个题：

题目大意是： 矩阵中有N个被标记的元素，然后针对每一个被标记的元素e（x，y），你要在所有被标记的元素中找到一个元素E（X，Y），使得X>x并且Y>y，如果存在多个满足条件的元素，先比较X，选择X最小的那个，如果还是有很多满足条件的元素，再比较Y，选择Y最小的元素，如果不存在就输出两个-1；

分析： 直接暴力就行了

这个题目大意：

这个题是上个题的坚强版，每次会增加或减少一个点，仍然找到一个元素E（X，Y），使得X>x并且Y>y；

最多有200000次操作，每次只能是O(logn)的查询，行有1000000000之大，但是最多只会出现200000个不同的行，所以要离散化一下。然后对于每行的所有列用set去存，用线段树来维护每一行的出现的最大列，具体看代码吧

 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<set>
#include<queue>
#include<stack>
#define MAXN 200010

using namespace std;

int Max[MAXN<<2], b[MAXN], c[MAXN], cnt;
set<int>sy[MAXN];
struct node
{
    int x, y, flag;
} n[300000];
void PushUp(int root)
{
    Max[root]=max(Max[root*2],Max[root*2+1]);
}
void Update(int p, int x, int L, int R, int root) //a[p]=x,并且更新最大值
{
    if(L==R)
    {
        Max[root]=x;
        return ;
    }
    int mid=(L+R)/2;
    if(p<=mid) Update(p,x,L,mid,root*2);
    else Update(p,x,mid+1,R,root*2+1);
    PushUp(root);
}
int Query(int num, int post_ll, int L, int R, int root)//从post_ll这个位置开始向右查找，返回大于等于num的位置下表
{
    if(L==R)
    {
        if(Max[root]>=num) return L;
        else return -1;
    }
    int ans=-1, mid=(L+R)/2;
    if(post_ll<=mid&&Max[root*2]>=num) ans=Query(num,post_ll,L,mid,root*2);
    if(ans!=-1) return ans;
    if(Max[root*2+1]>=num) ans=Query(num,post_ll,mid+1,R,root*2+1);
    return ans;
}

int BS1(int x)
{
    int low=0, high=cnt, mid;
    while(low<=high)
    {
        mid=low+high>>1;
        if(c[mid]==x) return mid;
        else if(c[mid]>x) high=mid-1;
        else low=mid+1;
    }
}
int BS2(int x)
{
    int low=0, high=cnt, mid, ans=-1;
    while(low<=high)
    {
        mid=low+high>>1;
        if(c[mid]>x)
        {
            ans=mid;
            high=mid-1;
        }
        else low=mid+1;
    }
    return ans;
}
void init(int nn)
{
    for(int i=0; i<nn; i++)
        sy[i].clear();
    memset(Max,-1,sizeof(Max));
}
int main()
{
    int nn, x, tot, ans, cas=0;
    char cmd[20];
    while(scanf("%d",&nn)!=EOF&&nn)
    {
        cnt=tot=0;
        init(nn);
        for(int i=0; i<nn; i++)
        {
            scanf("%s%d%d",cmd,&n[i].x,&n[i].y);
            if(!strcmp(cmd,"add"))
            {
                n[i].flag=1;
                b[tot++]=n[i].x;
            }
            else if(!strcmp(cmd,"find"))
                n[i].flag=2;
            else n[i].flag=3;
        }
        sort(b,b+tot);
        c[0]=b[0];
        for(int i=1; i<tot; i++)
        {
            if(b[i]!=b[i-1])
                c[++cnt]=b[i];
        }//离散化
        printf("Case %d:
",++cas);
        for(int i=0; i<nn; i++)
        {
            if(n[i].flag==1)
            {
                x=BS1(n[i].x);
                sy[x].insert(n[i].y);
                Update(x,*(--sy[x].end()),0,cnt,1);
            }
            else if(n[i].flag==2)
            {
                x=BS2(n[i].x);
                if(x==-1)
                {
                    puts("-1");
                    continue ;
                }
                ans=Query(n[i].y+1,x,0,cnt,1);
                if(ans==-1) printf("-1
");
                else printf("%d %d
",c[ans],*(sy[ans].lower_bound(n[i].y+1)));
            }
            else
            {
                x=BS1(n[i].x);
                sy[x].erase(n[i].y);
                if(!sy[x].size())
                {
                    Update(x,-1,0,cnt,1);
                }
                else Update(x,*(--sy[x].end()),0,cnt,1);
            }
        }
        printf("
");
    }
    return 0;
}