有多少种方法将 n 个相同的球分成几组，每组至少有 k 个球？

Question

我正在尝试使用带有记忆的递归来做到这一点，我已经确定了以下基本情况。

I) 当 n==k 时，只有一组拥有所有球。

II) 当 k>n 时，任何组都不能有至少 k 个球，因此为零。

我无法从这里继续前进。如何才能做到这一点？

当 n=6 ,k=2 时举例说明 (2,2,2) (4,2) (3,3) (6)

即可以形成4个不同的分组。

Answer 1

这可以用下面描述的二维递归公式来表示：

T(0, k) = 1
T(n, k) = 0   n < k, n != 0
T(n, k) = T(n-k, k)                 +           T(n, k + 1)
             ^                                       ^
    There is a box with k balls,        No box with k balls, advance to next k
            put them 

在上面，T(n,k) 是n 球的分布数量，使得每个盒子至少得到k。
诀窍是将k 视为尽可能少的球数，并将问题分为两种情况：是否有一个正好有k 球的盒子（如果有，放置它们并用@987654327 递归） @balls），或者不（然后，以k+1 的最小值和相同数量的球进行递归）。

示例，计算您的示例：T(6,2)（6 个球，每盒至少 2 个）：

T(6,2) = T(4,2) + T(6,3) 
T(4,2) = T(2,2) + T(4,3) = T(0,2) + T(2,3) + T(1,3) + T(4,4) =
       = T(0,2) + T(2,3) + T(1,3) + T(0,4) + T(4,5) = 
       =  1     +  0     +  0     +  1     +    0 
       = 2
T(6,3) = T(3,3) + T(6,4) = T(0,3) + T(3,4) + T(2,4) + T(6,5)
       = T(0,3) + T(3,4) + T(2,4) + T(1,5) + T(6,6) = 
       = T(0,3) + T(3,4) + T(2,4) + T(1,5) + T(0,6) + T(6,7) =
       =   1    +   0    +   0    +   0    + 1      + 0 
       = 2
T(6,2) = T(4,2) + T(6,3) = 2 + 2 = 4

使用动态规划，可以在O(n^2)时间计算。

Answer 2

这个案例可以很简单的解决：

桶数

最大桶数b可以如下确定：

b = roundDown(n / k)

每个有效分发最多可以使用b 个桶。

具有x 存储桶的分布数

对于给定数量的桶，分布的数量可以很简单地找到：
将k 球分发到每个桶。找出将剩余球（r = n - k * x）分配给x桶的方法数：

total_distributions(x) = bincoefficient(x , n - k * x)

编辑：如果顺序很重要，这将起作用。既然它不是问题，我们可以在这里使用一些技巧：

每个分布都可以映射到一个数字序列。例如：d = {d1 , d2 , ... , dx}。我们可以轻松地生成所有这些序列，从“第一个”序列{r , 0 , ... , 0} 开始，然后从左向右移动 1。所以下一个序列看起来像这样：{r - 1 , 1 , ... , 0}。如果只生成匹配d1 >= d2 >= ... >= dx 的序列，则不会生成重复。这个约束可以很容易地用来优化这个搜索：如果给定了da - 1 >= db + 1，我们只能将一个1从da移动到db（使用a = b - 1），否则数组排序的约束被违反。要移动的 1 始终是可以移动的最右边。另一种思考方式是将r 视为一元数字，然后将该字符串简单地拆分成组，这样每个组至少只要它是继任者。

 countSequences(x)
     sequence[]
     sequence[0] = r

     sequenceCount = 1

     while true
         int i = findRightmostMoveable(sequence)

         if i == -1
             return sequenceCount

         sequence[i] -= 1
         sequence[i + 1] -= 1
         sequenceCount

findRightmostMoveable(sequence)
    for i in [length(sequence) - 1 , 0)
       if sequence[i - 1] > sequence[i] + 1
           return i - 1

return -1

实际上findRightmostMoveable 可以稍微优化一下，如果我们看一下序列的结构转换（更准确地说是序列的两个元素之间的差异）。但老实说，我懒得进一步优化。

拼凑起来

range(1 , roundDown(n / k)).map(b -> countSequences(b)).sum()