整数拆分问题的四种解法

整数划分问题是算法中的一个经典命题之一

所谓整数划分,是指把一个正整数n写成如下形式:

n=m_1+m_2+m_3+....+m_i;(其中m_i为正整数,并且1<=m_i<=n),则\{m_1,m_2,m_3,....,m_i\}n的一个划分。

如果\{m_1,m_2,m_3,....,m_i\}中的最大值不超过m,即max\{m_1,m_2,m_3,....,m_i\} <= m,则称它属于n的一个m划分。这里我们记nm划分的个数为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)的方法。

方法一:递归法

根据n和m的关系,考虑下面几种情况:

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

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

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

  1. 划分中包含n的情况,只有一个,即{n};
  2. 划分中不包含n的情况,这时划分中最大的数字也一定比n小,即n的所有(n-1)划分;

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

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

(5)当n>m时,根据划分中是否包含m,可以分为两种情况:

  1. 划分中包含m的情况,即\{m,\{x_1,x_2,x_3,...,x_i\}\},其中\{x_1,x_2,x_3,...,x_i\}的和为n-m,可能再次出现m,因此是(n-m)的m划分,因此这种划分个数为f(n-m, m)
  2. 划分中不包含m的情况,则划分中所有值都比m小,即n(m-1)划分,个数为f(n, m - 1)

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

综合以上各种情况,可以看出,上面的结论具有递归定义的特征,其中(1)和(2)属于回归条件,(3)和(4)属于特殊情况,而情况(5)为通用情况,属于递归的方法,其本质主要是通过减少n或m以达到回归条件,从而解决问题。

其递归表达式如下所示。

参考源码1.1(递归版本(较慢))

#include <stdio.h>

#define MAXNUM 100            //最高次数

//递归法求解整数划分
unsigned long GetPartitionCount(int n, int max)
{
    if(n == 1 || max == 1)
    {
        return 1;
    }
    if(n < max)
    {
        return GetPartitionCount(n, n);
    }
    if(n == max)
    {
        return 1 + GetPartitionCount(n, n - 1);
    }
    else
    {
        return GetPartitionCount(n - max, max) + GetPartitionCount(n, max - 1);
    }
}


int main(int argc, char **argv)
{
    int n;
    int m;
    unsigned long count;
    while(1)
    {
        scanf("%d", &n);
        if(n<=0)
            return 0;
        m=n;
        count = GetPartitionCount(n, m);
        printf("%d\n",count);
    }
    return 0;
}

方法二:动态规划

考虑到使用递归中,很多的子递归重复计算,这样不仅在时间开销特别大,这也是运算太慢的原因,比如算120的时候需要3秒中,计算130的时候需要27秒钟,在计算机200的时候....计算10分钟还没计算出来。。。鉴于此,可以使用动态规划的思想进行程序设计,原理如同上面一样,分成三种情况,只是使用一个数组来代替原有的递归,具体可以参看源码,源码中提供了两个版本 递归+记录版本和数组版本

2.1 递归加记录版本

此版本使用数组标记,如果之前计算过,则直接调用数组中内容,否则计算子递归,这样保证了每次计算一次,减少冗余量

源码如下:

/*----------------------------------------------
 *        Author    :NEWPLAN
 *        Date    :2015-04-01
 *        Email    :xxxxxxx
 *        Copyright:NEWPLAN
-----------------------------------------------*/
#include <iostream>


#define MAXNUM 100            //最高次数
unsigned  long ww[MAXNUM*11][MAXNUM*11];
unsigned long dynamic_GetPartitionCount(int n, int max);

using namespace std;
int main(int argc, char **argv)
{
    int n;
    int m;
    unsigned long count;
	
	while(1)
	{
		cin>>n;
		cout<<dynamic_GetPartitionCount(n,n)<<endl;
	}
	
    return 0;
}

unsigned long dynamic_GetPartitionCount(int n, int max)
{
    if(n == 1 || max == 1)
    {
		ww[n][max]=1;
        return 1;
    }
    if(n < max)
    {
		ww[n][n]=ww[n][n]? ww[n][n] : dynamic_GetPartitionCount(n, n);
		return ww[n][n];
    }
    if(n == max)
    {
		ww[n][max]=ww[n][n-1]?1+ww[n][n-1]:1 + dynamic_GetPartitionCount(n, n - 1);
		return ww[n][max];
    }
    else
    {
		ww[n][max]=ww[n - max][max]? (ww[n - max][max]) : dynamic_GetPartitionCount(n - max, max);
		ww[n][max]+=ww[n][max-1]? (ww[n][max-1]): dynamic_GetPartitionCount(n, max - 1);	
        return ww[n][max];
    }
}

2.2 数组标记法动态规划(从小到大)

考虑到计算ww[10][10]=ww[10][9]+1;所以在每次计算中都是用到之前的记录,这样就可以先从小到大计算出程序,使得计算较大数的时候调用已经计算出的较小的记录,程序直接是用循环就可以完成任务,避免了重复计算和空间栈的开销。

源码:

/*----------------------------------------------
 *        Author    :NEWPLAN
 *        Date    :2015-04-01
 *        Email    :xxxxxxx
 *        Copyright:NEWPLAN
-----------------------------------------------*/
#include <iostream>

#define MAXNUM 100            //最高次数

unsigned  long ww[MAXNUM*11][MAXNUM*11];
unsigned long dynamic_GetPartitionCount(int n, int max);

using namespace std;

int main(int argc, char **argv)
{
    int n;
    int m;
    unsigned long count;
	
	while(1)
	{
		cin>>n;
		cout<<dynamic_GetPartitionCount(n,n)<<endl;
	}
	
    return 0;
}

unsigned long dynamic_GetPartitionCount(int n, int max)
{
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
		{
			if(j==1|| i==1)
			{
				ww[i][j]=1;
			}
			else 
			{
				if(j==i)
					ww[i][j]=ww[i][j-1]+1;
				else if((i-j)<j)
					ww[i][j]=ww[i-j][i-j]+ww[i][j-1];
				else
					ww[i][j]=ww[i-j][j]+ww[i][j-1];
			}
		}
	return ww[n][max];
}

三种方法效果对比十分明显,在写此博客之前测试数据200,动态规划版本输入直接算出结果,现在这片博客写完了,,,使用递归的还没计算出结果。。。


 

方法三:母函数

    下面我们从另一个角度,即“母函数”的角度来考虑这个问题。

    所谓母函数,即为关于x的一个多项式G(x)

    有G(x) = a_0 + a_1*x + a_2*x^2 + a_3*x^3 + ......

    则我们称G(x)为序列(a_0, a_1, a_2,.....)的母函数。关于母函数的思路我们不做更过分析。

    我们从整数划分考虑,假设n的某个划分中,1的出现个数记为a_1,2的个数记为a_2,.....,i的个数记为a_i

    显然有:a_k <=\frac{ n}{k} \ \ (0<= k <=n)

    因此n的划分数f(n,n),也就是从1到nn个数字抽取这样的组合,每个数字理论上可以无限重复出现,即个数随意,使它们的综合为n。显然,数字i可以有如下可能,出现0次(即不出现),1次,2次,......,k次等等。把数字i(x^i)表示,出现k次的数字i(x^{i*k})表示,不出现用1表示。

    例如,数字2用x^2表示,2个2用x^4表示,3个2用x^6表示,k个2用x^{2k}表示。

    则对于从1到N的所有可能组合结果我们可以表示为:

   G(x) = ( 1 + x + x^2 + x^3 + ... + x^n)*(1 + x^2 + x^4 + x^6 + ....)....(1 + x^n)

             = g(x,1)*g(x,2)*g(x,3)*....*g(x,n)

             = a0 + a1*x + a2*x^2 +...+ an*x^n + ....//展开式

    上面的表达式中,每个括号内的多项式代表了数字i的参与到划分中的所有可能情况。因此,该多项式展开后,由于x^a *x^b = x^{a+b},因此x^i就代表了i的划分,展开后x^i项的系数也就是i的所有划分个数,即f(n,n) = a_n

    由此我们找到了关于整数划分的母函数G(x);剩下的问题就是,我们需要求出G(x)的展开后的所有系数。

    为此,我们首先要做多项式乘法,对于我们来说,并不困难。我们把一个关于x的多项式用一个整数数组a[]表示,a[i]代表x^i的系数,即:

   g(x) = a[0] + a[1]x + a[2]x^2 + ... + a[n]x^n;

    则关于多项式乘法的代码如下,其中数组a和数组b表示两个要相乘的多项式,结果存储到数组c中。

参考题目: HDU:1028:Ignatius and the Princess III

参考源码:

#include <iostream>
#include <string.h>
#include <stdio.h>

using namespace std;

const int N=10005;

int c1[N],c2[N];

int main()
{
    int n,i,j,k;
    while(cin>>n)
    {
        if(n==0) break;
        for(i=0;i<=n;i++)
        {
            c1[i]=1;
            c2[i]=0;
        }
        for(i=2;i<=n;i++)
        {
            for(j=0;j<=n;j++)
                for(k=0;k+j<=n;k+=i)
                    c2[k+j]+=c1[j];
            for(j=0;j<=n;j++)
            {
                c1[j]=c2[j];
                c2[j]=0;
            }
        }
        cout<<c1[n]<<endl;
    }
    return 0;
}

方法四:五边形数定理

设第n个五边形数为,那么,即序列为:1, 5, 12, 22, 35, 51, 70, ... 

对应图形如下:

设五边形数的生成函数为,那么有:

以上是五边形数的情况。下面是关于五边形数定理的内容:

五边形数定理是一个由欧拉发现的数学定理,描述欧拉函数展开式的特性。欧拉函数的展开式如下:

欧拉函数展开后,有些次方项被消去,只留下次方项为1, 2, 5, 7, 12, ...的项次,留下来的次方恰为广义五边形数。 

五边形数和分割函数的关系

欧拉函数的倒数是分割函数的母函数,亦即:

   其中为k的分割函数。

上式配合五边形数定理,有:

 

在 n>0 时,等式右侧的系数均为0,比较等式二侧的系数,可得

p(n) - p(n-1) - p(n-2) + p(n-5) + p(n-7) + \cdots=0

因此可得到分割函数p(n)的递归式:

p(n) = p(n-1) + p(n-2) - p(n-5) - p(n-7) + \cdots

例如n=10时,有:

p(10) = p(9) + p(8) - p(5) - p(3) = 30 + 22 - 7 -  3 = 42

所以,通过上面递归式,我们可以很快速地计算n的整数划分方案数p(n)了。

参考例题:

HUD4651:Partition

源码:

#include <iostream>

using namespace std;

#define  MYDATA long long
const MYDATA MOD=1000000007;

#define  AMS 100005
MYDATA pp[AMS];
MYDATA asist[2*AMS];
void myinit()
{
	for(int i=0;i<AMS;i++)
	{
		/*算出五角数(正常五角数为1,5,12,22.... k*(3*k-1)/2)*/
		/*此部分,需要算出的是分割函数(1,2,5,7,12,15,22,26.....
		[k*(3*k-1)/2,k*(3*k+1)/2 ])*/
		asist[2*i]=i*(i*3-1)/2;
		asist[2*i+1]=i*(i*3+1)/2;
	}
}
void mymethod()
{
	pp[1]=1;
	pp[2]=2;
	pp[0]=1;
	for(int i=3;i<AMS;i++)
	{
		int k=0;
		int flags;
		pp[i]=0;
		/*pp[n]=pp[n-1]+pp[n-2]-pp[n-5]-pp[n-7]+pp[12]+pp[15]
		-.... ..... [+pp[n-k*[3k-1]/2]  + pp[n-k*[3k+1]/2]]*/
		for(int j=2;asist[j]<=i;j++)
		{
			/*说明:式子中+MOD是必须的,否则输出可能出错(有可能为负数)*/
			flags=k&2;
			if(!flags)
				pp[i]=(pp[i]+pp[i-asist[j]]+MOD)%MOD;
			else
				pp[i]=(pp[i]-pp[i-asist[j]]+MOD)%MOD;
			k++;
			k%=8;
		}
	}
}

int main()
{ 
	int t,n;
	myinit();
	mymethod();
  
    cin>>t;
    while(t--)
    {
        cin>>n;
	cout<<pp[n]<<endl;
    }
    return 0;
}

附加:

给定一个整数n,输出这个整数拆分的可能形式(即输出全部情况)

使用递归情况

整个输出类似于一颗树,以分解6为例,过程如下图

源码实现:

#include <stdio.h>

//使用一个数组记录在递归过程中产生的前面需要重复输出的值
int set[100];
//用于在递归过程中判断是否递归到最深处,输出回车
int k;

//此函数表示使用不大于m的整数对n进行拆分的情况,i用于表示set数组已经存在的记录数长度
void q(int n,int m,int i)
{
    if(n==k&&n!=m)
    {
        //此时递归栈已经退回到某一分支的最上层,输出回车
        //并重置计数器i为0
        printf("\n");
        i=0;
    }
    if(n==1)
    {
        //当n为1,意味者着只能表示1
        printf("1 ");
        return;
    }
    else if(m==1)
    {
        //当m为1,意味着要输出n个m相加
        for(int i=0; i<n-1; i++)
            printf("1+");
        printf("1 ");
        return;
    }
    if(n<m)
    {
        q(n,n,i);
    }
    if(n==m)
    {
        //当n等于m时,到达本次递归求和的一个叶子,此时需要输出多一个空格,表示下一次输出为另一个叶子
        printf("%d ",n);
        //在递归输出另一个叶子之前,将之前记录的在叶子之上的数一并输出,如上图示过程1
        for(int j=0; j<i; j++)
            printf("%d+",set[j]);
        q(n,m-1,i);

    }
    if(n>m)
    {
        //如果n大于m,使用m作为分解,则要首先输出m+的形式
        printf("%d+",m);
        //记录下作为树干节点m的值并使i自增
        set[i++]=m;
        //递归输出m+以后的分解
        q(n-m,m,i);
        //递归完毕后需要将数组记录后退一个,回到上一个节点,如上图示过程2
        i--;
        //执行另一个分支,在下一次递归之前输出记录的数据,如上图示过程3
        for(int j=0; j<i; j++)
            printf("%d+",set[j]);
        //递归输出另一分支情况
        q(n,m-1,i);
    }


}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        if(n<=0)
        {
            printf("Please input a positive interger.\n\n");
            continue;
        }
        k=n;
        q(n,n,0);
        printf("\n\n");
    }
    return 0;
}

评论 16
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值