UVa 242 Stamps and Envelope Size

最新推荐文章于 2020-01-23 23:02:26 发布

原创最新推荐文章于 2020-01-23 23:02:26 发布 · 412 阅读

0 ·

CC 4.0 BY-SA版权

本文深入探讨了邮票与信封尺寸问题，并通过算法提供了解决方案。通过输入信封最大容纳邮票数和邮票面额集合，输出了最大化覆盖而无间隙的邮票组合及其总金额。

Stamps and Envelope Size

Philatelists have collected stamps since long before postal workers were disgruntled. An excess of stamps may be bad news to a country's postal service, but good news to those that collect the excess stamps. The postal service works to minimize the number of stamps needed to provide seamless postage coverage. To this end you have been asked to write a program to assist the postal service.

Envelope size restricts the number of stamps that can be used on one envelope. For example, if 1 cent and 3 cent stamps are available and an envelope can accommodate 5 stamps, all postage from 1 to 13 cents can be ``covered":

tabular21

Although five 3 cent stamps yields an envelope with 15 cents postage, it is not possible to cover an envelope with 14 cents of stamps using at most five 1 and 3 cent stamps. Since the postal service wants maximal coverage without gaps, the maximal coverage is 13 cents.

Input

The first line of each data set contains the integer S, representing the maximum of stamps that an envelope can accommodate. The second line contains the integer N, representing the number of sets of stamp denominations in the data set. Each of the next N lines contains a set of stamp denominations. The first integer on each line is the number of denominations in the set, followed by a list of stamp denominations, in order from smallest to largest, with each denomination separated from the others by one or more spaces. There will be at most S denominations on each of the N lines. The maximum value of S is 10, the largest stamp denomination is 100, the maximum value of N is 10.

The input is terminated by a data set beginning with zero (S is zero).

Output

Output one line for each data set giving the maximal no-gap coverage followed by the stamp denominations that yield that coverage in the following format:

max coverage = <value> : <denominations>

If more than one set of denominations in a set yields the same maximal no-gap coverage, the set with the fewest number of denominations should be printed (this saves on stamp printing costs). If two sets with the same number of denominations yield the same maximal no-gap coverage, then the set with the lower maximum stamp denomination should be printed. For example, if five stamps fit on an envelope, then stamp sets of 1, 4, 12, 21 and 1, 5, 12, 28 both yield maximal no-gap coverage of 71 cents. The first set would be printed because both sets have the same number of denominations but the first set's largest denomination (21) is lower than that of the second set (28). If multiple sets in a sequence yield the same maximal no-gap coverage, have the same number of denominations, and have equal largest denominations, then print the set with the lewer second-maximum stamp denomination, and so on.

Sample Input

5
2
4 1 4 12 21
4 1 5 12 28
10
2
5 1 7 16 31 88
5 1 15 52 67 99
6
2
3 1 5 8
4 1 5 7 8
0

Sample Output

max coverage =  71 :  1  4 12 21
max coverage = 409 :  1  7 16 31 88
max coverage =  48 :  1  5  7  8

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;


// record[i][j][k]代表是否可以用第i,i+1,...,n面额邮票，在不超过j张情况下，得到总额为k
int record[15][15][1100];
// d[i]表示凑出面值i需要的邮票数量
int d[15][1100];

// 面额组合情况结构体
typedef struct node
{
	int stamp[15];	// 邮票面额
	int num;	// 邮票张数
	int max_cov;	// 能形成的最大覆盖
	
	bool operator < (const struct node& x) const
	{
		if(max_cov > x.max_cov)
			return true;
		else if(max_cov == x.max_cov)
		{
			if(num < x.num)
				return true;
			else if(num == x.num)
			{	
				for(int i = num-1; i >= 0; i--)
				{
					if(stamp[i] > x.stamp[i])
						return false;
					else if(stamp[i] < x.stamp[i])
						return true;
				}
			}
			else
				return false;
		}
		else
			return false;
	}			
}node;

// 面额情况数组
node array[15];

// 最多能用的邮票张数
int max_num;

// 面额情况个数
int array_len;


// 代表现在需计算的是array[t]
int t;

int get_result(int i, int j, int k);

int main()
{
	while(scanf("%d", &max_num) == 1 && (max_num != 0))
	{
		scanf("%d", &array_len);

//		memset(d, -1, sizeof(d));
	
		// 读入所有情况
		for(t = 0; t < array_len; t++)
		{
			memset(record, -1, sizeof(record));
//			memset(d, -1, sizeof(d));

			scanf("%d", &array[t].num);
/*			for(int j = 1; j <= array[t].num; j++)
				scanf("%d", &array[t].stamp[j]);	
*/
			for(int j = 0; j < array[t].num; j++)
                                scanf("%d", &array[t].stamp[j]);
			// 计算结果
			int i = 0;
//			d[t][0] = 0;
			for(i = 1; ; i++)
			{

				if(!get_result(0, max_num, i))
					break;

/*				
				if(d[t][i] == -1 || d[t][i] > max_num)
					break;
				// 更新其他的状态
				for(int j = 0; j < array[t].num; j++)
				{
					if(i+array[i].stamp[j] >= 1100)
						continue;
					if(d[t][i+array[t].stamp[j]] == -1)
						d[t][i+array[t].stamp[j]] = d[t][i] + 1;
					else if(d[t][i+array[t].stamp[j]] > d[t][i] + 1)
						d[t][i+array[t].stamp[j]] = d[t][i] + 1;				
				}		
*/			}
			array[t].max_cov = i-1;	
		}
/*
		sort(array, array+array_len);
		printf("max coverage =%4d :", array[0].max_cov);
		for(int i = 0; i < array[0].num; i++)
			printf("%3d", array[0].stamp[i]);
		printf("\n");
*/

//		int max_c = array[0].max_cov;
		int place = 0;
		for(int i = 1; i < array_len; i++)	
		{
			if(array[i] < array[place])
				place = i;

		}

		printf("max coverage =%4d :", array[place].max_cov);
                for(int i = 0; i < array[place].num; i++)
                        printf("%3d", array[place].stamp[i]);
                printf("\n");
	}
	return 0;	
}


// 计算record[i][j][k]代表是否可以用第i,i+1,...,n面额邮票，在不超过j张情况下，得到总额为k
int get_result(int i, int j, int k)
{
	if(record[i][j][k] != -1)
		return record[i][j][k];

	// 如果总额为0
	if(k == 0)
	{
		record[i][j][k] = 1;
		return record[i][j][k];
	}
	// 如果只有一种面额可用
	if(i == array[t].num -1)
	{
		if(k % array[t].stamp[i] == 0 && k / array[t].stamp[i] <= j)
			record[i][j][k] = 1;
		else
			record[i][j][k] = 0;
		return record[i][j][k];	
	}		
	// 如果只有一张邮票可用
	if(j == 1)
	{
		for(int a = i; a < array[t].num; a++)
		{
			if(array[t].stamp[a] == k)
			{
				record[i][j][k] = 1;
				return record[i][j][k];
			}
		}		
		record[i][j][k] = 0;
		return record[i][j][k];
	}
	// 如果没有邮票可用
	if(j == 0)
	{
		record[i][j][k] = 0;
		return record[i][j][k];
	}

	// 否则，实验用第i种面额的所有情况
	int ans = 0;
	for(int use = 0; use <= j; use++)
	{
		if(k-array[t].stamp[i]*use < 0)
			break;
		int r = get_result(i+1, j-use, k-array[t].stamp[i]*use);
		if(r == 1)
		{
			ans = 1;
			break;
		}	
	}		

	record[i][j][k] = ans;
	return record[i][j][k];	
	
}
/*
max coverage =  71 :  1  4 12 21
max coverage =  409 :  1  7 16 31 88
max coverage =  48 :  1  5  7  8

max coverage =  71 :  1  4 12 21
max coverage = 409 :  1  7 16 31 88
max coverage =  48 :  1  5  7  8
max coverage =  71 :  1  4 12 21
max coverage = 409 :  1  7 16 31 88
max coverage =  48 :  1  5  7  8

max coverage =  71 :  1  4 12 21
max coverage = 409 :  1  7 16 31 88
max coverage =  48 :  1  5  7  8
*/

这题本身不难，不知为什么使用sort函数会runtime error, 不使用就可以AC. 以后再看