算法训练 数的划分

ALGO-22 数的划分

资源限制

时间限制：1.0s 内存限制：256.0MB

问题描述

将整数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

AC code：

import java.util.Scanner;

public class Main {

    static int cnt;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        dp(1, sc.nextInt(), sc.nextInt());
        System.out.print(cnt);
    }

    static void dp(int i, int n, int k) {
        if (k == 1) cnt++;
        else for (int l = n / k; i <= l; i++) dp(i,n - i, k - 1);
    }
}

我知道只要保证分切的递增的就等价于分切任意两份不相同

在网上看了一大把理论，看完还是只懂这条

呜呜呜
连接_1
连接_2

有兴趣的可以看一下，由于别人的推导我们可以得知

dp(i, j) = dp(i - j, j) + dp(i - 1, j - 1)
又或
F(a, b) = g(a, b-a)
g(a, b) = g(a-1, b) + g(a, b-a) (1 <= i <= a - 1)

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), k = sc.nextInt();
        int[][] dp = new int[n + 1][k + 1];
        dp[1][1] = 1;
        for (int i = 2; i <= n; i++)
            for (int j = 1; j <= k; j++) if (i >= j) dp[i][j] = dp[i - j][j] + dp[i - 1][j - 1];
        System.out.print(dp[n][k]);
    }
}

又或

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), k = sc.nextInt(), fg = n - k;
        int[][] g = new int[k + 1][n + 1];
        java.util.Arrays.fill(g[1], 1);
        for (int i = 2; i <= k; i++)
            for (int j = 0; j <= fg; j++) g[i][j] = g[i - 1][j] + (j >= i? g[i][j - i]: 0);
        System.out.print(g[k][fg]);
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), k = sc.nextInt(), fg = n - k;
        int[] g = new int[n + 1];
        java.util.Arrays.fill(g, 1);
        for (int i = 2; i <= k; i++)
            for (int j = 0; j <= fg; j++) if(j >= i) g[j] += g[j - i];
        System.out.print(g[fg]);
    }
}

真的啊，我这优化水平，给大佬打个杂不过分吧

自闭

你要不说我还真不知道这是动态规划题

After Rain - Aimer