UVa 165 Stamps 【DFS】

Stamps

The government of Nova Mareterrania requires that various legal documents have stamps attached to them so that the government can derive revenue from them. In terms of recent legislation, each class of document is limited in the number of stamps that may be attached to it. The government wishes to know how many different stamps, and of what values, they need to print to allow the widest choice of values to be made up under these conditions. Stamps are always valued in units of $1.

This has been analysed by government mathematicians who have derived a formula for n(h,k), where h is the number of stamps that may be attached to a document, k is the number of denominations of stamps available, and n is the largest attainable value in a continuous sequence starting from $1. For instance, if h=3, k=2 and the denominations are $1 and $4, we can make all the values from $1 to $6 (as well as $8, $9 and $12). However with the same values of h and k, but using $1 and $3 stamps we can make all the values from $1 to $7 (as well as $9). This is maximal, so n(3,2) = 7.

Unfortunately the formula relating n(h,k) to h, k and the values of the stamps has been lost--it was published in one of the government reports but no-one can remember which one, and of the three researchers who started to search for the formula, two died of boredom and the third took a job as a lighthouse keeper because it provided more social stimulation.

The task has now been passed on to you. You doubt the existence of a formula in the first place so you decide to write a program that, for given values of h and k, will determine an optimum set of stamps and the value of n(h,k).

Input

Input will consist of several lines, each containing a value for h and k. The file will be terminated by two zeroes (0 0). For technical reasons the sum of h and k is limited to 9. (The President lost his little finger in a shooting accident and cannot count past 9).

Output

Output will consist of a line for each value of h and k consisting of the k stamp values in ascending order right justified in fields 3 characters wide, followed by a space and an arrow (->) and the value of n(h,k) right justified in a field 3 characters wide.

Sample input

3 2
0 0

Sample output

  1  3 ->  7

恩，题目大意就是说，不同面额的邮票，输入数据 h 和 k ，意思是有 k 类不同面额的邮票，然后拿 h 张组成面额，求的是能组成的连续的面额的最大值。例如 3 张 2 种，若这两种面额为1 和 4 可以组成从1 到 6 虽然也可以组成8但是不能组成7所有这里的值为6 但是当这两种面额为 1 和 3 时 ，就能组成从1 到7 ，所以输入数据 3 和 2 输出数据应该为 7 。恩，看了人家的题解才懂，要递归遍历面额的不同值，在不同面额的情况下要遍历不同的张数判断能否组成连续的金额，最后找到连续的最大值。然后可以想到 staval[0]为 1 即是面额种类中必有 1 因为很多金额的组成都要用到 1 ，然后maxval [0] 为 h 。然后就是下一种类的面额值怎么找的问题，首先要比前一个面额值大，不能比前一个面额所能组成的最大金额大，因为一旦比它大，就不能组成连续的金额了。例如现有面额值为 1  2  3  下一种就要大于 3 而不能大于9 一旦大于9例如10那么就不能组成9而发生断层了。

#include<cstdio>
#include<cstring>
#define maxn 1001
using namespace std;
int h,k,msum;
int maxval[maxn],staval[maxn],ans[maxn];
bool vis[maxn];
void dfs(int c,int n,int sum)//张数为c种类为n组成的金额为sum
{
    vis[sum]=true;
    if(c>=h)
        return ;
    for(int i=0;i<=n;++i)
        dfs(c+1,n,sum+staval[i]);
}
void rsearch(int c)
{
    if(c>=k)
    {
        if(maxval[c-1]>msum)
        {
            msum=maxval[c-1];
            memcpy(ans,staval,sizeof(staval));
        }
        return ;
    }
    for(int i=staval[c-1]+1;i<=maxval[c-1]+1;++i)
    {
        staval[c]=i;
        memset(vis,false,sizeof(vis));
        dfs(0,c,0);
        int num=0,j=1;
        while(vis[j++])
            ++num;
        maxval[c]=num;
        rsearch(c+1);
    }
}
int main()
{
    while(scanf("%d%d",&h,&k),h+k)
    {
        staval[0]=1;
        maxval[0]=h;
        msum=-1;
        rsearch(1);
        for(int i=0;i<k;++i)
            printf("%3d",ans[i]);
        printf(" ->%3d\n",msum);
    }
    return 0;
}

上面那种递归当数据很大时就会超时了，下面看人家题解是用了动态规划的思想，可以转化为求组成金额 k 所要的（在已有面额种类中）最少的张数。cnt[k] 表示当前情况下组成金额为 k 所需要的最少的张数。http://blog.csdn.net/shuangde800/article/details/7755254这个转载的文章解释的感觉挺好

#include<cstdio>
#include<cstring>
#include<algorithm>
#define inf 0x3f3f3f3f
#define maxn 1001
using namespace std;
int h,k,msum;
int ans[maxn],staval[maxn],maxval[maxn],cnt[maxn];
bool vis[maxn];
void rsearch(int c)
{
    if(c>=k)
    {
        if(msum<maxval[c-1])
        {
            msum=maxval[c-1];
            memcpy(ans,staval,sizeof(staval));
        }
        return ;
    }
    int tem[maxn];
    memcpy(tem,cnt,sizeof(cnt));
    for(int i=staval[c-1]+1;i<=maxval[c-1]+1;++i)
    {
        staval[c]=i;
        for(int j=0;j<staval[c-1]*h;++j)//这里动态规划思想
        {
            if(cnt[j]<h)
            {
                for(int l=1;l<=h-cnt[j];++l)
                {
                    if(cnt[j]+l<cnt[j+l*i]&&j+l*i<maxn)
                        cnt[j+l*i]=cnt[j]+l;
                }
            }
        }
        int r=maxval[c-1];
        while(cnt[r+1]<inf)
            r++;
        maxval[c]=r;
        rsearch(c+1);
        memcpy(cnt,tem,sizeof(tem));
    }
}
int main()
{
    while(scanf("%d%d",&h,&k),h+k)
    {
        staval[0]=1;
        maxval[0]=h;
        msum=-1;
        int i;
        for(i=0;i<=h;++i)
            cnt[i]=i;
        while(i<maxn)
            cnt[i++]=inf;
        rsearch(1);
        for(int i=0;i<k;++i)
            printf("%3d",ans[i]);
        printf(" ->%3d\n",msum);
    }
    return 0;
}