根据概率选择获胜者的随机数

Question

假设您有一个哈希数组，代表竞争对手及其中奖概率（0 到 1 之间的浮点数）。喜欢：

  [ {:name => "Adam" , :prob => 0.5}
    {:name => "Ben" , :prob => 1.0}
    {:name => "Chris" , :prob => 0.1}
    {:name => "Daniel" , :prob => 0.2}
    {:name => "Ed" , :prob => 0.7}
    {:name => "Frey" , :prob => 0.5}
    {:name => "Gilbert" , :prob => 0.3}
  ]

我想要一个算法，我可以使用随机数选择三个获胜者，但要尊重每个人的概率。

样本的总概率为3.3

一种合乎逻辑的方法是计算随机值，例如：

val = rand(33)/10.0

并扫描数组，直到找到达到随机数的人。

这种方法有效，但它意味着对数组进行扫描。

我想知道是否会有更直接的解决方案。有什么想法吗？

PS：想象一下这个数组可能有很多元素。

Answer 1

创建一个循环，直到选出 3 名获胜者。在这个循环中，使用您选择的编程语言中可用的任何随机方法生成一个特定的随机数。在此之后，开始迭代用户。如果任何用户的概率小于此随机数，则接受该用户为获胜者。如果在循环的任何迭代中未选择获胜者，例如，在列表中的最低概率为 0.2 且生成的随机数为 0.1 的情况下，在这种情况下，继续循环的下一次迭代。当您获得 3 名获胜者时，跳出循环。可能的伪代码如下：

int count=0;
while(count<3){
    temp=GenerateRandomNumber()
    int userIndex= AcceptWinner(UserListProbability,temp)
    //here keep iterating through the users to check which user's probability is less than temp and returns the index of the winner in the List

    if(userIndex==-1)//No winner selected
        continue;
    else{
        count++;
        Print List(userIndex)
    }
}

注意：列表应该排序

Answer 2

我正在考虑这个问题，我认为我的结果是有道理的：

1. 根据概率对向量进行排序：[a=0.1,b=0.2,c=0.3,d=0.4]
2. 选择一个随机数（例如 0.5）
3. 从头开始迭代并对概率值求和，当它更高时停止： 答案 = 0.1 + 0.2 + 0.3。所以，0.6 > 0.5，我们重视“c”

我的要点是向量末尾的值应该有更高的被选中概率。我已经在python中实现了：

values = [0.1,0.2,0.3,0.4]
count_values = len(values)*[0]
answer = len(values)*[0]

iterations = 10000 

for i in range(0,iterations):
    rand = float(random.randint(0,iterations))/iterations
    count = 0
    sum = 0
    while sum <= rand and count <= len(values):
        sum += values[count]
        count += 1
    count_values[count-1]+=1

for i in range(0,len(count_values)):
    answer[i] = float(count_values[i])/iterations

并运行了几次，我计算了所有元素被选择的概率，这应该与我们的初始概率相匹配：

[0.1043, 0.196, 0.307, 0.3927]
[0.1018, 0.2003, 0.2954, 0.4025]
[0.0965, 0.1997, 0.3039, 0.3999]

Answer 3

我假设在您的示例中，“概率”表示“体重”（因此概率为 1.0 的人不能保证获胜，总概率之和也不会为 1.0）

您可以构建一个节点树，其中叶节点包含您的各个条目：

leaf1 = {:name => "Adam" , :prob => 0.5}
leaf2 = {:name => "Ben" , :prob => 1.0}

每个节点都包含其下节点的总和

node1 = { :prob_sum => 1.5 , :children=> [ leaf1, leaf2] }

然后根节点包含整个结构的总和

root_node = { :prob_sum => 33 , :children => [ leaf9, leaf10] }

然后你在零和根节点中包含的总和之间选择一个随机数。

my_random = rand( root_node.prob_sum )

然后遍历树。每个节点都包含其下所有节点的总和，因此如果您的随机数大于该节点，则减去该节点的值并跳过该分支。

def find_node( my_random ):
c = children.first()
while( c ):
     if ( c.prob_sum < my_random ):
         return c.find_node(my_random)
     my_random -= c.prob_sum
     c = c.next

假设你已经构建了一个平衡树，你应该得到 O(log n) 的结果

或者，您可以通过将运行总计字段添加到当前数据集并基于该运行总计进行二进制搜索来获得相同的结果。这可能更容易实现，但只有在您的工作集可以放入内存时才适用。

Answer 4

还有一种方法在今天有效，但存在一些问题。

今天我创建了一个数组，并将每个人的概率*100 个条目放入该数组中。

那么就可以直接对数组内容进行随机化了。

第一个问题是它在各个方面（内存、处理......）都很昂贵，而且无法扩展。

当我选择第二个人和第三个人时，我遇到的第二个问题是，我要么拿出第一个，要么随机循环，直到找到另一个人。

尽管如此，对于小型数据集（就像我目前的数据集，但会随着时间的推移而增加），这个解决方案可以正常工作。