[线性dp]数的划分 c语言网1531

题目描述

一个正整数可以划分为多个正整数的和，比如n=3时：
3；1＋2；1＋1＋1；
共有三种划分方法。
给出一个正整数，问有多少种划分方法。

输入

一个正整数n

数据规模和约定
n< =100

输出

一个正整数，表示划分方案数

样例输入

3

样例输出

3

题意： 给出一个数字n，求n有多少种不同的划分方案。

分析： 先列出1到5的所有划分方案，并仔细观察找找规律。

1 = 1
2 = 1+1 or 2
3 = 1+1+1 or 1+2 or 3
4 = 1+1+1+1 or 1+1+2 or 1+3 or 2+2 or 4
5 = 1+1+1+1+1 or 1+1+1+2 or 1+1+3 or 1+2+2 or 1+4 or 2+3 or 5

很明显把上一行的所有方案再添加1个1就能得到下面一行中的部分方案，以5为例，其前5种方案都是把4的5种方案添加1个1，而第6种方案是把3的最后一种方案添加了1个2，这样可以考虑把某个数的划分方案分类，划分方案中最小数字相同的为一类，dp[i][j]则表示第i个数的划分方式中最小数为j的划分方式数，还是以5为例，dp[5][1] = 5，具体为1+1+1+1+1、1+1+1+2、1+1+3、1+2+2和1+4这5种，dp[5][2] = 1，只有2+3这一种，dp[5][3] = dp[5][4] = 0，dp[5][5] = 1，只有5这一种划分方案。设好状态后状态转移方程为也比较简单了，dp[i][j] = sum(dp[i-j][k])，k∈[j, i-j]，时间复杂度为O(n^3)，解决这道题目其实也够用了。

不过最内层循环是可以优化一下的，因为最内层循环不过是个区间求和，在求dp数组时可以维护一个前缀和数组，这个数组要开二维的，sum[i][j]表示第i行前j个数的和，这样最内层循环就可以丢掉了，优化后时间复杂度为O(n^2)。

具体代码如下：

O(n^3)版本：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
using namespace std;
int dp[105][105];
//dp[i][j]表示第i个数的划分方式中最小数为j的划分方式数 

signed main()
{
	int n;
	cin >> n;
	for(int i = 1; i <= n; i++)
		dp[i][i] = 1;
	for(int i = 2; i <= n; i++)
		for(int j = 1; j < i; j++) 
			for(int k = j; k <= i-j; k++)
				dp[i][j] += dp[i-j][k];
	int ans = 0;
	for(int i = 1; i <= n; i++)
		ans += dp[n][i];
	cout << ans;
    return 0;
}

O(n^2)版本：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
using namespace std;
int dp[105][105], sum[105][105];
//dp[i][j]表示第i个数的划分方式中最小数为j的划分方式数 

signed main()
{
	int n;
	cin >> n;
	for(int i = 1; i <= n; i++)
		dp[i][i] = 1;
	sum[1][1] = 1;
	for(int i = 2; i <= n; i++)
	{
		for(int j = 1; j < i; j++) 
		{
			if(i-j >= j)
				dp[i][j] = sum[i-j][i-j]-sum[i-j][j-1];
			sum[i][j] = sum[i][j-1]+dp[i][j];
		}
		sum[i][i] = sum[i][i-1]+1;
	}
	cout << sum[n][n];
    return 0;
}