杭电OJ 1028（C++）

本题使用动态规划算法，递归函数的声明为int split(int n, int m)，其中n为要划分的正整数，m是划分中最大的正整数。

算法的基本思想如下：

1. 将计算过的值存储在备忘录（数组）中，下次使用时直接调用，不再重复计算；
2. 当n==0或者m==0时，存储0并返回；
3. 当n==1或者m==1时，存储1并返回；
4. 当m>n时，存储split(n,n)并返回；
5. 当m==n时，只有n自身包含m，存储split(n,m-1)+1并返回；
6. 当m<n时，分为分解包含m和不包含m两种情况，存储split(n,m-1)+split(n-m,m)并返回。

有两种动态规划算法，一种是带备忘录的自顶向下算法，在基本递归的基础上保存已经计算过的子问题，下次计算相同的子问题时直接调用结果，不再重复计算。这种算法的AC代码如下：

#include <iostream>
using namespace std;

int dp[130][130]; //备忘录
int split(int n, int m); //带备忘录的自顶向下动态规划算法

int main()
{
	int N;
	
	while (cin >> N)
	{
		memset(dp, 0, sizeof(dp));
		cout << split(N, N) << endl;
	}
	return 0;
}

int split(int n, int m) //带备忘录的自顶向下动态规划算法
{
	if (dp[n][m] > 0)
		return dp[n][m];
	else if (n == 0 || m == 0)
		return dp[n][m] = 0;
	else if (n == 1 || m == 1)
		return dp[n][m] = 1;
	else if (m > n)
		return dp[n][m] = split(n, n);
	else if (m == n)
		return dp[n][m] = split(n, m - 1) + 1;
	else if (m < n)
		return dp[n][m] = split(n, m - 1) + split(n - m, m);
}

另一种是自底向上的算法，每个子问题都是由更小的子问题的解求出的，先计算出所有子问题的解，然后查找即可。这种算法的AC代码如下：

#include <iostream>
using namespace std;

int arr[130][130];

int main()
{
	int N;
	memset(arr, 0, sizeof(arr));
	int i, j;
	for (i = 0; i < 122; i++)
	{
		arr[0][i] = 0;
		arr[i][0] = 0;
	}
	for (i = 1; i < 122; i++)
	{
		arr[1][i] = 1;
		arr[i][1] = 1;
	}
	for (i = 2; i < 122; i++)
	{
		for (j = 2; j < 122; j++)
		{
			if (i < j)
				arr[i][j] = arr[i][i];
			else if (i == j)
				arr[i][j] = arr[i][j - 1] + 1;
			else
				arr[i][j] = arr[i][j - 1] + arr[i - j][j];
		}
	}
	while (cin >> N)
	{
		cout << arr[N][N] << endl;
	}
	return 0;
}

继续加油。