poj 2418

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<string>
#include <stddef.h>
using namespace std;
int cnt=0;
#define abs(x) (((x)<0)?(-x):(x))
typedef string Int;
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 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();
    node->bf+=(rodir)?2:-2; pivot->bf+=(rodir)?1:-1;
}

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){
        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){ 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);
}
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;
    return true;
}
void Traversal(AVLNode * root){
    if(root->chi[0]!=nil) Traversal(root->chi[0]);
	cout<<root->val;
    printf(" %.4lf
",(double)root->cnt/(double)cnt); // double
    if(root->chi[1]!=nil) Traversal(root->chi[1]);
}
int main(){
	char * s;
	while (scanf("%s",s)!=EOF && ++cnt) Insert(root,s); // getline?
	Traversal(root);
    return 0;
}

　　

// A.myc
#include<iostream> 
#include<string.h> 
#include<stdio.h> 
#include<string> 
#include <stddef.h> 
#include<queue>
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; 
void OutNode(AVLNode * node){
	for(int i=0;i<node->blank;i++) printf(" ");
	cout<<node->val;
}
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;
	while(!q.empty()){
		AVLNode* t=q.front(); 
		if(t->hei!=y) { y=t->hei; printf("
"); }
		OutNode(t);
		if(t->chi[0]!=nil) q.push(t->chi[0]); 
		if(t->chi[1]!=nil) q.push(t->chi[1]);
		q.pop();
	}
}
void Doit(){
	int l=0; root->hei=0;
	CalCor(root,0,l,oo,-1);
	OutTree(root);
	printf("
//////////////////////////////////
");
}
inline void Nil(){ nil->chi[0]=nil->chi[1]=nil->pa=nil; nil->bf=nil->cnt=0;} 
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(); 
    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){ 
        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){ 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
",(double)root->cnt/(double)cnt*100.0); // double 
    if(root->chi[1]!=nil) Traversal(root->chi[1]); 
} 
int main(){ 
	freopen("out.txt","w",stdout);
    string s;
	while (getline(cin,s)) // ##
		if(s!="" && ++cnt) Insert(root,s); // ##
    Traversal(root); 
    return 0; 
}


/*#include<iostream>
#include<string.h>
#include<stdio.h>
#include<string>
#include <stddef.h>
#include<queue>
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;
}*nil=new AVLNode(),*root=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);
	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);
}
void OutTree(AVLNode * root){
	queue<AVLNode *> q;
	q.push(root);
	while(!q.empty()){
		AVLNode* t=q.front(); 
		q.push(t->chi[0]); q.push(t->chi[1]);
		q.pop();
	}
}
void Doit(){
	int l=0;
	CalCor(root,0,l,oo,-1);
	OutTree(root);
}
inline void Nil(){ nil->chi[0]=nil->chi[1]=nil->pa=nil; nil->bf=nil->cnt=0;}
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();
    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){
        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){ 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;
    return true;
	Doit();
}
void Traversal(AVLNode * root){
    if(root->chi[0]!=nil) Traversal(root->chi[0]);
    cout<<root->val;
    printf(" %.4lf
",(double)root->cnt/(double)cnt); // double
    if(root->chi[1]!=nil) Traversal(root->chi[1]);
}
int main(){
    char * s;
    while (scanf("%s",s)!=EOF && ++cnt) Insert(root,s); // getline?
    Traversal(root);
    return 0;
}*/

// AVLTree 
#include<iostream>  
#include<string.h>  
#include<stdio.h>  
#include<string>  
#include<stddef.h>  
#include<queue> 
#include<fstream>
using namespace std; 
#define abs(x) (((x)<0)?(-x):(x))  
#define BLACK 0
#define RED 1
#define debug
typedef string Int;
typedef int Val;
int cnt=0;
struct RBNode{
    RBNode *chi[2],*pa;
    int color,padir;
	Int key; Val cnt;
	#ifdef debug
	int blank,hei,len;
	#endif
	RBNode * s(){ return pa->chi[1-padir]; }
}*nil=new RBNode(),*root=nil;
void Nil(){ nil->chi[0]=nil->chi[1]=nil->pa=nil; nil->color=nil->cnt=nil->padir=0; nil->key="";}
#ifdef debug
typedef RBNode AVLNode;
// PaintAVL 
void OutNode(AVLNode * node,int cor){  
    for(int i=cor;i<node->blank;i++) printf(" ");  
    cout<<node->key;  
}  
int CalCor(AVLNode * root,int lst){ 
    Nil(); root->blank=0; 
    root->len=root->key.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(); 
}  
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("
"); 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->color){ 
            case 1:  pro+="RED  "; cor3+=5; break; 
            case 0:  pro+="BLACK  "; cor3+=7; 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();  
    } cout<<endl<<pro; 
}  
void Doit(Int key){  
	cout<<key<<endl<<endl;
    root->hei=0;  
    CalCor(root,0); 
    OutTree(root);  
    printf("
//////////////////////////////////
");  
}
#endif
RBNode * CreatNode(RBNode * &node,Int key,Val cnt=1,int op=1){  
	if(!op){ return nil; }
    if(node!=NULL && node!=nil){ RBNode *p=node; delete p; }  
    node=new RBNode(); node->cnt=cnt; node->key=key; node->color=RED;
    node->pa=node->chi[0]=node->chi[1]=nil; return node;  
}  
void Connect(RBNode *pa,RBNode *node,int dir)  {
	Nil(); pa->chi[dir]=node; node->pa=pa; node->padir=dir; Nil(); 
	#ifdef debug
	Doit("Connect  "+pa->key+"   "+node->key+(dir?"   1":"   0"));
	#endif
}
RBNode * Extrema(RBNode * node,int dir){  
    while(node->chi[dir]!=nil) node=node->chi[dir];  
    return node;  
}  
RBNode * Cessor(RBNode * node,int dir){  
    if(node->chi[dir]!=nil) return Extrema(node->chi[dir],1-dir);  
    for(RBNode * p=node->pa;p!=nil && p->chi[dir]==node;node=p,p=p->pa);  
    return node->pa;  
} 
RBNode * Bound(RBNode * node,Int key,int dif=1){  
    if(node==nil) return nil;  
    for(int dir;key!=node->key;node=node->chi[dir]){  
        dir=(key<node->key)?0:1;  
        if(node->chi[dir]==nil) return node;  
    }  
    if(!dif && node->key!=key) return nil; 
    return node;  
}
void SwpClr(RBNode * a,RBNode * b) { 
	int t=a->color; a->color=b->color; b->color=t; 
	#ifdef debug
	Doit("Swap  "+a->key+"   "+b->key);
	#endif
}
void Rotate(RBNode *node,int rodir,int wis=1){
	#ifdef debug
	Doit("Before  Ro  "+node->key+(rodir?"  1  ":"  0  "));
	#endif
	Nil(); if(wis && node->chi[1-rodir]->chi[rodir]!=nil && node->chi[1-rodir]->chi[1-rodir]->color==BLACK) Rotate(node->chi[1-rodir],1-rodir);
	while(node->chi[rodir]->chi[1-rodir]!=nil) Rotate(node->chi[rodir],rodir);
	RBNode * pivot=node->chi[1-rodir]; SwpClr(node,pivot);
	Connect(node,node->chi[1-rodir]->chi[rodir],1-rodir);
	Connect(node->pa,pivot,node->padir); Connect(pivot,node,rodir); 
	if(root==node) root=pivot; Nil();
	#ifdef debug
	Doit("After  Ro  "+node->key+(rodir?"  1  ":"  0  "));
	#endif
}
bool InDe(RBNode * &root,Int key,int op,Val cnt=1){
	#ifdef debug
	Doit("In  "+key);
	#endif
	Nil(); RBNode * pa=Bound(root,key,op);
	RBNode * node=new RBNode(); node=CreatNode(node,key,cnt,op);
	node->padir=(node==nil || node->key<pa->key)?0:1;
	if(root==nil){ if(!op) return false; root=node; root->color=BLACK; Nil(); return true;}
	if(pa->chi[0]!=nil && pa->chi[1]!=nil){ RBNode * t=Cessor(pa,1); pa->key=t->key; pa->cnt=t->cnt; pa=t; }
	if(op && pa->color!= node->color){ Connect(pa,node,node->padir); return true; };
	if(!op && pa->chi[0]!=nil) Rotate(pa,0); Connect(pa,node,node->padir);
	node=pa;
	while(node->s()->color==RED || 
	  node->s()!=nil && (node->color==node->s()->chi[0]->color==node->s()->chi[1]->color==node->pa->color==BLACK)){
		if(node->s()->color!=node->color){ Rotate(pa,pa->padir); continue; }
		(node->s()->color)^=1; SwpClr(node,node->pa); node=node->pa;
		if(node->pa->color!=node->color){ if(op) node=node->pa; break; }
	}
	if(node->color==RED || node->s()->chi[0]->color==RED || node->s()->chi[1]->color==RED)
		{ Rotate(node->pa,node->padir^(op-BLACK)); }
	else SwpClr(node,node->pa); root->color=BLACK; return true;
}
void Traversal(RBNode * root){  
    if(root->chi[0]!=nil) Traversal(root->chi[0]);  
    cout<<root->cnt;  
    printf(" %.4lf
",(double)root->cnt/(double)cnt*100.0); 
	if(root->chi[1]!=nil)  root->color=BLACK; 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){
            InDe(root,s,1); 
            // if(root!=nil){ InDe(root,s,0); InDe(root,s,1);} 
        }
    Traversal(root);  
    return 0;  
}