nyoj 90 整数划分(一) (dp||递归)

整数划分

时间限制： 3000  ms  |  内存限制： 65535  KB

难度： 3

描述

将正整数n表示成一系列正整数之和：n=n1+n2+…+nk， 
其中n1≥n2≥…≥nk≥1，k≥1。 
正整数n的这种表示称为正整数n的划分。求正整数n的不 
同划分个数。 
例如正整数6有如下11种不同的划分： 
6； 
5+1； 
4+2，4+1+1； 
3+3，3+2+1，3+1+1+1； 
2+2+2，2+2+1+1，2+1+1+1+1； 
1+1+1+1+1+1。 

输入

第一行是测试数据的数目M（1<=M<=10）。以下每行均包含一个整数n（1<=n<=10）。

输出

输出每组测试数据有多少种分法。

样例输入

1
6

样例输出

11  

一： DP

数据范围比较小，可以直接通过DP打表，重点是如何DP

此题可以转变下思路，转化为完全背包问题，一个数n可以由无数个1,2,3...n-1 ,相加等于n得到 。。。。

背包有1--n种，第i种重量为i，价值为i，

        dp[0] = 1;

        for (i = 1;i <= N;i++)

            for (j = i;j <= N;j++)

                dp[j] += dp[j-i];

 

 未优化

#include<algorithm>
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int dp[15][15];
int main()
{
    for(int i = 0 ; i < 15 ; i++)
        dp[0][i]=0;
    dp[0][0]=1;
    for(int i = 1 ; i < 15 ; i++)
    {
        for(int j = 0 ; j < i ; j++)
            dp[i][j]=dp[i-1][j];
        for(int j = i ; j < 15 ; j++)
            dp[i][j]=dp[i-1][j] + dp[i][j-i];
    }
//    for(int i = 0; i < 15 ;i++)
//    {
//        for(int j = 0 ; j < 15 ; j++)
//        printf("%d ",dp[i][j]);
//        puts("");
//    }
//        for(int i = 0; i < 15 ;i++)
//    {
//        for(int j = 0 ; j <= i  ; j++)
//        printf("%d ",dp[i][j]);
//        puts("");
//    }

    int t,a;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&a);
        printf("%d\n",dp[a][a]);
    }
    return 0;
}

优化过：

 

#include<algorithm>
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int dp[15];
int main()
{
    memset(dp,0,sizeof(dp));
    dp[0]=1;
    for(int i = 1 ; i < 15 ; i++)
    {
        for(int j = i ; j < 15 ; j++)
            dp[j]+=dp[j-i];
    }
    int t,a;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&a);
        printf("%d\n",dp[a]);
    }
    return 0;
}

二：递归

将正整数 n 表示成一系列正整数之和， n=n1+n2+…+nk, 其中 n1>=n2>=…>=nk>=1 ， k>=1 。
正整数 n 的这种表示称为正整数 n 的划分。正整数 n 的不同的划分个数称为正整数 n 的划分数，记作 p(n) 。
例如正整数 6 有如下 11 种不同的划分，所以 p(6)=11 。
6;
5+1;
4+2,4+1+1;
3+3,3+2+1,3+1+1+1;
2+2+2,2+2+1+1,2+1+1+1+1;
1+1+1+1+1+1.
在正整数 n 所有不同的划分中，将最大加数 n1 不大于 m 的划分个数记作 q(n,m) ，称它为属于 n 的一个 m 划分。根据 n 和 m 的关系，考虑以下几种情况：  

        (1)  当 n=1 时，不论 m 的值为多少（ m>0) ，只有一种划分即 {1};

        (2)  当 m=1 时，不论 n 的值为多少，只有一种划分即 n 个 1 ， {1,1,1,...,1};

        (3)  当 n=m 时，根据划分中是否包含 n ，可以分为两种情况：

              (a). 划分中包含 n 的情况，只有一个即 {n} ；

              (b). 划分中不包含 n 的情况，这时划分中最大的数字也一定比 n 小，即 n 的所有 (n-1) 划分。

              因此 q(n,n) =1 + q(n,n-1);

        (4) 当 n<m 时，由于划分中不可能出现负数，因此就相当于 q(n,n);

        (5) 但 n>m 时，根据划分中是否包含最大值 m ，可以分为两种情况：

               (a). 划分中包含 m 的情况，即 {m, {x1,x2,...xi}}, 其中 {x1,x2,... xi}  的和为 n-m ，可能再次出现 m ，因此是（ n-m ）的 m 划分，因此这种划分个数为 q(n-m, m);

               (b). 划分中不包含 m 的情况，则划分中所有值都比 m 小，即 n 的 (m-1) 划分，个数为 q(n,m-1);

              因此 q(n, m) = q(n-m, m)+q(n,m-1);

 

         综合以上情况，我们可以看出，上面的结论具有递归定义特征，其中（ 1 ）和（ 2 ）属于边界条件，（ 3 ）和（ 4 ）属于特殊情况，将会转换为情况（ 5 ）。而情况 （ 5 ）为通用情况，属于递推的方法，其本质主要是通过减小 m 以达到边界条件，从而解决问题。其递推表达式如下：

                                                          0                                             n<1 或 m<1

                                                          1                                             n=1 或 m=1

                         q(n,m)     =               q(n,n)                                     n<m

                                                          1+q(n,n-1)                             n=m

                                                           q(n,m-1)+q(n-m,m)              n>m>1

据此，可设计计算 q(n,m) 的递归算法如下。其中，正整数 n 的划分数 P(n)=q(n,n) 。

#include<algorithm>
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int part(int n,int m )
{
    if(n==1||m==1) return 1;
    if(n==m) return part(n,m-1)+1;
    return part(n,m-1)+part(n-m,m);
}
int main()
{
    int t,a,b;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&a);
        b = part(a,a);
        printf("%d\n",b);
    }
    return 0;
}