HOJ 12717 Cookie Selection

最新推荐文章于 2019-09-23 20:51:00 发布
Speedcell
最新推荐文章于 2019-09-23 20:51:00 发布
阅读量622
点赞数
分类专栏： SBT
本文链接：https://blog.csdn.net/speedcell4/article/details/12578179
版权
SBT 专栏收录该内容
2 篇文章 0 订阅
订阅专栏
我可以说这题我是SBT写的么……
/*
 Author : Speedcell
 Update : 2013-10-08
Version : soppYcell 2.3
*/

#include <algorithm>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>

#include <map>
#include <set>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <vector>
#include <string>
#include <bitset>
#include <memory>
#include <complex>
#include <numeric>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <ctype.h>
#include <locale.h>

using namespace std;

#pragma pack(4)

#ifndef __CONSTANT__
#define __CONSTANT__

typedef long long LONG;

const double pi = acos(-1.0);
const int   inf = 0x7f7f7f7f;
const LONG  INF = 0x7f7f7f7f7f7f7f7fll;

const int go[8][2] = {{0,1},{0,-1},{1,0},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}};

#endif // __CONSTANT__

#ifndef __IO__
#define __IO__

inline bool RD(int    & a) {return scanf("%d",&a)!=EOF;}
inline bool RD(char   & a) {return scanf("%c",&a)!=EOF;}
inline bool RD(char   * a) {return scanf("%s", a)!=EOF;}
inline bool RD(double & a) {return scanf("%lf",&a)!=EOF;}
inline bool RD(LONG   & a) {return scanf("%I64d",&a)!=EOF;}

template<class T1> inline bool
    IN(T1 & a) {return RD(a);}
template<class T1,class T2> inline bool
    IN(T1 & a,T2 & b) {return RD(a)&&RD(b);}
template<class T1,class T2,class T3> inline bool
    IN(T1 & a,T2 & b,T3 & c) {return RD(a)&&RD(b)&&RD(c);}
template<class T1,class T2,class T3,class T4> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d) {return RD(a)&&RD(b)&&RD(c)&&RD(d);}
template<class T1,class T2,class T3,class T4,class T5> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e);}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e,T6 & f) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e)&&RD(f);}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e,T6 & f,T7 & g) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e)&&RD(f)&&RD(g);}

inline void PT(int    a) {printf("%d",a);}
inline void PT(char   a) {printf("%c",a);}
inline void PT(char * a) {printf("%s",a);}
inline void PT(double a) {printf("%f",a);}
inline void PT(LONG   a) {printf("%I64d",a);}
inline void PT(const char a[]) {printf("%s",a);}

template<class T1> inline void
    OT(T1 a) {PT(a);}
template<class T1,class T2> inline void
    OT(T1 a,T2 b) {PT(a),PT(' '),PT(b);}
template<class T1,class T2,class T3> inline void
    OT(T1 a,T2 b,T3 c) {PT(a),PT(' '),PT(b),PT(' '),PT(c);}
template<class T1,class T2,class T3,class T4> inline void
    OT(T1 a,T2 b,T3 c,T4 d) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d);}
template<class T1,class T2,class T3,class T4,class T5> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e);}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f);}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f,T7 g) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f),PT(' '),PT(g);}

template<class T1> inline void
    OL(T1 a) {PT(a),PT('\n');}
template<class T1,class T2> inline void
    OL(T1 a,T2 b) {PT(a),PT(' '),PT(b),PT('\n');}
template<class T1,class T2,class T3> inline void
    OL(T1 a,T2 b,T3 c) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT('\n');}
template<class T1,class T2,class T3,class T4> inline void
    OL(T1 a,T2 b,T3 c,T4 d) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f,T7 g) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f),PT(' '),PT(g),PT('\n');}

#endif // __IO__

#ifndef __MACRO__
#define __MACRO__

#define ML(times) int tcase; IN(tcase); FOR(times,1,tcase)

#define FOR(i,a,b) for(int i=int(a),_##i=int(b);i<=_##i;i++)
#define DWN(i,b,a) for(int i=int(b),_##i=int(a);_##i<=i;i--)
#define ECH(i,u,pre,next) for(int i=int(pre[u]);i!=-1;i=int(next[i]))

#define MEM(a,v) memset(a,v,sizeof(a))
#define CLR(a,v) FOR(_i##a,0,sizeof(a)/sizeof(a[0])-1) a[_i##a]=v

#define LOOP(a,n)                                               \
    FOR(_i##a,0,(n)-1)                                          \
        OT(a[_i##a]),OT(_i##a!=__i##a?' ':'\n')
#define LOOP2(a,n,m)                                            \
    FOR(_i##a,0,(n)-1) FOR(_j##a,0,(m)-1)                       \
        OT(a[_i##a][_j##a]),OT(_j##a!=__j##a?' ':'\n')
#define LOOPG(G,n,pre,next)                                     \
    FOR(_i##a,0,(n)-1) ECH(_j##a,_i##a,pre,next)                \
        OL(_i##a,G[_j##a].v,G[_j##a].w)

#endif // __MACRO__

#ifndef __BIT__
#define __BIT__

template<class T> inline T lb(T i) {return i&-i;}
template<class T> inline T lc(T i) {return i<<1;}
template<class T> inline T rc(T i) {return i<<1|1;}
template<class T> inline T at(T a,int i) {return a& (T(1)<<i);}
template<class T> inline T nt(T a,int i) {return a^ (T(1)<<i);}
template<class T> inline T s1(T a,int i) {return a| (T(1)<<i);}
template<class T> inline T s0(T a,int i) {return a&~(T(1)<<i);}

#endif // __BIT__

#ifndef __COMPARER__
#define __COMPARER__

const double eps = 1e-8;

inline int cmp(double a,double b=0) {return fabs(b-a)<eps?0:((b-a)<eps?+1:-1);}
template<typename type> inline int cmp(type a,type b=0) {return a==b?0:(b<a?+1:-1);}

template<typename type> inline bool gt(type a,type b) {return cmp(a,b)> 0;}
template<typename type> inline bool ge(type a,type b) {return cmp(a,b)>=0;}
template<typename type> inline bool eq(type a,type b) {return cmp(a,b)==0;}
template<typename type> inline bool ne(type a,type b) {return cmp(a,b)!=0;}
template<typename type> inline bool le(type a,type b) {return cmp(a,b)<=0;}
template<typename type> inline bool ls(type a,type b) {return cmp(a,b)< 0;}

template<typename type> inline type smax(type a,type b) {return gt(a,b)?a:b;}
template<typename type> inline type smin(type a,type b) {return ls(a,b)?a:b;}

#endif // __COMPARER__

const int MAXV = 600002;

class SBT
{
private:
    struct node
    {
        node *c[2];
        int _size,val;

        int size(void)
        {
            if(this) return _size;
            else return 0;
        }
        int size(int f)
        {
            if(this) return c[f]->size();
            else return 0;
        }
        node *up(void)
        {
            if(this) _size=size(0)+size(1)+1;
            return this;
        }
    }*root,pool[MAXV];
    int _index;

    node *malloc(int val)
    {
        node *k1=&pool[_index++];
        k1->val=val;
        k1->_size=1;
        k1->c[0]=NULL;
        k1->c[1]=NULL;
        return k1;
    }
    node *rotate(node *k1,int f)
    {
        node *k2=k1->c[ f];
        node *k3=k2->c[!f];
        k1->c[ f]=k3;
        k2->c[!f]=k1;
        return k1->up(),k2->up();
    }
    node *maintain(node *k1,bool f)
    {
        bool flag=false;
        if(k1->c[f]->size(f)>k1->size(!f))
        {
            k1=rotate(k1,f);
            flag=true;
        }
        else if(k1->c[f]->size(!f)>k1->size(!f))
        {
            k1->c[f]=rotate(k1->c[f],!f);
            k1=rotate(k1,f);
            flag=true;
        }
        if(flag)
        {
            k1->c[0]=maintain(k1->c[0],0);
            k1->c[1]=maintain(k1->c[1],1);
            k1=maintain(k1,0);
            k1=maintain(k1,1);
        }
        return k1->up();
    }
    node *insert(node *k1,int val)
    {
        if(!k1) return malloc(val);
        else
        {
            if(k1->val>val)
            {
                k1->c[0]=insert(k1->c[0],val);
                return maintain(k1,0);
            }
            else
            {
                k1->c[1]=insert(k1->c[1],val);
                return maintain(k1,1);
            }
        }
    }
    node *remove(node *k1,int kth)
    {
        if(!k1) return NULL;
        else
        {
            if(k1->size(0)==kth)
            {
                if(!k1->c[0])
                {
                    OL(k1->val);
                    return k1->c[1];
                }
                if(!k1->c[1])
                {
                    OL(k1->val);
                    return k1->c[0];
                }
                return remove(rotate(k1,0),kth);
            }
            else if(k1->size(0)>kth)
            {
                k1->c[0]=remove(k1->c[0],kth);
                return maintain(k1,1);
            }
            else
            {
                k1->c[1]=remove(k1->c[1],kth-1-k1->size(0));
                return maintain(k1,0);
            }
        }
    }
    void display(node *k1,int d)
    {
        if(k1)
        {
            display(k1->c[0],d+1);
            FOR(i,0,d-1) OT(' ');
            OL(k1->val,k1->_size);
            display(k1->c[1],d+1);
        }
    }
public:
    void clear(void)
    {
        _index=0;
        root=NULL;
    }
    void insert(int val)
    {
        root=insert(root,val);
    }
    void remove(int kth)
    {
        root=remove(root,kth);
    }
    void display(void)
    {
        if(!root) OL("empty");
        else display(root,0);
    }
    int size(void)
    {
        return root->size();
    }
}sbt;

char o[120];

int toInt(void)
{
    if(o[0]=='#') return -1;
    else return atoi(o);
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("Cookie Selection.txt","r",stdin);
    #else
    #endif

    sbt.clear();
    while(IN(o))
    {
        int val=toInt();
        if(val==-1)
        {
            if(sbt.size()%2==1) sbt.remove((sbt.size()-1)/2);
            else sbt.remove(sbt.size()/2);
        }
        else sbt.insert(val);
    }

    return 0;
}
Speedcell
关注
0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
HOJ 12717 Cookie Selection

我可以说这题我是SBT写的么……/* Author : Speedcell Update : 2013-10-08Version : soppYcell 2.3*/#include #include #include #include #include #include #include #include #include #include #includ
复制链接

扫一扫