获得加权随机项目

我有这个桌子

+ ----------------- +
| 水果 重量
+ ----------------- +
| 苹果| 4 |
| 橙色| 2 |
| 柠檬| 1 |
+ ----------------- +

我需要归还随机水果。但是苹果的采摘频率应该是柠檬的 4倍和橙子的 2倍。

在更一般的情况下，它应该f(weight)经常出现。

什么是实现此行为的良好通用算法？

也许在Ruby上有一些现成的宝石？:)

PS
我已经在Ruby https://github.com/fl00r/pickup中实现了当前算法

从概念上讲，最简单的解决方案是创建一个列表，其中每个元素的出现次数与其权重相同，因此

fruits = [apple, apple, apple, apple, orange, orange, lemon]

然后使用您可以使用的任何功能从该列表中选择一个随机元素（例如，在适当范围内生成一个随机索引）。当然，这不是很有效的存储，需要整数权重。

另一种稍微复杂一些的方法如下所示：

1. 计算权重的累加和：

   intervals = [4, 6, 7]

   低于4的指数代表苹果，4至6以下的橘子和6至7以下的柠檬。

2. 生成一个n介于0到的随机数sum(weights)。

3. 查找最后一个项，其总和大于n。相应的水果就是您的结果。

与第一种方法相比，此方法需要更复杂的代码，但需要较少的内存和计算量，并且支持浮点权重。

对于这两种算法，对于任意数量的随机选择，设置步骤都可以执行一次。

这是一种算法（在C＃中），该算法可以从任何序列中选择随机加权元素，仅对其进行一次迭代：

public static T Random<T>(this IEnumerable<T> enumerable, Func<T, int> weightFunc)
{
    int totalWeight = 0; // this stores sum of weights of all elements before current
    T selected = default(T); // currently selected element
    foreach (var data in enumerable)
    {
        int weight = weightFunc(data); // weight of current element
        int r = Random.Next(totalWeight + weight); // random value
        if (r >= totalWeight) // probability of this is weight/(totalWeight+weight)
            selected = data; // it is the probability of discarding last selected element and selecting current one instead
        totalWeight += weight; // increase weight sum
    }

    return selected; // when iterations end, selected is some element of sequence. 
}

这是基于以下推理：让我们选择序列的第一个元素作为“当前结果”；然后，在每次迭代中，保留它或丢弃它，然后选择新元素作为当前元素。我们可以计算出最终将要选择的任何给定元素的概率，作为该元素不会在后续步骤中丢弃的所有概率的乘积，再乘以该元素首先被选择的概率。如果进行数学计算，您会发现该乘积简化为（元素的权重）/（所有权重的总和），这正是我们所需要的！

由于此方法仅对输入序列进行一次迭代，因此即使权重之和适合一个int（或您可以为该计数器选择更大的类型），它也适用于非常大的序列

目前的答案已经很不错了，我将对其进行扩展。

正如本杰明所建议的，累积总和通常用于此类问题：

+------------------------+
| fruit  | weight | csum |
+------------------------+
| apple  |   4    |   4  |
| orange |   2    |   6  |
| lemon  |   1    |   7  |
+------------------------+

要在此结构中查找项目，可以使用Nevermind的代码。我通常使用的这段C＃代码：

double r = Random.Next() * totalSum;
for(int i = 0; i < fruit.Count; i++)
{
    if (csum[i] > r)
        return fruit[i];
}

现在到有趣的部分。这种方法的效率如何？最有效的解决方案是什么？我的代码需要O（n）内存并在O（n）时间内运行。我不认为可以用不到O（n）的空间来做到这一点，但是时间复杂度可以低得多，实际上是O（log n）。诀窍是使用二进制搜索而不是常规的for循环。

double r = Random.Next() * totalSum;
int lowGuess = 0;
int highGuess = fruit.Count - 1;

while (highGuess >= lowGuess)
{
    int guess = (lowGuess + highGuess) / 2;
    if ( csum[guess] < r)
        lowGuess = guess + 1;
    else if ( csum[guess] - weight[guess] > r)
        highGuess = guess - 1;
    else
        return fruit[guess];
}

还有一个有关更新权重的故事。在最坏的情况下，更新一个元素的权重会导致更新所有元素的累积和，从而将更新复杂度增加到O（n）。也可以使用二进制索引树将其缩减为O（log n）。

这是一个简单的Python实现：

from random import random

def select(container, weights):
    total_weight = float(sum(weights))
    rel_weight = [w / total_weight for w in weights]

    # Probability for each element
    probs = [sum(rel_weight[:i + 1]) for i in range(len(rel_weight))]

    slot = random()
    for (i, element) in enumerate(container):
        if slot <= probs[i]:
            break

    return element

和

population = ['apple','orange','lemon']
weights = [4, 2, 1]

print select(population, weights)

在遗传算法中，此选择过程称为“ 适应比例选择”或“ 轮盘选择”，因为：

• 车轮的比例会根据其重量值分配给每个可能的选择。这可以通过将选择的权重除以所有选择的总权重，然后将它们归一化为1来实现。
• 然后进行类似于轮盘旋转的随机选择。

典型的算法具有O（N）或O（log N）的复杂度，但您也可以执行O（1）（例如，通过随机接受进行轮盘选择）。

这个要点正是您想要的。

public static Random random = new Random(DateTime.Now.Millisecond);
public int chooseWithChance(params int[] args)
    {
        /*
         * This method takes number of chances and randomly chooses
         * one of them considering their chance to be choosen.    
         * e.g. 
         *   chooseWithChance(0,99) will most probably (%99) return 1
         *   chooseWithChance(99,1) will most probably (%99) return 0
         *   chooseWithChance(0,100) will always return 1.
         *   chooseWithChance(100,0) will always return 0.
         *   chooseWithChance(67,0) will always return 0.
         */
        int argCount = args.Length;
        int sumOfChances = 0;

        for (int i = 0; i < argCount; i++) {
            sumOfChances += args[i];
        }

        double randomDouble = random.NextDouble() * sumOfChances;

        while (sumOfChances > randomDouble)
        {
            sumOfChances -= args[argCount -1];
            argCount--;
        }

        return argCount-1;
    }

您可以像这样使用它：

string[] fruits = new string[] { "apple", "orange", "lemon" };
int choosenOne = chooseWithChance(98,1,1);
Console.WriteLine(fruits[choosenOne]);

上面的代码很可能（％98）返回0，这是给定数组的“ apple”的索引。

同样，此代码测试上面提供的方法：

Console.WriteLine("Start...");
int flipCount = 100;
int headCount = 0;
int tailsCount = 0;

for (int i=0; i< flipCount; i++) {
    if (chooseWithChance(50,50) == 0)
        headCount++;
    else
        tailsCount++;
}

Console.WriteLine("Head count:"+ headCount);
Console.WriteLine("Tails count:"+ tailsCount);

它给出类似以下的输出：

Start...
Head count:52
Tails count:48