试题 算法训练 数的划分

试题 算法训练 数的划分

资源限制

内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s

---

问题描述

将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。
　　例如：n=7，k=3，下面三种分法被认为是相同的。
　　1，1，5; 1，5，1; 5，1，1;
　　问有多少种不同的分法。

---

输入格式

n，k

输出格式

一个整数，即不同的分法

样例输入

7 3

样例输出

4 
{
四种分法为：
    1，1，5;
    1，2，4;
    1，3，3;
    2，2，3;
}

---

数据规模和约定

6<n<=200，2<=k<=6

分析

拿题目的例子来说n=7,k=3 其实呢就是先 1 1 1 这是必须的就变成了 n=4

可以分成1份给到第3个，

也可以分成2份给到最后2个

为什么呢，因为这题目强调 不考虑顺序 那么我就选择让左边是小的，右边是大的，就不会重复了，那如果只给其中一个加，那就是加到最后，给其中二个加，那就是加到最后两个，那么就是满足的

所以所有的可能就是

int s = 0;
	for (int i = 1; i <= k; i++)
		s += dg(n - k, i);

然后就是递归出口的问题了

第一，必须满足n>=k,不然你想想n=4,k=5怎么可能，是绝对不能存在0的，故得if (n < k)return 0

第二，如果n==k了，还需要继续分吗n=4,k=4不就只有1种可能了吗，故得else if (n == k)return 1;

就这样告一段落了，我去写写dp的方法

代码–递归

#include <iostream>
using namespace std;
const int N = 203;
const int K = 10;

int dg(int n, int k)
{
	if (n < k)return 0;
	else if (n == k)return 1;
	int s = 0;
	for (int i = 1; i <= k; i++)
		s += dg(n - k, i);
	return s;
}

int main()
{
	int n, k;
	cin >> n >> k;
	cout << dg(n, k);
	return 0;
}

代码–上面的递归写成dp

#include <iostream>
using namespace std;
const int N = 203;
const int K = 10;
int dp[N][K];
int main()
{
	int n, k;
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= k && j <= i; j++)
		{
			if (i == j || j == 1)dp[i][j] = 1;
			else
			{
				for (int t = 1; t <= j; t++)
					dp[i][j] += dp[i - j][t];
			}
		}
	cout << dp[n][k];
	return 0;
}

大佬的dp

#include <iostream>
using namespace std;
const int N = 203;
const int K = 10;
int dp[N][K];
int main()
{
	int n, k;
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= k && j <= i; j++)
		{
			if (i == j || j == 1)dp[i][j] = 1;
			else dp[i][j] = dp[i - 1][j - 1] + dp[i - j][j];
		}
	cout << dp[n][k];
	return 0;
}

分析

dp[i][j] = dp[i - 1][j - 1] + dp[i - j][j];

n被分成k份的结果只可能是有1的和没有1的

有1的 == dp[i - 1][j - 1]

举例 n = 7,k = 3 先变成 1 0 0 ,至少有一个1存在，那便是第1个为1 ，故n = 6, k = 2；

你想想把n = 6,k = 2 加到后面两个后满足不？肯定满足因为其绝对是大于1的有序序列至少也会变成 1 1 1

没有1的 == dp[i - j][j]

这就和我上面讲的一样了

每个位置放个1先，后面再继续排