赤裸裸的splay平衡树

HYSBZ1588 http://www.lydsy.com/JudgeOnline/problem.php?id=1588

给我们n天的营业额， 要求出每天的最小波动值，然后加起来。  当天最小波动值 = 当天营业额 - （之前某天与当天营业额最接近的营业额）

所以维护一个spaly，将当天的营业额x插入splay中，然后将x旋转到根结点，然后找到左子树的最大值，右子树的最小值， 判断哪一个与当天的营业额差值小。

这里只用到了两种旋转，左旋和右旋。 没有考虑x的服 父亲是不是根节点。 也没有考虑共线不共线的问题。

 #include<cstdio>
 #include<iostream>
 #include<string.h>
 #include<algorithm>
 #include <vector>
 #include <math.h>
 using namespace std;
 const int INF = 0x7FFFFFFF;
 const int N =  + ;

 /*

             int y = pre[x];
         pre[next[x][kind]] = y;
         next[y][!kind] = next[x][kind];
         if(pre[y])
             next[pre[y]][next[pre[y]][1]==y] = x;

         //x旋转到了y的位置，所以y的父亲变成了x的父亲
         pre[x]  = pre[y];
         //
         next[x][kind] =  y;
         //x变成了y的父亲
         pre[y] = x;
 */
 struct SplayTree{
     int size,root;
     int next[N][],pre[N],key[N];
     void init()
     {
         size = root = ;
     }
     void newNode(int &rt, int father,int val)
     {
         rt = ++size;
         next[rt][] = next[rt][] = ;
         pre[rt] = father;
         key[rt] = val;
     }
     //kind = 0表示左转， 为1表示右转
     void rotate(int x, int kind)
     {
         int y = pre[x];//x的父亲
         pre[x] = pre[y];
         pre[y] = x;
         next[y][!kind] = next[x][kind];
         pre[next[y][!kind]] = y;
         next[x][kind] = y;
         if(pre[x])
             next[pre[x]][next[pre[x]][]==y] = x;
     }
     //将x旋转为goal的儿子
     void splay(int x, int goal)
     {
         while(pre[x]!=goal)
         {
             if(next[pre[x]][] == x)//如果自己的父亲的左孩子
                 rotate(x,);//右转
             else//左转
                 rotate(x,);
         }
         //如果x旋转到了根结点，那么root的指向需要发生变化
         if(!goal)
             root = x;
     }
     bool insert(int k)
     {
         int x,y;
         for(x=root;next[x][k>key[x]];x=next[x][k>key[x]])
             if(k==key[x])//如有已经有了要插入的结点，那么返回false
             {
                 splay(x,);
                 return false;
             }
         newNode(next[x][k>key[x]],x,k);
         splay(next[x][k>key[x]],);
         return true;
     }
     int getPre()//如果有左子树，获得左子树最大值
     {
         int x = next[root][];
         if(x)
         {
             while(next[x][])
             {
                 x = next[x][];
             }
             return key[x];
         }
         return INF;
     }
     int getNext()//如果有右子树，获得右子树最小值
     {
         int x = next[root][];
         if(x)
         {
             while(next[x][])
             {
                 x = next[x][];
             }
             return key[x];
         }
         return INF;
     }
 };
 SplayTree tree;
 int main()
 {
     //将每一天的最小波动值加起来
     int n,ans,x,a,b;
     while(scanf("%d%d",&n,&ans)!=EOF)
     {
         tree.init();
         tree.newNode(tree.root,,ans);
         while(--n)
         {
             x = ;
             scanf("%d",&x);

             //返回true，如果没有两个相同的结点，如果有，那么最小波动是0，不用加
             if(tree.insert(x))
             {
                 a = tree.getPre();
                 if(a<INF)
                     a = x - a;
                 b = tree.getNext();
                 if(b<INF)
                     b  -= x;

                 ans += min(a,b);
             }
         }
         printf("%d\n",ans);

     }
     return ;
 }