整数划分（C++）

写在所有的前面：

1. 本文采用C++实现代码
2. 方案2改进为最优解，是本文中唯一没有超时的算法，可通过目录直接跳转
   

题目说明

题目：整数划分

题目出处

广西大学oj
22级《算法设计与分析》第一次课堂作业
链接：https://oj.gxu.edu.cn/contest/619/problem/0004

题目描述Description

一个正整数 n 可以表示成若干个正整数之和，形如： n=n1+n2+…+nk ，其中 n1≥n2≥…≥nk,k≥1 。
我们将这样的一种表示称为正整数 n 的一种划分。
现在给定一个正整数 n ，请你求出 n 共有多少种不同的划分方法。

输入Input

共一行，包含一个整数 n 。

输出Output

共一行，包含一个整数，表示总划分数量。 由于答案可能很大，输出结果请对 10^9+7 取模。

样例Sample

输入

5

输出

7

限制Hint

1≤n≤1000

解答

方案1：逐位分配计数器法（递归）

解题思路

通过递归
从大到小确定每一位的数字
将多余的数字递归给下一位
如果符合条件，计数器加一

一般情况

void cal(a, b)
a 上一位数字
b 可分配数字
i 当前位所取数字
ans 计数器

1. 初始化i，取a，b中较小的值
2. i递减，将剩余的交给下一位 cal(i, b-i)
3. 如果i是最后一位，计数器ans加一

特殊情况

分配第一位时，i初始化为b

代码实现（C++）

long int ans;
int n;

//a 上一位数字
//b 当前可分配
//i 当前所取
void cal(int a, int b)
{
	int i;
	if (b < a || a == 0)i = b;
	else i = a;
	while (i > 0)
	{
		if (b - i == 0) ans++;
		else cal(i, b - i);
		i--;
	}
}

int main()
{
	scanf("%d", &n);
	cal(0, n);
	ans %= (int)1e9 + 7;
	printf("%d", ans);
	return 0;
}

其他解释

时间复杂度、空间复杂度较大，会超时

方案1改进：逐位分配计数器法（循环）

解题思路

从大到小确定每一位的数字
将多余的数字循环给下一位
如果符合条件，计数器加一

一般情况

循环流程：
while流程结束
分配本位
if分配完毕
if转移至上一位
else转移至下一位

• 流程结束：
  • 判断条件：
    • 指针指向负数 a==-1;
  • 流程： break;
• 分配当前位
  判断来自哪里：
  • 上一位： flag==1;
  • 流程：
    • 初始化当前位
      list[a] 初始化为合法最大值：
      if (b < list[a - 1]) list[a] = b;
      else list[a] = list[a - 1];
  • 下一位或当前位： else;
  • 流程：
    • 更新当前位 list[a]–;
    • 标志位 flag=0;
• 分配完毕
  • 判断条件：
    • 当前位分配值与拥有值相等 list[a]==b;
    • 或
    • 当前位为1 list[a]==1;
  • 流程：
    • 计数器加1 ans++;
    • 标志位 flag=2;
• 转移至上一位
  • 判断条件：
    • 当前值为1 list[a]==1;
  • 流程：
    • 指针切换到上一位 a–;
    • 还原拥有值b b+=list[a];
    • 标志值 flag=2;
• 转移至下一位
  • 判断条件：
    • 本位分配没有分配完毕 list[a]!=b;
    • 且
    • 不是来自下一位 flag!=2;
  • 流程：
    • 指针切换到下一位 a++;
    • 更新拥有值b b-=list[a-1];
      标志值 flag=1;

特殊情况

初始化：
计数器 ans=1;
指针 a=0;
第0位 list[0]=n;
拥有值 b=n;
标志值 flag=0;

代码实现

int main()
{
	int n, a, b, flag, ans;//总数，指针，拥有值，标志值，计数器
	//flag==1	来自上一位
	//flag==2	来自下一位
	//flag==0	来自本位
	int list[N];//分配方式数组（从大到小排列）
	scanf("%d", &n);

	//初始化
	ans = 1;
	a = 0;
	list[0] = n;
	b = n;
	flag = 0;

	while (a != -1)
	{
		//分配当前位
		if (flag == 1)
		{
			if (b < list[a - 1]) list[a] = b;
			else list[a] = list[a - 1];			//list[a] 初始化为合法最大值
		}
		else
		{
			list[a]--;
			flag = 0;
		}
		//分配完毕
		if (list[a] == b || list[a] == 1)
		{
			ans++;
			flag = 2;
		}

		//转移至上一位
		if (list[a] == 1)
		{
			a--;
			b += list[a];
			flag = 2;
		}
		//转移至下一位
		if (list[a] != b && flag != 2)
		{
			a++;
			b -= list[a - 1];
			flag = 1;
		}
	}

	ans %= (int)1e9 + 7;
	printf("%d", ans);
	return 0;
}

其他解释

时间复杂度较大，会超时

方案2：右下切分法(递归)

解题思路

根据分配长度由小到大排列
根据分配个数，将上方的分配情况转化为右方和下方的分配情况

一般情况

最大a，拥有值b

a == b					cal(a, b) == cal(a - 1, b) + 1 
a > b					cal(a, b) == cal(b, b) 
a < b					cal(a, b) == cal(a, b - a) + cal(a - 1, b) 

特殊情况

a == 1 || b == 1		(a, b) == 1

代码实现

int cal(int a,int b)
{
	if (a == 1 || b == 1)
		return 1;
	if (a == b)
		return cal(a - 1, b) + 1;
	if (a > b)
		return cal(b, b);
	if (a < b)
		return cal(a, b - a) + cal(a - 1, b);
}

int main()
{
	int n;
	scanf("%d", &n);
	printf("%d", cal(n, n) % ((int)1e9 + 7));
	return 0;
}

其他解释

时间复杂度较大，会超时

方案2改进：左上累加法（动态规划）

解题思路

根据分配长度由小到大排列
根据所取最大值向左向上累加

一般情况

可取最大值 max
在当前最大值下，总数为 i 的可划分的种类数量 dp[i]
dp[i] = (dp[i] + dp[i - max])

特殊情况

dp[0] = 1;
由于最后的值数量级很大，会超过存储长度long long int，
采用double类型也会损失精度
所以每次循环都要依题意对1000000007取模

代码实现

	const int N = 1000 + 5;

	int main()
	{
		int n;
		int dp[1005];

		scanf("%d", &n);
		dp[0] = 1;
		for (int max = 1; max <= n; max++)
		{
			for (int i = max; i <= n; i++)
			{
				dp[i] = (dp[i] + dp[i - max]) % 1000000007;
			}

		}
		printf("%d", dp[n]);
	}

其他解释

此为最优解，未超时