hdu 1028 Ignatius and the Princess III

有很多方法：

方法一：

参考：http://blog.youkuaiyun.com/suifengdream/article/details/8588349

题解：

画出解答树，每个结点有两个值（暂时叫左值和右值）不断划分，原则是将大数化为小数，左值大于右值，结点左值的子树的右值大于等于结点的右值。

n = 5、6、7、8时解答树如下：

由n=8的解答树，可知该解答树有4个子树记作A[8][1]、A[8][2]、A[8][3]、A[8][4]

A[8][1] = A[7][1] + A[7][2] + A[7][3] + 1.

A[8][2] = A[6][2] + A[6][3] + 1

A[8][3] = A[5][3] + 1

A[8][4] = A[4][4] + 1

记A[8][0]为n=8的总结点，则A[8][0] = A[8][1] + A[8][2] + A[8][3] + A[8][4] + 1

由此规律，代码如下：

//递推做法，建立一颗解答树

#include<iostream>
#include<string>
using namespace std;
int a[125][70];


int main()
{
	int i, j, k;
	for(i = 1; i <= 120; i++)
	{
		a[i][0] = 1;
		for(j = 1; j <= i/2; j++)
		{
			for(k = j; k <= i/2; k++)
				a[i][j] += a[i-j][k];
			a[i][j]++;
			a[i][0] += a[i][j];
		}
	}
	int n;
	while(scanf("%d", &n) != EOF)
		printf("%d\n", a[n][0]);
	return 0;
}

方法二：

整数划分的递归算法：

int split(int n, int m)
{
 if(n < 1 || m < 1)
  return 0;
 if(n == 1 || m == 1)
  return 1;
 if(n < m) 
  return split(n, n);
 if(n == m) 
  return (split(n, m - 1) + 1);
 if(n > m)
  return (split(n, m - 1) + split((n - m), m));
}

递归算法易于理解。但是由于多次重复计算，会很浪费时间。所以需要转化成非递归的算法。如下：

 

首先，我们引进一个小小概念来方便描述吧，record[n][m]是把自然数划划分成所有元素不大于m的分法，例如：

当n=4，m=1时，要求所有的元素都比m小，所以划分法只有1种：{1，1，1，1}；

当n=4，m=2时，。。。。。。。。。。。。。。。。只有3种{1，1，1，1},{2，1，1}，{2，2}；

当n=4，m=3时，。。。。。。。。。。。。。。。。只有4种{1，1，1，1},{2，1，1}，{2，2},{3,1}；

当n=4，m=5时，。。。。。。。。。。。。。。。。只有5种{1，1，1，1},{2，1，1}，{2，2},{3,1},{4}；

从上面我们可以发现：当n==1||m==1时，只有一种分法；

当n<m时，由于分法不可能出现负数，所以record[n][m]=record[n][n];

当n==m时，那么就得分析是否要分出m这一个数，如果要分那就只有一种{m}，要是不分，那就是把n分成不大于m-1的若干份；即record[n][n]=1+record[n][n-1];

当n>m时，那么就得分析是否要分出m这一个数，如果要分那就{{m},{x1,x2,x3..}}时n-m的分法record[n-m][m]，要是不分，那就是把n分成不大于m-1的若干份；即record[n][n]=record[n-m][m]+record[n][m-1];

其中的dp[n][m-1]便是将n进行进行整数的划分，最大的数不超过m-1的方案数；dp[n-m][]表示拿出一个m后，剩下的数被不超过m的数的表示的方案数。

参考代码：

//动态规划，递推


#include<iostream>
#define Max 125
using namespace std;
int dp[Max][Max];

void calc()
{
	dp[1][1] = 1;
	int i, j;
	for(i = 1; i < Max; i++)
	{
		for(j = 1; j < Max; j++)
		{
			if(i == j)
				dp[i][j] = dp[i][j-1] + 1;
			else if(i < j)
				dp[i][j] = dp[i][i];
			else
				dp[i][j] = dp[i-j][j] + dp[i][j-1];

		}
	}
}

int main()
{
	calc();
	int n;
	while(scanf("%d", &n) != EOF)
	{
		printf("%d\n", dp[n][n]);
	}
	return 0;
}

//也可以将二维数组转会为以为数组
#include<stdio.h>
#include<string.h>

int main()
{
    int dp[121];
    int n,i,j;
    while(scanf("%d",&n)!=EOF)
    {
        memset(dp,0,sizeof(dp));
        dp[0]=1;
        for(i=1;i<=n;i++)
			for(j=i;j<=n;j++)
				dp[j]+=dp[j-i];
        printf("%d\n",dp[n]);
    }
    return 0;
}

方法三：

母函数

//母函数

#include<iostream>
using namespace std;
const Num = 120;

int ch[2][Num+3]; 

int main()
{
	int n;
	while(scanf("%d", &n) != EOF)
	{
		memset(ch, 0, sizeof(ch));
		int i, j, k;
		for( i=0; i <= n; i++ )
			ch[1][i] = 1;
		int row, now;
		for( i=2; i <= n; i++ )
		{
			now = i%2;
			row = (i-1)%2;
			for( j=0; j <=n; j++)
				ch[now][j]=0;
			for( j=0; j <= n; j++ )
				for( k=0; j+k <=n; k+=i)
					ch[now][j+k] += ch[row][j];
		}
		printf("%d\n", ch[n%2][n]);
	}
	return 0;
}