UVA 11020 Efficient Solutions （BST，Splay树）

题意：给n个坐标。一个坐标(x,y)若有无存在的坐标满足x1<x && y1<=y  或  x1<=x && y1<y 时，此坐标(x,y)是就是有优势的。在给每一个坐标之后，立刻输出当前有优势的坐标有多少个。

思路：Set可以做，但是我用Splay树实现也不难。观察题意中的不等式发现，一个点(x,y)的左下方不能有点（相当于跟(0,0)组成的矩形中不能有其他点，除了(x,y)之外），但是若有相同的点的存在，这些相同点都是优势点。

　　用Splay维护剩下的全部优势点，对于新来的一个点，如果它本来就被其他已经存在的优势点所淘汰，则不必插入树了。若没有被淘汰，插入它后，它有可能会淘汰其他点，如果我们根据x坐标来排序的话，有可能被淘汰的点就在新插入的点的右边，只要右边有点(x1,y1)满足y1>=y就会淘汰掉该点。

 #include <bits/stdc++.h>
 #define pii pair<int,int>
 #define INF 0x3f7f7f7f
 #define LL long long
 using namespace std;
 const int N=;
 const int mod=;

 struct node
 {
     int key, y, pre, flip, ch[], son[];
 }nod[N];
 int  n, node_cnt, root;

 int create_node(int v,int y,int far)    //以x来排序即可。
 {
     nod[node_cnt].key=v;
     nod[node_cnt].y=y;
     nod[node_cnt].pre=far;
     nod[node_cnt].flip=;
     nod[node_cnt].ch[]=;
     nod[node_cnt].ch[]=;
     nod[node_cnt].son[]=;
     nod[node_cnt].son[]=;
     return node_cnt++;
 }

 void Rotate(int t,int d)
 {
     int son=nod[t].ch[d];
     int far=nod[t].pre;
     int gra=nod[far].pre;

     nod[son].pre=far;
     nod[far].pre=t;
     nod[t].pre=gra;

     nod[t].ch[d]=far;
     nod[far].ch[d^]=son;
     nod[gra].ch[ nod[gra].ch[]==far ]=t;

     nod[far].son[d^]=nod[t].son[d];
     nod[t].son[d]+=nod[far].son[d]+;
 }

 int Insert(int t,int v,int y)
 {
     if(t==)    return root=create_node(v, y, );
     if( v==nod[t].key )     //x相同，必有人被淘汰
     {
         if(nod[t].y<y)      return ;           //此人无效
         if(nod[t].ch[])    return Insert(nod[t].ch[], v, y);            //插在其前面
         else                return nod[t].ch[]=create_node(v, y, t);
     }
     else if( v<nod[t].key )
     {
         if(nod[t].ch[])    return Insert(nod[t].ch[], v, y);
         else                return nod[t].ch[]=create_node(v, y, t);
     }
     else
     {
         if(nod[t].ch[])    return Insert(nod[t].ch[], v, y);
         else                return nod[t].ch[]=create_node(v, y, t);
     }
 }

 void Splay(int t,int goal)
 {
     while(nod[t].pre!=goal)
     {
         int f=nod[t].pre, g=nod[f].pre;
         if(g==goal)    Rotate(t, nod[f].ch[]==t);
         else
         {
             int d1=nod[f].ch[]==t, d2=nod[g].ch[]==f;
             if(d1==d2)  Rotate(f, d1),Rotate(t, d1);
             else        Rotate(t, d1),Rotate(t, d2);
         }
     }
     if(!goal)   root=t;
 }

 int Find_del_node(int t,int y)
 {
     if(t==)            return ;   //无后继了
     if(nod[t].y>=y )    return t;
     int q;
     if(nod[t].ch[] && (q=Find_del_node(nod[t].ch[], y)) )    return q;
     if(nod[t].ch[] && (q=Find_del_node(nod[t].ch[], y)) )    return q;
     return ;
 }

 int Find_bac(int t,int d)   //这个可以找前驱也可以找后继。d为1则前驱。
 {
     if(t==)            return ;
     if(nod[t].ch[d]==) return t;
     else    return Find_bac(nod[t].ch[d], d);
 }

 void Delete(int t)  //专门删除根节点
 {
     int L=nod[t].ch[], R=nod[t].ch[];
     if(R==)    //无后继
     {
         root=L;
         nod[root].pre=;
     }
     else        //找后继
     {
         R=Find_bac(R, );
         Splay( R, root);
         nod[R].ch[]=L;
         nod[R].pre=;
         nod[R].son[]=nod[L].son[]++nod[L].son[];
         nod[L].pre=R;
         root=R;
     }
 }

 int main()
 {
     //freopen("input.txt", "r", stdin);
     int t, k, a, b, ans, Case=;
     cin>>t;
     while(t--)
     {
         printf("Case #%d:\n", ++Case);
         node_cnt=;
         root=;
         scanf("%d",&n);
         for(int i=; i<n; i++)
         {
             scanf("%d%d", &a, &b);
             int ok=Insert(root, a, b);
             if(ok!=)       //碰到x相同的，而且y又比它大，那么直接无效。但是并不是一定是优势点。
             {
                 Splay(ok, );                           //插入成功，先伸展到根。
                 int r=Find_bac(nod[root].ch[], );      //找前驱
                 if( r && nod[r].key<a && b>=nod[r].y)   Delete(root);    //新点为非优势点
                 else
                 {
                     while( (k=Find_del_node(nod[root].ch[], b))!=  ) //从右边开始，找到一个删一个。
                     {
                         Splay(k, );
                         Delete(root);
                         Splay(ok, );
                     }
                 }
             }
             printf("%d\n", nod[root].son[]++nod[root].son[]);    //输出树上有多少点
         }
         if(t)   printf("\n");
     }
     return ;
 }

AC代码