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

蒜头君特别喜欢数学。今天，蒜头君突发奇想：如果想要把一个正整数 n分解成不多于 k个正整数相加的形式，那么一共有多少种分解的方式呢？
蒜头君觉得这个问题实在是太难了，于是他想让你帮帮忙。

输入格式

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

输出格式

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

样例输入

5 3

样例输出

5

超时的代码：
dfspackage 划分整数;

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
[k]);
}

}