nyoj_90_整数划分_201403161553

 

整数划分

时间限制：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[N][M]表示N为被划分数，M为划分数的最大值，此题M==N，故即求dp[N][N];

1>状态转移方程：

dp[N][M]=dp[N][M-1]+dp[N-M][M];

该怎样理解呢？这里分两步：

Step 1:所划分的最大数不包括M，即每个划分数都是小于M的，此时总数为dp[N][M-1].

Step 2:所划分的最大数包括M，那么这一步被划分数就应该减去一个M，此时总数为dp[N-M][M].

到这里就是完整的思路了，应该注意的是上面的划分，划分数里有重复的数，那么如果要求划分数没有重复的呢，该怎样求呢？

这里的状态转移方程和上面就有点细微区别了.先来看看方程：

2>dp[N][M]=dp[N][M-1]+dp[N-M][M-1];

其实联系1中的步骤就不难理解了，同样分为两步：

Step 1:所划分的最大数不包括M，即每个划分数都是小于M的，此时总数也是dp[N][M-1].

Step 2:所划分的最大数包括M，那么划分就的相应的减去M，注意到不能重复，即M划分数出现的次数只能为1.所以M就得换成M-1了，即dp[N-M][M-1].

3>在拓展一下，要是划分的个数为确定的数呢？即dp[N][K].表示N被划分成K个数.

这时状态转移方程就为

dp[N][K]=dp[N-K][K]+dp[N-1][K-1].

应该这样理解：

Step 1:被划分的K个数中不包括1，那么就应该先自动的为其分配1，K个数共N-K，剩下的数自由分配，总能保证其值大于2，即dp[N-K][K].

Step 2:存在一个数为1的情况，此时剩下的N-1分给K-1个数，即dp[N-1][K-1].

代码如下：

#include <stdio.h>
#include <string.h>
int dp[12][12];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int i,j,n;
        memset(dp,0,sizeof(dp));
        scanf("%d",&n);
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                if(i>j)
                dp[i][j]=dp[i-j][j]+dp[i][j-1];
                else if(i==j)
                dp[i][j]=dp[i][j-1]+1;
                else if(i<j)
                dp[i][j]=dp[i][i];
            }
        }
        printf("%d
",dp[n][n]);
    }
    return 0;
}

 

下面来介绍递归的方法：

整数划分问题是算法中的一个经典命题之一，有关这个问题的讲述在讲解到递归时基本都将涉及。所谓整数划分，是指把一个正整数n写成如下形式：

       n=m1+m2+...+mi; （其中mi为正整数，并且1 <= mi <= n），则{m1,m2,...,mi}为n的一个划分。

       如果{m1,m2,...,mi}中的最大值不超过m，即max(m1,m2,...,mi)<=m，则称它属于n的一个m划分。这里我们记n的m划分的个数为f(n,m);

       例如当n=4时，他有5个划分，{4},{3,1},{2,2},{2,1,1},{1,1,1,1};

       注意4=1+3 和 4=3+1被认为是同一个划分。

       该问题是求出n的所有划分个数，即f(n, n)。下面我们考虑求f(n,m)的方法;

1.递归法：

       根据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)划分。

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

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

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

               (a). 划分中包含m的情况，即{m, {x1,x2,...xi}}, 其中{x1,x2,... xi} 的和为n-m，因此这种情况下

                 为f(n-m,m)

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

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

      综上所述：

                             f(n, m)=   1;                (n=1 or m=1)

                             f(n, n);                        (n<m)

                             1+ f(n, m-1);                (n=m)

                             f(n-m,m)+f(n,m-1);      (n>m)

代码如下：

#include <stdio.h>
int f(int n,int m)  // fun(n, m)表示将整数 n 划分为最大数不超过 m 的划分
{
    if(n==1||m==1)
    return 1;
    else if(m>n)
    return f(n,n);
    else if(m==n)// 此时也是两部分，如果含有 m 则只有一种只含有 m 的划分，如果不含有 m 则转化为最大数不超过 m-1 的划分
    return f(n,m-1)+1;
    else if(m<n)    // 此时将问题转化为两部分  1.划分中含有 m；   2.划分中不含 m
    return f(n,m-1)+f(n-m,m);
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        printf("%d
",f(n,n));
    }
    return 0;
}