struct AVLNode{
AVLNode *kid[2],*pa;
int val,cnt;
int flag;
AVLNode():kid[0](NULL),kid[0](NULL),pa(NULL),flag(0){}
}*root,*nil;
void Rotate(AVLNode *node,int drct){
AVLNode *t=node->kid[1-drct];
node->kid[1-drct]->kid[drct]->pa=node;
node->kid[1-drct]=node->kid[1-drct]->kid[drct];
p->pa=node->pa;
if(p->pa->kid[0]==node) p->pa->kid[0]=p;
else p->pa->kid[1]=p;
node->pa=p;
p->kid[drct]=node;
}
void Insert(AVLNode *root,int val){
if(root==NULL){
root=new AVLNode();
root->val=val;
return;
}
AVLNode *p=root;
while(val<p->val && p->lhd!=NULL) p=p->lhd;
while(val>p->val && p->rhd!=NULL) p=p->rhd;
if(val<p->val){ p->lhd=new AVLNode(); p->lhd->val=val; }
else if(val>p->val){ p->rhd=new AVLNode(); p->rhd->val=val; }
else p->cnt++;
}
void Query(AVLNode *root,int val){
AVLNode *p=root;
while(p->val!=val){
if(val<p->val){
if(p->lhd==NULL) return false;
p=p->lhd; continue;
}
if(val>p->val){
if(p->rhd==NULL) return false;
p=p->lhd; continue;
}
}
return true;
}
void Delete(AVLNode *root,int val){
AVLNode *p=root;
while(p->val!=val){
if(val<p->val){
if(p->lhd==NULL) return false;
p=p->lhd; continue;
}
if(val>p->val){
if(p->rhd==NULL) return false;
p=p->lhd; continue;
}
}
// ..............
}
////////////////
int gradir=(p->pa->chi[0])==p?0:1;
node->pa=p; p->chi[dir]=node;
p->bf+=(dir==0)?-1:1;
while(p->bf){
p->pa->bf+=(gradir==0)?-1:1;
if(p->pa->bf==-2 || p->pa->bf==2 ){
int rodir=(p->pa->bf<0)?1:0;
Rotate(p->pa->dir,rodir);
p->chi[rodir]->bf+=(rodir==1)?1:-1;
p->bf+=(rodir==1)?1:-1;
}else{ p=p->pa; }
}
// http://acm.nankai.edu.cn/p1248.html
#include<iostream>
#include<string.h>
#include<stdio.h>
using namespace std;
#define abs(x) (((x)<0)?(-x):(x))
int flag=0;
struct Int{
int size,saf,lazy;
Int():size{}
bool operator <(const & a) const
{ return saf<a.saf; }
bool operator ==(const & a) const
{ return saf==a.saf; }
};
struct AVLNode{
AVLNode *chi[2],*pa;
Int val;
int bf,cnt;
}*nil=new AVLNode(),*root=nil;
inline void Nil(){ nil->chi[0]=nil->chi[1]=nil->pa=nil; nil->bf=nil->cnt=0;}
inline void CreatNode(AVLNode * &node,Int val,int cnt=1){
if(node!=nil){ AVLNode *p=node; delete p; }
node=new AVLNode(); node->val=val; node->cnt=cnt;
node->pa=node->chi[0]=node->chi[1]=nil; node->bf=0;
}
inline void Connect(AVLNode *pa,AVLNode *node,int dir)
{ pa->chi[dir]=node; node->pa=pa; }
AVLNode * Bound(AVLNode * root,Int val){
AVLNode *p=root; if(root==nil) return nil;
while(p!=nil && val!=p->val){
int dir=(val<p->val);
node=node->kid[drct];
}
return p;
}
AVLNode * Extrema(AVLNode * node,int dir){
while(node->kid[dir]!=nil) node=node->chi[dir];
return node;
}
BSTNode * Cessor(BSTNode * node,int dir){
if(node->kid[dir]!=nil) return Extrema(node->chi[dir],1-dir);
for(AVLnode * p=node->pa;p!=nil && p->chi[dir]==node;node=p,p=p->pa);
return p;
}
void Rotate(AVLNode *node,int rodir){
Nil(); AVLNode *pivot=node->chi[1-rodir];
Connect(node,node->chi[1-rodir]->chi[rodir],1-rodir);
Connect(node->pa,pivot,(node->pa->chi[0]==node)?0:1);
Connect(pivot,node,rodir); Nil();
node->bf+=(rodir)?2:-2; pivot->bf+=(rodir)?1:-1;
}
AVLNode * Bound(AVLNode * node,Int val){
if(node==nil) return nil;
for(;val!=node->val;node=node->chi[dir]){
int dir=(val<node->val)?0:1
if(node->chi[dir]==nil) return node;
}
return node;
}
AVLNode * Search(AVLNode *root,int val){
AVLNode *p=Bound(root,val);
if(p->val==val) return p; return nil;
}
void Balance(AVLNode node,int dbf,int aimbf){
while(abs(node->bf+=dbf)!=aimbf){
if(abs(node->bf)==2){
int dir=(node->bf<0)?0:1;
if((node->bf)*(node->chi[dir]->bf)<0)
Rotate(node->chi[dir],dir)
Rotate(node,1-dir); node->pa->bf-=dbf;
}
if(node=node->pa==nil) return;
}
}
void Insert(AVLNode *root,Int val){
if(root==nil){ CreatNode(root,val); return; }
Nil(); AVLNode *p=Bound(root,val);
if(p->val==val){ p->cnt++; return; }
int dir=(val<p->val)?0:1; AVLNode *node;
CreatNode(node,val); Connect(p,node,dir);
Balance(p,(!dir)?-1:1,0);
}
bool Delete(AVLNode *root,int val){
if(root==nil) return false;
Nil(); AVLNode *p=Search(root,val);
if(p==nil) return false;
if(p->cnt>1){ (p->cnt)--; return true; }
if(p->chi[0]!=nil || p->chi[1]!=nil){
AVLNode *suc=Cessor(p,1);
if(suc==nil) suc=Cessor(p,0);
p->val=suc->val; p=suc;
}
int dir=p->pa->chi[0]==p?0:1;
p->pa->chi[dir]=nil;
Balance(p->pa,(!dir)?1:-1,1); delete p;
}
void Depart(AVLNode *root,int min){
}
int main(){
int n,m;
scanf("%d%d",&n,&m);
while(n--){
char q; int a;
scanf("%c%d",&q,&a);
switch(c){
case 'I': a-=flag; if(a>=m) Insert(root,a); break;
case 'A': m+=a; flag+=a; break;
case 'S': m-=a; flag-=a; Depart(root,m); break;
case 'F': Query(root,a); break;
}
}
return 0;
}
AVLNode * Bound(AVLNode * root,Int val){
if(root==nil) return nil;
AVLNode *p=root;
while(p!=nil && val!=p->val){
int dir=(val<p->val);
p=p->chi[dir];
}
return p;
}
// A.myc
#include<iostream>
#include<string.h>
#include<stdio.h>
#include<string>
#include <stddef.h>
#include<queue>
#include<fstream>
using namespace std;
int oo=0xffffffff;
int cnt=0;
#define abs(x) (((x)<0)?(-x):(x))
typedef string Int;
struct AVLNode{
AVLNode *chi[2],*pa;
Int val;
int bf,cnt;
int blank,len,hei;
}*nil=new AVLNode(),*root=nil;
inline void Nil(){ nil->chi[0]=nil->chi[1]=nil->pa=nil; nil->bf=nil->cnt=0; nil->blank=nil->len=nil->hei=0; }
void OutNode(AVLNode * node,int cor){
for(int i=cor;i<node->blank;i++) printf(" ");
cout<<node->val;
}
int CalCor(AVLNode * root,int lst){
Nil(); root->blank=0;
root->len=root->val.length(); int dis=0,dis2=0;;
if(root->chi[0]!=nil){ root->chi[0]->hei=root->hei+1; dis=CalCor(root->chi[0],lst); }
int halflen=(root->len)/2; root->blank=lst+dis-halflen; if(root->blank<lst) root->blank=lst;
if(root->chi[1]!=nil){ root->chi[1]->hei=root->hei+1; dis2=CalCor(root->chi[1],lst+dis+(dis?1:0)); }
if(!dis2) root->blank-=(root->len+1)/2; if(root->blank<lst) root->blank=lst;
int ans=((dis+(dis?1:0)+dis2)>root->len)?dis+(dis?1:0)+dis2:root->len;
if(dis2 && dis && (root->chi[1]->blank-root->chi[0]->blank)>root->len && (root->chi[0]->blank+root->chi[1]->blank)/2+root->len<=ans)
root->blank=(root->chi[0]->blank+root->chi[1]->blank)/2;
return ans; Nil();
}
/*int CalCor(AVLNode * root,int lst,int &padel,int dir){
Nil(); root->blank=0;
root->delta=0; root->len=root->val.length(); int dis=0,dis2=0;;
if(root->chi[0]!=nil){ root->chi[0]->hei=root->hei+1; dis=CalCor(root->chi[0],lst,root->delta,0); }
root->blank=dis+root->delta+lst;
if(root->chi[1]!=nil){ root->chi[1]->hei=root->hei+1; dis2=CalCor(root->chi[1],root->blank+root->len,root->delta,1); }
if(dis && dis2) root->delta/=2; root->blank=dis+dis?(root->delta):0+lst;
if(!dir){ padel+=dis2+(dis2)?(root->delta):0+root->chi[1]->len; return root->blank+root->len-lst; }
else { padel+=root->blank-lst; return dis2+(dis2)?(root->delta):0+root->chi[1]->len; } Nil();
}*/
/*void CalCor(AVLNode *root,int cor,int lst,int &rst,int dir){
root->len=root->val.length(); cor-=dir*root->len/2;
if(root->chi[0]!=nil){ CalCor(root->chi[0],cor,lst,root->blank,-1); root->chi[0]->hei=root->hei+1;}
if(lst<0){ cor-=lst; rst-=lst; root->blank-=lst; lst=0; }
cor+=root->len; if(cor>rst){ rst=cor; }
if(root->chi[1]!=nil){ CalCor(root->chi[1],cor,lst,root->blank,1); root->chi[1]->hei=root->hei+1; }
} */
void OutTree(AVLNode * root){
queue<AVLNode *> q;
q.push(root); int y=0,cor=0,cor2=0,cor3=0; string branch="",pro="";
while(!q.empty()){
AVLNode* t=q.front();
if(t->hei!=y) { cout<<endl<<pro<<endl<<branch; branch=""; pro=""; y=t->hei; printf("\n"); cor=0; cor2=0; cor3=0; }
OutNode(t,cor); cor=t->blank+t->len;
for(int i=cor3;i<t->blank;i++) pro+=' '; cor3=t->blank;
switch(t->bf){
case -1: pro+="-1 "; cor3+=4; break;
case -2: pro+="-2 "; cor3+=4; break;
case 0: pro+="0 "; cor3+=3; break;
case 1: pro+="1 "; cor3+=3; break;
case 2: pro+="2 "; cor3+=3; break;
}
if(t->chi[0]!=nil){
q.push(t->chi[0]);
for(int i=cor2;i<(t->chi[0]->blank+t->blank)/2;i++) branch+=' ';
branch+='/'; cor2=(t->chi[0]->blank+t->blank)/2;
}
if(t->chi[1]!=nil){
q.push(t->chi[1]);
for(int i=cor2;i<(t->chi[1]->blank+t->blank)/2;i++) branch+=' ';
branch+='\\'; cor2=(t->chi[1]->blank+t->blank)/2;
}
q.pop();
}
}
void Doit(){
root->hei=0;
CalCor(root,0);
// CalCor(root,0,l,oo,-1);
OutTree(root);
printf("\n//////////////////////////////////\n");
}
inline AVLNode * CreatNode(AVLNode * &node,Int val,int cnt=1){
if(node!=NULL && node!=nil){ AVLNode *p=node; delete p; }
node=new AVLNode(); node->val=val; node->cnt=cnt;
node->pa=node->chi[0]=node->chi[1]=nil; node->bf=0;
return node;
}
inline void Connect(AVLNode *pa,AVLNode *node,int dir)
{ pa->chi[dir]=node; node->pa=pa; }
AVLNode * Bound(AVLNode * node,Int val){
if(node==nil) return nil;
for(int dir;val!=node->val;node=node->chi[dir]){
dir=(val<node->val)?0:1;
if(node->chi[dir]==nil) return node;
}
return node;
}
AVLNode * Extrema(AVLNode * node,int dir){
while(node->chi[dir]!=nil) node=node->chi[dir];
return node;
}
AVLNode * Cessor(AVLNode * node,int dir){
if(node->chi[dir]!=nil) return Extrema(node->chi[dir],1-dir);
for(AVLNode * p=node->pa;p!=nil && p->chi[dir]==node;node=p,p=p->pa);
return node->pa;
}
void Rotate(AVLNode *node,int rodir){
Nil(); AVLNode *pivot=node->chi[1-rodir];
Connect(node,node->chi[1-rodir]->chi[rodir],1-rodir);
Connect(node->pa,pivot,(node->pa->chi[0]==node)?0:1);
Connect(pivot,node,rodir); Nil();
if(root==node) root=pivot; // !!!!!!
node->bf+=(rodir)?2:-2; pivot->bf+=(rodir)?1:-1;
Doit();
}
AVLNode * Search(AVLNode *root,Int val){
AVLNode *p=Bound(root,val);
if(p->val==val) return p; return nil;
}
void Balance(AVLNode * node,int dbf,int aimbf){
for((node->bf)+=dbf;aimbf!=abs(node->bf);(node->bf)+=dbf){
dbf=(node->pa->chi[0]==node)?-1:1;
if(abs(node->bf)==2){
int dir=(node->bf<0)?0:1;
if((node->bf)*(node->chi[dir]->bf)<0) Rotate(node->chi[dir],dir);
Rotate(node,1-dir);
node->pa->bf-=dbf;
}
if((node=node->pa)==nil) { Nil(); return;}
} Nil();
}
void Insert(AVLNode * &root,Int val){
if(root==nil){ root=CreatNode(root,val); return; }
Nil(); AVLNode *p=Bound(root,val);
if(p->val==val){ p->cnt++; return; }
int dir=(val<p->val)?0:1; AVLNode *node=nil;
CreatNode(node,val); Connect(p,node,dir);
Balance(p,(!dir)?-1:1,0);
Doit();
}
bool Delete(AVLNode *root,Int val){
if(root==nil) return false;
Nil(); AVLNode *p=Search(root,val);
if(p==nil) return false;
if(p->cnt>1){ (p->cnt)--; return true; }
if(p->chi[0]!=nil || p->chi[1]!=nil){
AVLNode *suc=Cessor(p,1);
if(suc==nil) suc=Cessor(p,0);
p->val=suc->val; p=suc;
}
int dir=p->pa->chi[0]==p?0:1;
p->pa->chi[dir]=nil;
Balance(p->pa,(!dir)?1:-1,1); delete p;
Doit();
return true;
}
void Traversal(AVLNode * root){
if(root->chi[0]!=nil) Traversal(root->chi[0]);
cout<<root->val;
printf(" %.4lf\n",(double)root->cnt/(double)cnt*100.0); // double
if(root->chi[1]!=nil) Traversal(root->chi[1]);
}
int main(){
freopen("in.txt","r",stdin);
freopen("out.txt","w",stdout);
string s;
while (getline(cin,s)) // ##
if(s!="" && ++cnt) Insert(root,s); // ##
Traversal(root);
return 0;
}
