#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;
}