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

最新推荐文章于 2019-01-20 18:55:30 发布

转载最新推荐文章于 2019-01-20 18:55:30 发布 · 519 阅读

DP 同时被 2 个专栏收录

14 篇文章

订阅专栏

递归

3 篇文章

订阅专栏

本文探讨了整数划分的概念及应用，详细介绍了利用动态规划和完全背包算法解决整数划分问题的方法，并提供了优化后的代码实现。同时，阐述了递归方法在整数划分中的应用，包括边界条件、特殊情形及通用情况的处理策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

整数划分

时间限制：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

样例输出

一： 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;
}