在少量元素中分配大值

Question

我需要在一个包含n元素的小数组中随机分配一个大整数budget，这样数组中的所有元素将具有相同的分布，并且总和为budget，并且数组中的每个元素都得到至少min。

我有一个在 O(budget) 中运行的算法：

private int[] distribute(int budget, int n, int min) {
  int[] subBudgets = new int[n];
  for (int i = 0; i < n; i++) {
    subBudgets[i] = min;
  }
  budget -= n * min;
  while (budget > 0) {
    subBudgets[random.nextInt(n)]++;
    budget--;
  }
  return subBudgets;
}

但是，当budget 增加时，它可能会非常昂贵。有什么算法可以在 O(n) 甚至更好的时间内运行吗？

Answer 1

首先生成n随机数x[i]，将它们相加，然后将budget除以和得到k。然后将k*x[i] 分配给每个数组元素。它很简单而且 O(n)。

如果您希望每个元素中至少有min 值，您可以修改上述算法，方法是在开始上述算法之前用min（或使用k*x[i] + min）填充所有元素并从budget 分包n*min。

如果您需要使用整数，您可以使用实数 k 和舍入 k*x[i] 来解决问题。然后，您必须跟踪累积舍入误差，如果计算值达到整个单位，则从计算值中添加或减去累积误差。您还必须将剩余值分配给最后一个元素以达到整个 budget。

P.S.：请注意，此算法可以在纯函数式语言中轻松使用。这就是为什么我喜欢这一系列算法为每个成员生成随机数然后进行一些处理的原因。 Erlang 中的实现示例：

-module(budget).

-export([distribute/2, distribute/3]).

distribute(Budget, N) ->
  distribute(Budget, N, 0).

distribute(Budget, N, Min) when
    is_integer(Budget), is_integer(N), N > 0,
    is_integer(Min), Min >= 0, Budget >= N*Min ->
  Xs = [random:uniform() || _ <- lists:seq(1,N) ],
  Rest = Budget - N*Min,
  K = Rest / lists:sum(Xs),
  F = fun(X, {Bgt, Err, Acc}) ->
      Y = X*K + Err,
      Z = round(Y),
      {Bgt - Z, Y - Z, [Z + Min | Acc]}
  end,
  {Bgt, _, T} = lists:foldl(F, {Rest, 0.0, []}, tl(Xs)),
  [Bgt + Min | T].

C++ 中的相同算法（？？我不知道。）

private int[] distribute(int budget, int n, int min) {
  int[] subBudgets = new int[n];
  double[] rands = new double[n];
  double k, err = 0, sum = 0;
  budget -= n * min;
  for (int i = 0; i < n; i++) {
    rands[i] = random.nextDouble();
    sum += rands[i];
  }
  k = (double)budget/sum;
  for (int i = 1; i < n; i++) {
    double y = k*rands[i] + err;
    int z = floor(y+0.5);
    subBudgets[i] = min + z;
    budget -= z;
    err = y - z;
  }
  subBudgets[0] = min + budget;
  return subBudgets;
}

Answer 2

结合@Hynek -Pichi- Vychodil 的想法和我的原始算法，我想出了以下算法，它在 O(n) 中运行，并且所有舍入误差均匀分布到数组中：

private int[] distribute(int budget, int n, int min) {
  int[] subBudgets = new int[n];
  for (int i = 0; i < n; i++) {
    subBudgets[i] = min;
  }
  budget -= n * min;
  if (budget > 3 * n) {
    double[] rands = new double[n];
    double sum = 0;
    for (int i = 0; i < n; i++) {
      rands[i] = random.nextDouble();
      sum += rands[i];
    }
    for (int i =0; i < n; i++) {
      double additionalBudget = budget / sum * rands[i];
      subBudgets[i] += additionalBudget;
      budget -= additionalBudget;
    }
  }
  while (budget > 0) {
    subBudgets[random.nextInt(n)]++;
    budget--;
  }
  return subBudgets;
}

Answer 3

让我用一个例子来演示我的算法：

假设budget = 100, n = 5, min = 10

将数组初始化为：

[10, 10, 10, 10, 10] => current sum = 50

生成一个从0到50的随机整数（50是budget - current sum的结果）：

假设随机整数为20 并更新数组：

[30, 10, 10, 10, 10] => current sum = 70

生成一个从0到30的随机整数（30是budget - current sum的结果）：

假设随机整数为5 并更新数组：

[30, 15, 10, 10, 10] => current sum = 75

重复上面的过程，最后一个元素就是剩下的。

最后，打乱数组得到最终结果。

Answer 4

从多项分布中抽样

您当前将min 分配给每个子预算后剩余的美元的方式包括执行固定数量的budget 随机“试验”，在每次试验中，您随机选择n 之一类别，并且您想知道每个类别被选择了多少次。这是由具有以下参数的multinomial distribution 建模的：

• 试验次数（在 WP 页面上称为 n）：budget
• 类别数（在 WP 页面上称为 k）：n
• 每个试验中类别i 的概率，对于1 <= i <= n：1/n

如果试验数量与类别数量大致相同或更少，那么您目前的做法是一个好方法。但是如果预算很大，还有其他更有效的方法可以从这个分布中抽样。我所知道的最简单的方法是注意到具有k 类别的多项分布可以通过将类别组合在一起来重复分解为二项分布：而不是直接针对每个k 类别有多少选择，我们表达了这一点作为一系列问题：“如何在第一类和其他k-1之间分配预算？”我们接下来问“如何在第二个类别和另一个k-2之间拆分剩余部分？”等等。

因此，顶级二项式具有类别（子预算）1 与其他所有项。通过从参数为n = budget 和p = 1/n 的二项分布中抽取1 个样本来确定进入子预算1 的美元数量（如何做到这一点在here 中有描述）；这将产生一些数字0 <= x[1] <= n。要找到进入子预算 2 的美元数量，请从剩余资金的二项式分布中抽取 1 个样本，即使用参数 n = budget - x[1] 和 p = 1/(n-1)。得到子预算 2 的金额 x[2] 后，将使用参数n = budget - x[1] - x[2] 和 p = 1/(n-2) 等找到子预算 3。