nyoj801 哈夫曼编码，输入有毒

Haffman编码

时间限制：1000 ms  |  内存限制：65535 KB

难度：3

描述
哈弗曼编码大家一定很熟悉吧（不熟悉也没关系，自己查去。。。）。现在给你一串字符以及它们所对应的权值，让你构造哈弗曼树，从而确定每个字符的哈弗曼编码。当然，这里有一些小规定：

1.规定哈弗曼树的左子树编码为0，右子树编码为1；

2.若两个字符权值相同，则ASCII码值小的字符为左孩子，大的为右孩子；

3.创建的新节点所代表的字符与它的左孩子的字符相同；

4.所有字符为ASCII码表上32-96之间的字符（即“ ”到“`”之间的字符）。

输入输入包含多组数据（不超过100组）

每组数据第一行一个整数n，表示字符个数。接下来n行，每行有一个字符ch和一个整数weight，表示字符ch所对应的权值，中间用空格隔开。

输入数据保证每组测试数据的字符不会重复。输出对于每组测试数据，按照输入顺序输出相应的字符以及它们的哈弗曼编码结果，具体格式见样例。样例输入

3
a 10
b 5
c 8
4
a 1
b 1
c 1
d 1

样例输出

a:0
b:10
c:11
a:00
b:01
c:10
d:11

题目就是直接求哈夫曼编码的树，离散数学知识，就是利用优先队列，将权值最小的两个节点弹出，连接形成新的节点，节点权值为子节点权值之和，并且该节点字符为左儿子字符（题目要求，为了使构成的树唯一）。

注意有坑在输入，首先样例的字符范围就超过了32-96。。。然后如果用c++输入输出写的估计都会中毒，因为第32位字符为空格，所以会导致运行时re

换成c语言，注意getchar的使用，还要注意输出顺序，代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<string>
#include<cstring>
using namespace std;
struct node{
int count;
char c;
node *l;
node *r;
node(){
l=r=NULL;
}
node(char a,int b,node *k=NULL,node *d=NULL){
c=a;count=b;
l=k;r=d;
}
bool operator<(const node &b) const{
if (count!=b.count)
return count>b.count;
else return c>b.c;
}
};
node t[300];
string ans[300];
node tt;

//递归遍历哈夫曼树
void dfs(node *now,string s){
if (now->l==NULL&&now->r==NULL){
ans[int(now->c)]=s;
// cout<<s<<endl;
return;
}
if (now->l!=NULL) dfs(now->l,s+'0');
if (now->r!=NULL) dfs(now->r,s+'1');
return;
}

int main(){
int n;
int count;
while(scanf("%d",&n)!=EOF){
getchar();
if (n==0) continue;
priority_queue<node> q;
char c[300];
string s;
for (int i=0;i<200;i++) t[i].r=t[i].l=NULL;
for (int i=0;i<n;i++){
/*
getline(cin,s);
c[i]=s[0];
int sum=0;
for (int j=2;j<s.length();j++){
sum=sum*10+s[j]-'0';
} */
scanf("%c %d",&c[i],&count);getchar();
q.push(node(c[i],count));
}/*
if (n==1){
cout<<c[0]<<":0"<<endl;
continue;
}*/
int i=0;

while(q.size()!=1){
t[i++]=q.top();
q.pop();
t[i++]=q.top();
q.pop();
q.push(node(t[i-2].c,t[i-2].count+t[i-1].count,&t[i-2],&t[i-1]));
}
tt=q.top();
//cout<<tt.count<<endl;
dfs(&tt,"");
for (int i=0;i<n;i++){
cout<<c[i]<<":"<<ans[int(c[i])]<<endl;
}
}
}