Dollar Dayz POJ - 3181

Farmer John goes to Dollar Days at The Cow Store and discovers an unlimited number of tools on sale. During his first visit, the tools are selling variously for $1, $2, and $3. Farmer John has exactly $5 to spend. He can buy 5 tools at $1 each or 1 tool at $3 and an additional 1 tool at $2. Of course, there are other combinations for a total of 5 different ways FJ can spend all his money on tools. Here they are:

        1 @ US$3 + 1 @ US$2

        1 @ US$3 + 2 @ US$1

        1 @ US$2 + 3 @ US$1

        2 @ US$2 + 1 @ US$1

        5 @ US$1

Write a program than will compute the number of ways FJ can spend N dollars (1 <= N <= 1000) at The Cow Store for tools on sale with a cost of $1..$K (1 <= K <= 100).

Input

A single line with two space-separated integers: N and K.

Output

A single line with a single integer that is the number of unique ways FJ can spend his money.

Sample Input

5 3

Sample Output

5

题目大意：
输入n，和k，问将n用1到k这k个数字进行拆分，有多少种拆分方法。例如：

n=5,k=3 则有n=3+2,n=3+1+1,n=2+1+1+1,n=2+2+1,n=1+1+1+1+1这5种拆分方法

解题思路：

这个题目是个比较明显的动态规划，如果想不到是背包问题，也可以写出状态转移方程如下：

用a[i][j]表示用最大值为i的值，可以组成j的数量，可以得到状态转移方程如下：

a[i][j]=a[i][j-1]+a[i-j][j-1]+a[i-2j][j-1]+a[i-3j][j-1]…+a[0][j-1]意思很明显，就将j-1状态可以到达a[i][j]的状态的数字相加。由于得到的结果可能相当大，已经超过了long long，所以应该用大数。但是若跑完所有数据，用大数会超过一秒，我们通过大数的程序可以达到，最大的数字为33位，那么，我们可以将两个long long的数字进行拼接，组成一个超过33位的数。这样增加了速度，这种比较慢的算法也可以不超时。ac的代码如下：

#include <iostream>
#include<cstdio>
using namespace std;

long long a[1200][200]={0},b[1200][120]={0};

int main()
{
    int i,j,n,m,k;
    long long inf,x;
    inf=1;
    for(i=0;i<18;i++)
    {
        inf=inf*10;
    }
    cin>>n>>m;
    for(i=1;i<=n;i++)
    {
        b[i][1]=0;
        a[i][1]=1;
        for(j=2;j<=m;j++)
        {
            if(j>i)
            {
                a[i][j]=a[i][j-1];
                b[i][j]=b[i][j-1];
                continue;
            }
            a[i][j]=a[i][j-1];
            b[i][j]=b[i][j-1];
            for(k=1;k*j<=i;k++)
            {
                if(i-j*k==0)
                {
                    a[i][j]++;
                    b[i][j]+=a[i][j]/inf;
                    a[i][j]=a[i][j]%inf;
                }
                else {
                    b[i][j]+=b[i-j*k][j-1];
                    a[i][j]+=a[i-j*k][j-1];
                    b[i][j]+=a[i][j]/inf;
                    a[i][j]=a[i][j]%inf;
                }
            }
        }
    }
    if(b[n][m]!=0)
    {
        cout<<b[n][m];
    }
    cout<<a[n][m]<<endl;
    return 0;
}

 

其实这个题有更快的方法，看上面这个式子a[i][j]=a[i][j-1]+a[i-j][j-1]+a[i-2j][j-1]+a[i-3j][j-1]…+a[0][j-1]我们可以发现，其实可以转到a[i][j]的状态有两种，一种是a[i][j-1]就是不用j这个数字拼接i这个数字的方法数，另一种是a[i-j][j]就是用了j这个数字拼接的到i-j的方法数那么状态转移方程就可以写成a[i][j]=a[i][j-1]+a[i-j][j]不用加那么多项，就降低了一个数量级的复杂度，仍然利用上面处理大数的方法，得到的ac代码如下：

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

long long a[1100][110],b[1100][110],inf;

int main(){
    int n,k,i,j;
    for(inf=1,i=0;i<18;i++) inf*=10;
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    scanf("%d%d",&n,&k);
    for(i=0;i<=k;i++) a[0][i]=1;
    for(i=1;i<=k;i++){
        for(j=1;j<=n;j++){
            if(j-i<0){
                b[j][i]=b[j][i-1];
                a[j][i]=a[j][i-1];
                continue;
            }
            b[j][i]=b[j][i-1]+b[j-i][i]+(a[j][i-1]+a[j-i][i])/inf;
            a[j][i]=(a[j][i-1]+a[j-i][i])%inf;
        }
    }
    if(b[n][k]) printf("%I64d",b[n][k]);
    printf("%I64d\n",a[n][k]);
    return 0;
}