2018第五次蓝桥杯模拟--划分数字

蒜头君特别喜欢数学。今天，蒜头君突发奇想：如果想要把一个正整数 n分解成不多于 k个正整数相加的形式，那么一共有多少种分解的方式呢？

蒜头君觉得这个问题实在是太难了，于是他想让你帮帮忙。

输入格式

共一行，包含两个整数 $n(1\le n\le 300)$ 和 $k(1\le k\le 300)$，含义如题意所示。

输出格式

一个数字，代表所求的方案数。

样例输入

5 3

样例输出

5

超时的代码：

dfs

package 划分整数;

import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

public class Main {
	static long ants=0;
	static int n,k;

	static Set<String>set=new HashSet<String>();
	static List<Integer>list=new LinkedList<Integer>();
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		n=in.nextInt();
		k=in.nextInt();
		dfs(n,0);
		System.out.println(ants);
	}
	public static void dfs(int x,int cn){
		if(cn>k) return;
		if(x<0) return;
		if(x==0){
			if(cn<=k){
				List<Integer>t=new LinkedList<Integer>();
				for(int i=0;i<list.size();i++){
					t.add(list.get(i));
				}
				Collections.sort(list);
				if(!set.contains(list.toString())){
					set.add(list.toString());
					ants++;				
				}
				list=t;
			}
			return;
		}
		for(int i=1;i<=n;i++){
			if(x<0) break;
			x=x-i;
			cn++;
			list.add(i);
			dfs(x,cn);
			list.remove(list.size()-1);
			x=x+i;
			cn--;
		}
	}

}

动态规划分析：

dp:

采用动态规划的方式。令 dp(n, k) 表示将 n 分解为不超过 k 个数之和的方案数。分成四种情况讨论，1. n = 1 或者 k = 1 的时候，只有一种方案。2. n < k 的时候，实际上方案树就是 dp(n ,n)，因为 n 不可能分解超过 n 个数。

3. n > k 的时候，这时候，我们情况，如果一定拆成 k 个数，那么实际上每个数必须大于等于 1，我们把每个数都减去 1，那么对应的方案数是 dp(n - k, k)，如果拆成小于 k 个数，那么就是 dp(n, k - 1)，这时候方案数是 dp(n, k - 1) + dp(n - k, k)。

例如dp[5][3]=dp[2][3]+dp[5][2];

n=k;当划分3个数时5=1+3+1,5=1+2+2，将划分出的每个数减去1，相当于划,为：5-3=2,2=2；2=1+1

n<k;划分的数个数小于3时，相当于划分dp[5][2];

4. n = k 的时候，沿用 3 结论，这时候，如果一定要拆成 k 个数，实际上只有一种方案，那么总方案为 dp(n, k-1) + 1。

package 划分整数动态规划;

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int n,k;
		Scanner in=new Scanner(System.in);
		n=in.nextInt();
		k=in.nextInt();
		long dp[][]=new long[n+1][k+1];
		
		for(int i=1;i<=n;i++){
			for(int j=1;j<=k;j++){
				if(i==1&&j==1) dp[i][j]=1;
				else 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];
				}
			}
		}
		System.out.println(dp[n][k]);
	}

}