洛谷 P1025 [NOIP2001 提高组] 数的划分

题目描述

将整数 $n$ 分成 $k$ 份，且每份不能为空，任意两个方案不相同(不考虑顺序)。

例如：$n=7$ ，$k=3$，下面三种分法被认为是相同的。

$1,1,5$ ;
$1,5,1$ ;
$5,1,1$ .

问有多少种不同的分法。

输入格式

$n$ , $k$ $($ $6<n\le 200$ ，$2\le k\le 6$ $)$

输出格式

$1$个整数，即不同的分法。

输入输出样例

输入 #1

7 3

输出 #1

4

说明/提示

四种分法为：
$1,1,5$ ;
$1,2,4$ ;
$1,3,3$ ;
$2,2,3$ .

【题目来源】

$NOIP2001$ 提高组第二题

代码实现

方法一：使用深搜实现

import java.util.Scanner;

public class P1025 {

    public static int n;
    public static int k;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        n = sc.nextInt();
        k = sc.nextInt();

        dfs(1,0,0);

        System.out.println(count);
    }

    public static int count = 0;

    /**
     *
     * @param last:实现遍历递增，使遍历不重复
     * @param sum:累计到当前位置的遍历和
     * @param index:遍历的当前位置
     */
    public static void dfs(int last,int sum,int index){
        if(index == k){
            if(sum == n){
                count++;
            }
            return;
        }

        //剪枝的实现，因为是递增，所以后面每一个数都大于等于当前数
        for(int i=last;sum+(k-index)*i<=n;i++){   
            dfs(i,sum+i,index+1);
        }
    }

方法二：使用动态规划实现

import java.util.Scanner;

public class P025 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();

        int maxn = n+2;
        int maxm = k+2;
        /*
            dp[i][j]:表示将i分成j份一共有多少中方法
            sum[i][j]:表示将i分成1~j份的和
         */
        int[][] dp = new int[maxn][maxm];
        int[][] sum = new int[maxn][maxm];

        for(int i=0;i<maxn;i++){
            dp[i][0] = 1;    //将n分成0份只有一种方法
            dp[i][1] = 1;    //将n分成1份也只有一种方法
            if(i<=k)  dp[i][i] = 1;    //将n分成n份也只有一种方法
            sum[i][1] = 1;
        }

        for(int i=2;i<maxn;i++){
            //j 不可能大于 i
            for(int j=2;j<=Math.min(i,maxm-1);j++){
                if(i!=j){
                    dp[i][j] =  sum[i-j][Math.min(j,i-j)];    //剩下的份数与要分的份数
                }
                sum[i][j] = sum[i][j-1] + dp[i][j];
            }
        }

        System.out.println(dp[n][k]);
    }
}
/*
dp[i][j]
先将i 给每个份分1 则剩下为i-j
则dp[i][j] = dp[i-j][1]+dp[i-j][2]+...+dp[i-j][k]
k = Math.min(j,i-j)  j:要分成j份   i-j:还剩下i-j份
 */