hdu 2527 Safe Or Unsafe (哈夫曼树)

Safe Or Unsafe

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1388    Accepted Submission(s): 544

Problem Description

Javac++ 一天在看计算机的书籍的时候，看到了一个有趣的东西！每一串字符都可以被编码成一些数字来储存信息，但是不同的编码方式得到的储存空间是不一样的！并且当储存空间大于一定的值的时候是不安全的！所以Javac++ 就想是否有一种方式是可以得到字符编码最小的空间值！显然这是可以的，因为书上有这一块内容--哈夫曼编码(Huffman Coding)；一个字母的权值等于该字母在字符串中出现的频率。所以Javac++ 想让你帮忙，给你安全数值和一串字符串，并让你判断这个字符串是否是安全的？

 

Input

输入有多组case，首先是一个数字n表示有n组数据，然后每一组数据是有一个数值m(integer)，和一串字符串没有空格只有包含小写字母组成！

 

Output

如果字符串的编码值小于等于给定的值则输出yes，否则输出no。

 

Sample Input

2

12

helloworld

66

ithinkyoucandoit

 

Sample Output

no

yes

 

Source

HDU 2008-10 Programming Contest

 

Recommend

gaojie   |   We have carefully selected several similar problems for you:  2526 2524 2525 1024 1757 

 

和hdu 1053 类似

模板原型：

priority_queue<T,Sequence,Compare>

T:存放容器的元素类型

Sequence:实现优先级队列的底层容器，默认是vector<T>

Compare:用于实现优先级的比较函数，默认是functional中的less<T>

常用的操作如下：

empty()  如果优先队列为空，则返回真 
pop()  删除第一个元素 
push()  加入一个元素 
size()  返回优先队列中拥有的元素的个数 
top()  返回优先队列中有最高优先级的元素

但是在使用时必须注意：priority_queue放置元素时，不会判断元素是否重复。（因为在模板的第二个参数时顺序容器，不能保证元素的唯一性）此外可以替代默认的Compare函数

 //0MS    376K    1953 B    G++
 #include<iostream>
 #include<algorithm>
 #include<queue>
 using namespace std;
 typedef struct Huffman{
     int deep;
     int fred;
     Huffman *left,*right;
     friend bool operator <(Huffman a,Huffman b){
         return a.fred>b.fred;
     }
 }Huffman;
 Huffman trie[];
 Huffman *root;
 int len,id,sum;
 int cnt;
 priority_queue<Huffman>Q;

 void huffman()
 {
     sum=;
     root=(Huffman*)malloc(sizeof(Huffman));
     for(int i=;i<id;i++)
         Q.push(trie[i]);
     while(Q.size()>){
         Huffman *h1=(Huffman*)malloc(sizeof(Huffman));
         *h1=Q.top();
         Q.pop();
         Huffman *h2=(Huffman*)malloc(sizeof(Huffman));
         *h2=Q.top();
         Q.pop();

         Huffman h3;
         h3.left=h1;
         h3.right=h2;
         h3.fred=h1->fred+h2->fred;
         Q.push(h3);
     }
     *root=Q.top();
     Q.pop();
     root->deep=;

     queue<Huffman>q;
     q.push(*root);
     while(!q.empty()){
         Huffman ht=q.front();
         q.pop();
         if(ht.left!=NULL){
             ht.left->deep=ht.deep+;
             q.push(*ht.left);
         }
         if(ht.right!=NULL){
             ht.right->deep=ht.deep+;
             q.push(*ht.right);
         }
         if(!ht.left && !ht.right){
             sum+=ht.deep*ht.fred;
         }
     }
 }
 int main(void)
 {
     char c[];
     int t,n;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d%s",&n,c);
         len=strlen(c);
         c[len]='!';
         sort(c,c+len);
         cnt=;
         id=;
         for(int i=;i<=len;i++)
             if(c[i]!=c[i-]){
                 trie[id++].fred=cnt;
                 cnt=;
             }else cnt++;
         if(id==){
             if(len>n) puts("no");
             else puts("yes");
             continue;
         }
         huffman();
         if(sum>n) puts("no");
         else puts("yes");
     }
     return ;
 }

 //15MS    232K    984 B    G++
 #include<stdio.h>
 #include<string.h>
 #include<queue>
 using namespace std;
 int main(void)
 {
     int t,n,r,len;
     int p[];
     char c[];
     scanf("%d",&t);
     while(t--)
     {
         memset(p,,sizeof(p));
         scanf("%d%s",&n,c);
         len=strlen(c);
         int judge=;
         for(int i=;i<len;i++){
             if(c[i]!=c[i-]) judge=;
         }
         if(judge){
             if(len>n) puts("no");
             else puts("yes");
             continue;
         }
         for(int i=;i<len;i++)
             p[c[i]-'a']++;
         priority_queue<int,vector<int>,greater<int> >Q;
         int sum=;
         for(int i=;i<;i++)
             if(p[i]) Q.push(p[i]);
         while(Q.size()>){
             int a=Q.top();
             Q.pop();
             int b=Q.top();
             Q.pop();
             sum+=a+b;
             Q.push(a+b);
         }
         if(sum>n) puts("no");
         else puts("yes");
     }
     return ;
 }