第四周集训总结

贪心算法

定义

在对问题求解时，总是做出在当前看来是最好的选择。不从整体最优上加以考虑，所做出的仅是在某种意义上的局部最优解。
贪心算法没有固定的算法框架，算法设计的关键是贪心策略的选择。必须注意的是，贪心算法不是对所有问题都能得到整体最优解，选择的贪心策略必须具备无后效性，即某个状态以后的过程不会影响以前的状态，只与当前状态有关。
所以对所采用的贪心策略一定要仔细分析其是否满足无后效性。

基本思路

1.建立数学模型来描述问题。

2.把求解的问题分成若干个子问题。

3.对每一子问题求解，得到子问题的局部最优解。

4.把子问题的解局部最优解合成原来解问题的一个解。

适用的问题

贪心策略适用的前提是：局部最优策略能导致产生全局最优解。实际上，贪心算法适用的情况很少。一般，对一个问题分析是否适用于贪心算法，可以先选择该问题下的几个实际数据进行分析，就可做出判断。

贪心策略的选择

因为用贪心算法只能通过解局部最优解的策略来达到全局最优解，因此，一定要注意判断问题是否适合采用贪心算法策略，找到的解是否一定是问题的最优解。

分治算法

定义

分治算法核心是：分而治之，就是将原问题划分成n个规模较小，并且和原问题相似的子问题，递归的去解决这些问题，然后将结果合并，最后得到原问题的答案。

分治算法的递归实现中，每一层递归都包含了这样三个操作：

1. 分解：将原问题分解成一系列子问题。
2. 解决：递归地求解各个子问题，若子问题足够小，则直接求解。
3. 合并：将子问题的结果合并成原问题。

分治算法原则如下：

1. 原问题和子问题使用相同的计算模式
2. 子问题之间相互独立，不会相互影响
3. 当子问题足够小，可以直接求解出答案
   子问题解决后，还可以合并为原问题期望的结果，而且合并的时间复杂度要低于原问题直接解决的时间复杂度

（例）归并排序-分治算法

问题描述：

输入：待排序列r[n],待排区间[s,t]
输出：升序序列r[s]~r[t]

分析：

1. 划分
2. 求解子问题
3. 合并

归并排序首先执行划分过程，直到子序列长度为1，再在回溯的过程中排序。在merge_()函数中，由于回溯回来的两个子序列已经有序，所以只需依次取出两者中最小值中的较小者即可。

#include 

using namespace std;

void Mergesort(int r[],int s,int t);
void merge_(int r[],int s,int m,int t);

int r[10010],r1[10010];

int main()
{
    int n,i;
    cin>>n;
    for(i=0;i<n;i++)
        cin>>r[i];
    Mergesort(r,0,n-1);
    for(i=0;i<n;i++)
        cout<<r[i]<<" ";
    cout<<endl;
    return 0;
}


void Mergesort(int r[],int s,int t)
{
    if(s == t)
        return ;
    else
    {
        int m = (s+t)/2;
        Mergesort(r,s,m);
        Mergesort(r,m+1,t);
        merge_(r,s,m,t);
        for(int i=s;i<=t;i++)
            r[i] = r1[i];
    }
}

void merge_(int r[],int s,int m,int t)
{
    int i=s,j=m+1,k=s;
    while(i<=m && j<=t)
    {
        if(r[i] <= r[j])
            r1[k++]=r[i++];
        else
            r1[k++]=r[j++];
    }
    while(i<=m)
        r1[k++]=r[i++];
    while(j<=t)
        r1[k++]=r[j++];
}

(二) 例题

导弹拦截

题目描述

某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统，但是这种拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，由于该系统还在试用阶段。所以一套系统有可能不能拦截所有的导弹。

输入导弹依次飞来的高度（雷达给出的高度不大于30000的正整数）。计算要拦截所有导弹最小需要配备多少套这种导弹拦截系统。

输入

n颗依次飞来的高度（1≤n≤1000）

输出

要拦截所有导弹最小配备的系统数k

样例输入

389 207 155 300 299 170 158 65

样例输出

2

提示

输入：导弹高度： 7 9 6 8 5

输出：导弹拦截系统K=2

输入：导弹高度： 4 3 2

输出：导弹拦截系统K=1

#include
using namespace std;

int s[1005];
int l[1005];
int main()
{
	int n =1;
	memset(s,0,sizeof(s));
	memset(l,0,sizeof(s));
	while(cin >> s[n])
	{
		n++;
	}
	int k = 1;
	l[k] = s[1];
	int p = 0;
	for(int i = 2;i <n ;i++){
		p=0;
		for(int j = 1;j <=k;j++){
			if(l[j] >= s[i]){
				if(p==0) p = j;
				else if(l[j] < l[p]) p = j;
			}
		}
		if(p==0){
			k++;
			l[k] = s[i];
		}
		else{
			l[p] = s[i];
		}
	}
	cout << k << endl;
}

活动选择

题目描述

学校在最近几天有n个活动，这些活动都需要使用学校的大礼堂，在同一时间，礼堂只能被一个活动使。由于有些活动时间上有冲突，学校办公室人员只好让一些活动放弃使用礼堂而使用其他教室。

现在给出n个活动使用礼堂的起始时间bi和结束时间ei(bi < ei<=32767)，请你帮助办公室人员安排一些活动来使用礼堂，要求安排的活动尽量多。

输入导弹依次飞来的高度（雷达给出的高度不大于30000的正整数）。计算要拦截所有导弹最小需要配备多少套这种导弹拦截系统。

输入

第一行一个整数n(n<=1000)； 接下来的n行，每行两个整数，第一个bi，第二个是ei(bi < ei<=32767)

输出

输出最多能安排的活动个数

样例输入

11
3 5
1 4
12 14
8 12
0 6
8 11
6 10
5 7
3 8
5 9
2 13

样例输出

4

#include
using namespace std;

const int MAXN=100000+5;
struct node{
	int b,e;
}record[MAXN];
bool cmp(const node& a,const node& b){return a.e < b.e;}

int main()
{
	int n;
	cin >> n;
	for(int i= 0;i < n;i++)
		cin >> record[i].b >> record[i].e;
	sort(record,record+n,cmp);
	int ct=0;
	int lastend = -1;
	for(int i = 0;i < n;i++){
		if(record[i].b>=lastend){
			ct++;
			lastend=record[i].e;
		}
	}
	cout << ct << endl;
	return 0;
}

纪念品分组

题目描述

元旦快到了，校学生会让乐乐负责新年晚会的纪念品发放工作。为使得参加晚会的同学所获得的纪念品价值相对均衡，他要把购来的纪念品根据价格进行分组，但每组最多只能包括两件纪念品，并且每组纪念品的价格之和不能超过一个给定的整数。为了保证在尽量短的时间内发完所有纪念品，乐乐希望分组的数目最少。 你的任务是写一个程序，找出所有分组方案中分组数最少的一种，输出最少的分组数目。

输入

输入包含n+2行： 第1行包括一个整数w，为每组纪念品价格之和的上限。 第2行为一个整数n，表示购来的纪念品的总件数。 第3~n+2行每行包含一个正整数pi (5 <= pi <= w)，表示所对应纪念品的价格。

输出

输出仅一行，包含一个整数，即最少的分组数目。

样例输入

100
9
90
20
20
30
50
60
70
80
90

样例输出

6

#include
using namespace std;

int main()
{
	int max,n;
	cin >> max >> n;
	int a[50000];
	int vis[50000] = {0};
	for(int i =0;i < n;i++)
	{
		cin >> a[i];
	}
	sort(a,a+n);
	int k = 0;
	for(int i = 0;i < n;i++)
	{
		for(int j = n - 1;j >= 0;j--){
			if(a[i] + a[j] > max && vis[i] ==0 && vis[j]==0){
				k++;
				vis[j]++;
			}
			if(a[i] + a[j] <= max && vis[i] ==0 && vis[j]==0){
				k++;
				vis[i]++;
				vis[j]++;
			}
		}
	}
	cout << k <<endl;
	return 0;
}

标准部件

题目描述

某公司生产了一些标准部件，这些部件有固定的尺寸（xi）和重量（yi）。为了更好地加工它们，需要分组，使每一组的部件都能排成一个尺寸和重量都不下降（若i

输入

第一行为一个整数N（N<=1000），表示部件的个数。第二行有N对正整数，每对正整数表示这些部件的尺寸和重量，均不超过10000。

输出

仅一行，即最少分成的组数。

样例输入

5
8 4 3 8 2 3 9 7 3 5

样例输出

2

#include
using namespace std;
const int maxn=10001;
struct node
{
	int x,y;
}a[maxn],t;
int main()
{
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>a[i].x>>a[i].y;	
	for(int i=1;i<=n-1;i++)
	{
		for(int j=i+1;j<=n;j++)
		{
			if(a[i].x>a[j].x||(a[i].x==a[j].x&&a[i].y>a[j].y))
			{
				t=a[i];
				a[i]=a[j];
				a[j]=t;
			}
		}
	}
	int k=1;
	int b[maxn];
	b[k]=a[1].y;
	for(int i=2;i<=n;i++)
	{
		int flag=0;
		for(int j=1;j<=k;j++)
		{
		    if(b[j]<=a[i].y)
		    {
		        b[j]=a[i].y;
		        flag=1;
		        break;
		    }
		}
		if(!flag) b[++k]=a[i].y;
	}
	cout<<k<<endl;
}

分治算法及数据排序练习

取余运算

题目描述

输入b，p，k的值，求b ^ p mod k的值（即b的p次方除以k的余数）。其中b，p，k * k为32位整数。

输入

输入B，P，K的值

输出

输出b ^ p mod k的值

样例输入

2 10 9

样例输出

2 ^ 10 mod 9 = 7

#include
using namespace std;

int mod(long long a,long long p,long long k)
{
	if(p == 1) return a % k;
	if(p % 2) return mod(a%k,p-1,k) * a % k;
	else return mod((a*a)%k,p/2,k);
}

int main()
{
	long long a,p,k;
	cin >> a >> p >> k;
	printf("%lld^%lld mod %lld=%d",a,p,k,mod(a,p,k));
}

问卷调查

题目描述

天宝想做一项问卷调查，为了调查的客观性，他先用计算机生成了N（N≤100）个1000以内的随机正整数，重复的数字只保留一个，随机数与学号一一对应，然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你帮天宝完成“去重”与“排序”的工作。

输入

输入有2行，第1行为正整数N（N≤100），第2行为N个用空格隔开的正整数x（x≤1000），表示生成的N个随机数。

输出

输出有2行，第1行输出去重后的随机正整数个数，第2行为升序排列的随机数，中间用空格隔开。

样例输入

10
20 40 32 67 40 20 89 300 400 15

样例输出

10
20 40 32 67 40 20 89 300 400 15

#include
using namespace std;

int main()
{
	set<int> a;
	int n,m;
	cin >> n;
	for(int i = 0;i < n;i++)
	{
		cin >> m;
		a.insert(m);
	}
	cout << a.size() << endl;
	set<int> ::iterator it ;
	for(it = a.begin();it!=a.end();it++){
		cout << *it << ' ';
	}
	cout << endl;
} 

车厢重组

题目描述

在一个旧式的火车站旁边有一座桥，其桥面可以绕河中心的桥墩水平旋转。一个车站的职工发现桥的长度最多能容纳两节车厢，如果将桥旋转180度，则可以把相邻两节车厢的位置交换，用这种方法可以重新排列车厢的顺序。于是他就负责用这座桥将进站的车厢按车厢号从小到大排列。他退休后，火车站决定将这一工作自动化，其中一项重要的工作是编一个程序，输入初始的车厢顺序，计算最少用多少步就能将车厢排序。

输入

输入包含n+2行： 第1行包括一个整数w，为每组纪念品价格之和的上限。 第2行为一个整数n，表示购来的纪念品的总件数。 第3~n+2行每行包含一个正整数pi (5 <= pi <= w)，表示所对应纪念品的价格。

输出

一个数据，是最少的旋转次数。

样例输入

4
4 3 2 1

样例输出

6

#include
using namespace std;

int main()
{
	int n;
	cin >> n;
	int a[10005];
	for(int i = 0;i < n;i++){
		cin >> a[i];
	}
	int ct = 0;
	for(int i =0 ;i < n;i++){
		for(int j =i+ 1;j < n;j++){
			if(a[i] > a[j]){
				swap(a[i],a[j]);
				ct++;
			}
		}
	}
	cout << ct << endl;
	return 0;
}

军事机密

题目描述

军方截获的信息由n（n<=30000）个数字组成，因为是敌国的高端秘密，所以一时不能破获。最原始的想法就是对这n个数进行小到大排序，每个数都对应一个序号，然后对第i个是什么数感兴趣，现在要求编程完成。

输入

第一行n，接着是n个截获的数字，接着一行是数字k，接着是k行要输出数的序号。

输出

k行序号对应的数字

样例输入

5
121 1 126 123 7
3
2
4
3

样例输出

7
123
121

#include
using namespace std;

int main()
{
	int n;
	cin >> n;
	int a[30005],b[30005];
	for(int i = 0;i < n;i++){
		cin >> a[i];
	}
	int m;
	cin >> m;
	for(int i = 0;i < m;i++){
		cin >> b[i];
	}
	sort(a,a+n);
	for(int i = 0;i < m;i++){
		cout << a[b[i] - 1] << endl;
	}
}

奖学金

题目描述

某小学最近得到了一笔赞助，打算拿出其中一部分为学习成绩优秀的前5名学生发奖学金。期末，每个学生都有3门课的成绩：语文、数学、英语。先按总分从高到低排序，如果两个同学总分相同，再按语文成绩从高到低排序，如果两个同学总分和语文成绩都相同，那么规定学号小的同学排在前面，这样，每个学生的排序是唯一确定的。

任务：先根据输入的3门课的成绩计算总分，然后按上述规则排序，最后按排名顺序输出前5名学生的学号和总分。注意，在前5名同学中，每个人的奖学金都不相同，因此，你必须严格按上述规则排序。例如，在某个正确答案中，如果前两行的输出数据（每行输出两个数：学号、总分）是：

       7279
       5279

这两行数据的含义是：总分最高的两个同学的学号依次是7号、5号。这两名同学的总分都是279（总分等于输入的语文、数学、英语三科成绩之和），但学号为7的学生语文成绩更高一些。如果你的前两名的输出数据是：

       5279
       7279

则按输出错误处理，不能得分。

输入

输入包含n+1行：

第1行为一个正整数n，表示该校参加评选的学生人数。

第2到n+1行，每行有3个用空格隔开的数字，每个数字都在0到100之间。第j行的3个数字依次表示学号为j-1的学生的语文、数学、英语的成绩。每个学生的学号按照输入顺序编号为1~n（恰好是输入数据的行号减1）。 所给的数据都是正确的，不必检验。

输出

输出共有5行，每行是两个用空格隔开的正整数, 依次表示前5名学生的学号和总分。

样例输入

10
78 44 40
91 91 83
98 51 54
61 88 33
77 46 83
76 93 67
66 68 61
76 35 69
68 79 36
90 90 84

样例输出

2 265
10 264
6 236
5 206
3 203

#include
using namespace std;

struct node{
	int sum,yu,hao;
}a[300+5];

bool cmp(node x,node y){
	if(x.sum>y.sum) return 1;
	if(x.sum<y.sum) return 0;
	if(x.yu>y.yu) return 1;
	if(x.yu<y.yu) return 0;
	return x.hao < y.hao;
}

int main()
{
	int i,x,y,z,n;
	cin >> n;
	for(int i = 1;i <= n;i++){
		cin >> x >> y >>z;
		a[i].sum = x + y + z,a[i].yu = x,a[i].hao = i;
	}
	sort(a+1,a+1+n,cmp);
	for(int i = 1;i <= 5;i++)
		cout << a[i].hao << ' ' << a[i].sum << endl;
}

纪念品分组

题目描述

元旦快到了，校学生会让乐乐负责新年晚会的纪念品发放工作。为使得参加晚会的同学所获得的纪念品价值相对均衡，他要把购来的纪念品根据价格进行分组，但每组最多只能包括两件纪念品，并且每组纪念品的价格之和不能超过一个给定的整数。为了保证在尽量短的时间内发完所有纪念品，乐乐希望分组的数目最少。 你的任务是写一个程序，找出所有分组方案中分组数最少的一种，输出最少的分组数目。

输入导弹依次飞来的高度（雷达给出的高度不大于30000的正整数）。计算要拦截所有导弹最小需要配备多少套这种导弹拦截系统。

输入

输入包含n+2行： 第1行包括一个整数w，为每组纪念品价格之和的上限。 第2行为一个整数n，表示购来的纪念品的总件数。 第3~n+2行每行包含一个正整数pi (5 <= pi <= w)，表示所对应纪念品的价格。

输出

输出仅一行，包含一个整数，即最少的分组数目。

样例输入

100
9
90
20
20
30
50
60
70
80
90

样例输出

6

#include
using namespace std;

int main()
{
	int max,n;
	cin >> max >> n;
	int a[50000];
	int vis[50000] = {0};
	for(int i =0;i < n;i++)
	{
		cin >> a[i];
	}
	sort(a,a+n);
	int k = 0;
	for(int i = 0;i < n;i++)
	{
		for(int j = n - 1;j >= 0;j--){
			if(a[i] + a[j] > max && vis[i] ==0 && vis[j]==0){
				k++;
				vis[j]++;
			}
			if(a[i] + a[j] <= max && vis[i] ==0 && vis[j]==0){
				k++;
				vis[i]++;
				vis[j]++;
			}
		}
	}
	cout << k <<endl;
	return 0;
}

贪心算法练习

今年暑假不AC

题目描述

“今年暑假不AC？”
“是的。”
“那你干什么呢？”
“看世界杯呀，笨蛋！”
“@#$%^&*%…”

确实如此，世界杯来了，球迷的节日也来了，估计很多ACMer也会抛开电脑，奔向电视了。
作为球迷，一定想看尽量多的完整的比赛，当然，作为新时代的好青年，你一定还会看一些其它的节目，比如新闻联播（永远不要忘记关心国家大事）、非常6+7、超级女生，以及王小丫的《开心辞典》等等，假设你已经知道了所有你喜欢看的电视节目的转播时间表，你会合理安排吗？（目标是能看尽量多的完整节目）

输入

输入数据包含多个测试实例，每个测试实例的第一行只有一个整数n(n<=100)，表示你喜欢看的节目的总数，然后是n行数据，每行包括两个数据Ti_s,Ti_e (1<=i<=n)，分别表示第i个节目的开始和结束时间，为了简化问题，每个时间都用一个正整数表示。n=0表示输入结束，不做处理。

输出

对于每个测试实例，输出能完整看到的电视节目的个数，每个测试实例的输出占一行。
Sample Input

样例输入

12
1 3
3 4
0 7
3 8
15 19
15 20
10 15
8 18
6 12
5 10
4 14
2 9
0

样例输出

5

#include
using namespace std;
 
struct node 
{
	int t1;
	int t2; 
}a[105]; 
 
int cmp(node u,node v)
{
	if(u.t2==v.t2)
		return u.t1>v.t1;
	return u.t2<v.t2;
}
 
int main()
{
	int n,i,j,k,t;
	while(scanf("%d",&n)&&n)
	{
		for(i=0;i<n;i++)
			scanf("%d%d",&a[i].t1,&a[i].t2);
		sort(a,a+n,cmp);
		for(i=1,t=a[0].t2,k=1;i<n;i++)
		{
			if(a[i].t1>=t)
			{
				t=a[i].t2;
				k++;
			}
		}
		printf("%d\n",k);
	}
	return 0;
}

迷瘴

题目描述

通过悬崖的yifenfei，又面临着幽谷的考验——
幽谷周围瘴气弥漫，静的可怕，隐约可见地上堆满了骷髅。由于此处长年不见天日，导致空气中布满了毒素，一旦吸入体内，便会全身溃烂而死。
幸好yifenfei早有防备，提前备好了解药材料（各种浓度的万能药水）。现在只需按照配置成不同比例的浓度。
现已知yifenfei随身携带有n种浓度的万能药水，体积V都相同，浓度则分别为Pi%。并且知道，针对当时幽谷的瘴气情况，只需选择部分或者全部的万能药水，然后配置出浓度不大于 W%的药水即可解毒。
现在的问题是：如何配置此药，能得到最大体积的当前可用的解药呢？
特别说明：由于幽谷内设备的限制,只允许把一种已有的药全部混入另一种之中（即：不能出现对一种药只取它的一部分这样的操作）。

输入

输入数据的第一行是一个整数C，表示测试数据的组数；
每组测试数据包含2行，首先一行给出三个正整数n,V,W(1<=n,V,W<=100)；
接着一行是n个整数，表示n种药水的浓度Pi%(1<=Pi<=100)。

输出

对于每组测试数据，请输出一个整数和一个浮点数；
其中整数表示解药的最大体积，浮点数表示解药的浓度(四舍五入保留2位小数)；
如果不能配出满足要求的的解药，则请输出0 0.00。

样例输入

3
1 100 10
100
2 100 24
20 30
3 100 24
20 20 30

样例输出

0 0.00
100 0.20
300 0.23

#include
using namespace std;

int main()
{
	int t;
	cin >> t;
	while(t--)
	{
		int n,v,w;
		cin >> n >> v >> w;
		int a[1005];
		for(int i = 0;i < n;i++){
			cin >> a[i];
		}
		sort(a,a+n);
		int sum = 0;
		double num = 0.0;
		for(int i = 0;i <n;i++){
			if(num * sum + a[i] * v <= w*(sum+v)){
				num = (num*sum+a[i]*v)*1.0/(sum+v);
				sum = sum + v;
			}
		}
		printf("%d %.2lf\n",sum,num/100);
	}
	return 0;
}

Entropy

题目描述

An entropy encoder is a data encoding method that achieves lossless data compression by encoding a message with “wasted” or “extra” information removed. In other words, entropy encoding removes information that was not necessary in the first place to accurately encode the message. A high degree of entropy implies a message with a great deal of wasted information; english text encoded in ASCII is an example of a message type that has very high entropy. Already compressed messages, such as JPEG graphics or ZIP archives, have very little entropy and do not benefit from further attempts at entropy encoding.

English text encoded in ASCII has a high degree of entropy because all characters are encoded using the same number of bits, eight. It is a known fact that the letters E, L, N, R, S and T occur at a considerably higher frequency than do most other letters in english text. If a way could be found to encode just these letters with four bits, then the new encoding would be smaller, would contain all the original information, and would have less entropy. ASCII uses a fixed number of bits for a reason, however: it’s easy, since one is always dealing with a fixed number of bits to represent each possible glyph or character. How would an encoding scheme that used four bits for the above letters be able to distinguish between the four-bit codes and eight-bit codes? This seemingly difficult problem is solved using what is known as a “prefix-free variable-length” encoding.

In such an encoding, any number of bits can be used to represent any glyph, and glyphs not present in the message are simply not encoded. However, in order to be able to recover the information, no bit pattern that encodes a glyph is allowed to be the prefix of any other encoding bit pattern. This allows the encoded bitstream to be read bit by bit, and whenever a set of bits is encountered that represents a glyph, that glyph can be decoded. If the prefix-free constraint was not enforced, then such a decoding would be impossible.

Consider the text “AAAAABCD”. Using ASCII, encoding this would require 64 bits. If, instead, we encode “A” with the bit pattern “00”, “B” with “01”, “C” with “10”, and “D” with “11” then we can encode this text in only 16 bits; the resulting bit pattern would be “0000000000011011”. This is still a fixed-length encoding, however; we’re using two bits per glyph instead of eight. Since the glyph “A” occurs with greater frequency, could we do better by encoding it with fewer bits? In fact we can, but in order to maintain a prefix-free encoding, some of the other bit patterns will become longer than two bits. An optimal encoding is to encode “A” with “0”, “B” with “10”, “C” with “110”, and “D” with “111”. (This is clearly not the only optimal encoding, as it is obvious that the encodings for B, C and D could be interchanged freely for any given encoding without increasing the size of the final encoded message.) Using this encoding, the message encodes in only 13 bits to “0000010110111”, a compression ratio of 4.9 to 1 (that is, each bit in the final encoded message represents as much information as did 4.9 bits in the original encoding). Read through this bit pattern from left to right and you’ll see that the prefix-free encoding makes it simple to decode this into the original text even though the codes have varying bit lengths.

As a second example, consider the text “THE CAT IN THE HAT”. In this text, the letter “T” and the space character both occur with the highest frequency, so they will clearly have the shortest encoding bit patterns in an optimal encoding. The letters “C”, "I’ and “N” only occur once, however, so they will have the longest codes.

There are many possible sets of prefix-free variable-length bit patterns that would yield the optimal encoding, that is, that would allow the text to be encoded in the fewest number of bits. One such optimal encoding is to encode spaces with “00”, “A” with “100”, “C” with “1110”, “E” with “1111”, “H” with “110”, “I” with “1010”, “N” with “1011” and “T” with “01”. The optimal encoding therefore requires only 51 bits compared to the 144 that would be necessary to encode the message with 8-bit ASCII encoding, a compression ratio of 2.8 to 1.

输入

The input file will contain a list of text strings, one per line. The text strings will consist only of uppercase alphanumeric characters and underscores (which are used in place of spaces). The end of the input will be signalled by a line containing only the word “END” as the text string. This line should not be processed.

输出

For each text string in the input, output the length in bits of the 8-bit ASCII encoding, the length in bits of an optimal prefix-free variable-length encoding, and the compression ratio accurate to one decimal point.

样例输入

AAAAABCD
THE_CAT_IN_THE_HAT
END

样例输出

64 13 4.9
144 51 2.8

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

string s;
priority_queue< int,vector<int>,greater<int> > Q;

int main()
{
	while(getline(cin,s) && s!= "END"){
		int t = 1;
		int l = s.size();
		int l1=l*8;
		sort(s.begin(),s.end());
		for(int i = 1;i < s.length();i++){
			if(s[i] != s[i-1]){
				Q.push(t);
				t=1;
			}
			else t++;
		}
		Q.push(t);
		int ans=0;
		if(Q.size() == 1) ans = s.size();
		while(Q.size()>1){
			int a = Q.top();Q.pop();
			int b = Q.top();Q.pop();
			Q.push(a+b);
			ans = ans + a + b;
			
		}
		printf("%d %d %.1f\n",l1,ans,double(l1)/double(ans));
		Q.pop();
	}
	return 0;
}