程序博客网 > 淘宝好看的情侣装店铺

C#&PHP&Java实现Alias Method概率抽奖算法

来源：互联网 发布：淘宝好看的情侣装店铺 编辑：程序博客网 时间：2024/06/05 11:29

最近在做抽奖服务端接口，会涉及到抽奖概率的问题，网上查资料找到一个比较好的抽奖概率的算法，Alias Method概率抽奖算法。今天就来分享一下这个算法的C#、PHP以及Java的实现。

举个例子，游戏中玩家推倒了一个boss，会按如下概率掉落物品：10%掉武器 20%掉饰品 30%掉戒指 40%掉披风。现在要给出下一个掉落的物品类型，或者说一个掉落的随机序列，要求符合上述概率。


一般会想到的两种解法

第一种算法，构造一个容量为100(或其他)的数组，将其中10个元素填充为类型1（武器），20个元素填充为类型2（饰品）...构造完毕之后，在1到100之间取随机数rand，取到的array[rand]对应的值，即为随机到的类型。这种方法优点是实现简单，构造完成之后生成随机类型的时间复杂度就是O(1)，缺点是精度不够高，占用空间大，尤其是在类型很多的时候。


第二种就是一般的离散算法，通过概率分布构造几个点，[10, 30, 60, 100]，没错，后面的值就是前面依次累加的概率之和（是不是像斐波那契数列）。在生成1~100的随机数，看它落在哪个区间，比如50在[30,60]之间，就是类型3。在查找时，可以采用线性查找，或效率更高的二分查找，时间复杂度O(logN)。

这里推荐一个大牛的两篇文章，从数学入手，探讨各种算法实现。《用JavaScript玩转游戏编程(一)掉宝类型概率》 和《实验比较各离散采样算法》 。想深入了解的朋友推荐看看。

参考他的文章中得到两个概念，PDF（密度分布函数）和 CDF（累积分布函数）两种概率分布，分别对应如上两种算法：

T1234PDF0.10.20.30.4CDF0.10.30.61.0

好了，现在就来说一下Alias Method（别名方法）

在这里我们不深究他的数学原理（http://www.keithschwarz.com/darts-dice-coins/ 这篇文章里详述了其原理），来看看如何使用和实现。譬如说如上的PDF[0.1,0.2,0.3,0.4]，将每种概率当做一列，别名算法最终的结果是要构造拼装出一个每一列合都为1的矩形，若每一列最后都要为1，那么要将所有元素都乘以4（概率类型的数量）


此时会有概率大于1的和小于1的，接下来就是构造出某种算法用大于1的补足小于1的，使每种概率最后都为1，注意，这里要遵循一个限制：每列至多是两种概率的组合。


最终，我们得到了两个数组，一个是在下面原始的prob数组[0.4,0.8,0.6,1]，另外就是在上面补充的Alias数组，其值代表填充的那一列的序号索引，（如果这一列上不需填充，那么就是NULL），[3,4,4,NULL]。当然，最终的结果可能不止一种，你也可能得到其他结果。

等等，这个问题还没有解决，得到这两个数组之后，随机取其中的一列，比如是第三列，让prob[3]的值与一个随机小数f比较，如果f小于prob[3]，那么结果就是3，否则就是Alias[3]，即4。

我们可以来简单验证得到的概率是不是正确的，比如随机到第三列的概率是1/4，得到第三列下半部分的概率为1/4*3/5，记得在第一列还有它的一部分，那里的概率为1/4*(1-2/5)，两者相加最终的结果还是3/10，符合原来的pdf概率。这种算法初始化较复杂，但生成随机结果的时间复杂度为O(1)，是一种性能非常好的算法。

T1234PDF0.10.20.30.4Alias344NULL

一、Alias Method概率抽奖算法的C#实现


  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace Lanhusoft.Core
  9. {
  10.     public class AliasMethod
  11.     {
  12.         /* The probability and alias tables. */
  13.         private int[] _alias;
  14.         private double[] _probability;
  15.         
  16.         public AliasMethod(List<Double> probabilities)
  17.         {
  18.  
  19.             /* Allocate space for the probability and alias tables. */
  20.             _probability = new double[probabilities.Count];
  21.             _alias = new int[probabilities.Count];
  22.  
  23.             /* Compute the average probability and cache it for later use. */
  24.             double average = 1.0 / probabilities.Count;
  25.  
  26.             /* Create two stacks to act as worklists as we populate the tables. */
  27.             var small = new Stack<int>();
  28.             var large = new Stack<int>();
  29.  
  30.             /* Populate the stacks with the input probabilities. */
  31.             for (int i = 0; i < probabilities.Count; ++i)
  32.             {
  33.                 /* If the probability is below the average probability, then we add
  34.                  * it to the small list; otherwise we add it to the large list.
  35.                  */
  36.                 if (probabilities[i] >= average)
  37.                     large.Push(i);
  38.                 else
  39.                     small.Push(i);
  40.             }
  41.  
  42.             /* As a note: in the mathematical specification of the algorithm, we
  43.              * will always exhaust the small list before the big list.  However,
  44.              * due to floating point inaccuracies, this is not necessarily true.
  45.              * Consequently, this inner loop (which tries to pair small and large
  46.              * elements) will have to check that both lists aren't empty.
  47.              */
  48.             while (small.Count > 0 && large.Count > 0)
  49.             {
  50.                 /* Get the index of the small and the large probabilities. */
  51.                 int less = small.Pop();
  52.                 int more = large.Pop();
  53.  
  54.                 /* These probabilities have not yet been scaled up to be such that
  55.                  * 1/n is given weight 1.0.  We do this here instead.
  56.                  */
  57.                 _probability[less] = probabilities[less] * probabilities.Count;
  58.                 _alias[less] = more;
  59.  
  60.                 /* Decrease the probability of the larger one by the appropriate
  61.                  * amount.
  62.                  */
  63.                 probabilities[more] = (probabilities[more] + probabilities[less] - average);
  64.  
  65.                 /* If the new probability is less than the average, add it into the
  66.                  * small list; otherwise add it to the large list.
  67.                  */
  68.                 if (probabilities[more] >= average)
  69.                     large.Push(more);
  70.                 else
  71.                     small.Push(more);
  72.             }
  73.  
  74.             /* At this point, everything is in one list, which means that the
  75.              * remaining probabilities should all be 1/n.  Based on this, set them
  76.              * appropriately.  Due to numerical issues, we can't be sure which
  77.              * stack will hold the entries, so we empty both.
  78.              */
  79.             while (small.Count > 0)
  80.                 _probability[small.Pop()] = 1.0;
  81.             while (large.Count > 0)
  82.                 _probability[large.Pop()] = 1.0;
  83.         }
  84.  
  85.         /**
  86.          * Samples a value from the underlying distribution.
  87.          *
  88.          * @return A random value sampled from the underlying distribution.
  89.          */
  90.         public int next()
  91.         {
  92.  
  93.             long tick = DateTime.Now.Ticks;
  94.             var seed = ((int)(tick & 0xffffffffL) | (int)(tick >> 32));
  95.             unchecked
  96.             {
  97.                 seed = (seed + Guid.NewGuid().GetHashCode() + new Random().Next(0, 100));
  98.             }
  99.             var random = new Random(seed);
  100.             int column = random.Next(_probability.Length);
  101.  
  102.             /* Generate a biased coin toss to determine which option to pick. */
  103.             bool coinToss = random.NextDouble() < _probability[column];
  104.  
  105.             return coinToss ? column : _alias[column];
  106.         }
  107.     }
  108. }


二、Alias Method概率抽奖算法的PHP实现


  1. <?php  
  2. class AliasMethod  
  3. {  
  4.     private $length;  
  5.     private $prob_arr;  
  6.     private $alias;  
  7.   
  8.     public function __construct ($pdf)  
  9.     {  
  10.         $this->length = 0;  
  11.         $this->prob_arr = $this->alias = array();  
  12.         $this->_init($pdf);  
  13.     }  
  14.     private function _init($pdf)  
  15.     {  
  16.         $this->length = count($pdf);  
  17.         if($this->length == 0)  
  18.             die("pdf is empty");  
  19.         if(array_sum($pdf) != 1.0)  
  20.             die("pdf sum not equal 1, sum:".array_sum($pdf));  
  21.   
  22.         $small = $large = array();  
  23. $average=1.0/$this->length;
  24.         for ($i=0; $i < $this->length; $i++)   
  25.         {   
  26.             $pdf[$i] *= $this->length;  
  27.             if($pdf[$i] < $average)  
  28.                 $small[] = $i;  
  29.             else  
  30.                 $large[] = $i;  
  31.         }  
  32.   
  33.         while (count($small) != 0 && count($large) != 0)   
  34.         {  
  35.             $s_index = array_shift($small);  
  36.             $l_index = array_shift($large);  
  37.             $this->prob_arr[$s_index] = $pdf[$s_index]*$this->length;  
  38.             $this->alias[$s_index] = $l_index;  
  39.   
  40.             $pdf[$l_index] += $pdf[$s_index]-$average;  
  41.             if($pdf[$l_index] < $average)  
  42.                 $small[] = $l_index;  
  43.             else  
  44.                 $large[] = $l_index;  
  45.         }  
  46.   
  47.         while(!empty($small))  
  48.             $this->prob_arr[array_shift($small)] = 1.0;  
  49.         while (!empty($large))  
  50.             $this->prob_arr[array_shift($large)] = 1.0;  
  51.     }  
  52.     public function next_rand()  
  53.     {  
  54.         $column = mt_rand(0, $this->length - 1);  
  55.         return mt_rand() / mt_getrandmax() < $this->prob_arr[$column] ? $column : $this->alias[$column];  
  56.     }  
  57. }  
  58. ?>


三、Alias Method概率抽奖算法的Java实现


  1. package com.lanhusoft.rsaapp;
  2.  
  3. import android.util.Log;
  4.  
  5. import java.util.*;
  6. import java.util.concurrent.atomic.AtomicInteger;
  7.  
  8.  
  9. public final class AliasMethod {
  10.     /* The random number generator used to sample from the distribution. */
  11.     private final Random random;
  12.  
  13.     /* The probability and alias tables. */
  14.     private final int[] alias;
  15.     private final double[] probability;
  16.  
  17.     /**
  18.      * Constructs a new AliasMethod to sample from a discrete distribution and
  19.      * hand back outcomes based on the probability distribution.
  20.      * <p/>
  21.      * Given as input a list of probabilities corresponding to outcomes 0, 1,
  22.      * ..., n - 1, this constructor creates the probability and alias tables
  23.      * needed to efficiently sample from this distribution.
  24.      *
  25.      * @param probabilities The list of probabilities.
  26.      */
  27.     public AliasMethod(List<Double> probabilities) {
  28.         this(probabilities, new Random());
  29.     }
  30.  
  31.     /**
  32.      * Constructs a new AliasMethod to sample from a discrete distribution and
  33.      * hand back outcomes based on the probability distribution.
  34.      * <p/>
  35.      * Given as input a list of probabilities corresponding to outcomes 0, 1,
  36.      * ..., n - 1, along with the random number generator that should be used
  37.      * as the underlying generator, this constructor creates the probability
  38.      * and alias tables needed to efficiently sample from this distribution.
  39.      *
  40.      * @param probabilities The list of probabilities.
  41.      * @param random        The random number generator
  42.      */
  43.     public AliasMethod(List<Double> probabilities, Random random) {
  44.         /* Begin by doing basic structural checks on the inputs. */
  45.         if (probabilities == null || random == null)
  46.             throw new NullPointerException();
  47.         if (probabilities.size() == 0)
  48.             throw new IllegalArgumentException("Probability vector must be nonempty.");
  49.  
  50.         /* Allocate space for the probability and alias tables. */
  51.         probability = new double[probabilities.size()];
  52.         alias = new int[probabilities.size()];
  53.  
  54.         /* Store the underlying generator. */
  55.         this.random = random;
  56.  
  57.         /* Compute the average probability and cache it for later use. */
  58.         final double average = 1.0 / probabilities.size();
  59.  
  60.         /* Make a copy of the probabilities list, since we will be making
  61.          * changes to it.
  62.          */
  63.         probabilities = new ArrayList<Double>(probabilities);
  64.  
  65.         /* Create two stacks to act as worklists as we populate the tables. */
  66.         Deque<Integer> small = new ArrayDeque<Integer>();
  67.         Deque<Integer> large = new ArrayDeque<Integer>();
  68.  
  69.         /* Populate the stacks with the input probabilities. */
  70.         for (int i = 0; i < probabilities.size(); ++i) {
  71.             /* If the probability is below the average probability, then we add
  72.              * it to the small list; otherwise we add it to the large list.
  73.              */
  74.             if (probabilities.get(i) >= average)
  75.                 large.add(i);
  76.             else
  77.                 small.add(i);
  78.         }
  79.  
  80.         /* As a note: in the mathematical specification of the algorithm, we
  81.          * will always exhaust the small list before the big list.  However,
  82.          * due to floating point inaccuracies, this is not necessarily true.
  83.          * Consequently, this inner loop (which tries to pair small and large
  84.          * elements) will have to check that both lists aren't empty.
  85.          */
  86.         while (!small.isEmpty() && !large.isEmpty()) {
  87.             /* Get the index of the small and the large probabilities. */
  88.             int less = small.removeLast();
  89.             int more = large.removeLast();
  90.  
  91.             /* These probabilities have not yet been scaled up to be such that
  92.              * 1/n is given weight 1.0.  We do this here instead.
  93.              */
  94.             probability[less] = probabilities.get(less) * probabilities.size();
  95.             alias[less] = more;
  96.  
  97.             /* Decrease the probability of the larger one by the appropriate
  98.              * amount.
  99.              */
  100.             probabilities.set(more,
  101.                     (probabilities.get(more) + probabilities.get(less)) - average);
  102.  
  103.             /* If the new probability is less than the average, add it into the
  104.              * small list; otherwise add it to the large list.
  105.              */
  106.             if (probabilities.get(more) >= 1.0 / probabilities.size())
  107.                 large.add(more);
  108.             else
  109.                 small.add(more);
  110.         }
  111.  
  112.         /* At this point, everything is in one list, which means that the
  113.          * remaining probabilities should all be 1/n.  Based on this, set them
  114.          * appropriately.  Due to numerical issues, we can't be sure which
  115.          * stack will hold the entries, so we empty both.
  116.          */
  117.         while (!small.isEmpty())
  118.             probability[small.removeLast()] = 1.0;
  119.         while (!large.isEmpty())
  120.             probability[large.removeLast()] = 1.0;
  121.     }
  122.  
  123.     /**
  124.      * Samples a value from the underlying distribution.
  125.      *
  126.      * @return A random value sampled from the underlying distribution.
  127.      */
  128.     public int next() {
  129.         /* Generate a fair die roll to determine which column to inspect. */
  130.         int column = random.nextInt(probability.length);
  131.  
  132.         /* Generate a biased coin toss to determine which option to pick. */
  133.         boolean coinToss = random.nextDouble() < probability[column];
  134.  
  135.         /* Based on the outcome, return either the column or its alias. */
  136.        /* Log.i("1234","column="+column);
  137.         Log.i("1234","coinToss="+coinToss);
  138.         Log.i("1234","alias[column]="+coinToss);*/
  139.         return coinToss ? column : alias[column];
  140.     }
  141.  
  142.     public static void main(String[] args) {
  143.         TreeMap<String, Double> map = new TreeMap<String, Double>();
  144.         map.put("1金币", 0.2);
  145.         map.put("2金币", 0.15);
  146.         map.put("3金币", 0.1);
  147.         map.put("4金币", 0.05);
  148.         map.put("未中奖", 0.5);
  149.  
  150.         List<Double> list = new ArrayList<Double>(map.values());
  151.         List<String> gifts = new ArrayList<String>(map.keySet());
  152.  
  153.         AliasMethod method = new AliasMethod(list);
  154.  
  155.         Map<String, AtomicInteger> resultMap = new HashMap<String, AtomicInteger>();
  156.  
  157.         for (int i = 0; i < 100000; i++) {
  158.             int index = method.next();
  159.             String key = gifts.get(index);
  160.             if (!resultMap.containsKey(key)) {
  161.                 resultMap.put(key, new AtomicInteger());
  162.             }
  163.             resultMap.get(key).incrementAndGet();
  164.         }
  165.         for (String key : resultMap.keySet()) {
  166.             System.out.println(key + "==" + resultMap.get(key));
  167.         }
  168.  
  169.     }
  170. }


参考：

http://blog.csdn.net/sky_zhe/article/details/10051967

0 0
淘宝好看的情侣装店铺 淘宝好看的情侣装店铺
原创粉丝点击
热门IT博客
淘宝培训心得淘宝培训心得
外文数据库下载外文数据库下载
linux kmod oracleasm
免费linux云主机
php true false大小写
用php做app接口
胖子衣服淘宝店
跨境电商出口数据
ubuntu qq2015下载
淘宝网13岁女大童棉衣
淘宝便宜衣服的爆光
淘宝利润计算
智能推荐系统书籍 知乎
张国荣人品知乎
docker yaml mysql
粉笔回放数据加载失败
深圳市信息软件协会
破获特大网络售假药案
sdl游戏编程
电脑手机同步软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 论文摘要 微商摘要 内容摘要 摘要英文 摘要格式 病历摘要 论文摘要怎么写 摘要是什么意思 论文摘要范文 论文摘要范文参考 优秀论文摘要范文 病历摘要模板 会计摘要怎么写 房屋信息摘要 摘要酒53度多少钱 工商管理论文摘要 复兴之路内容摘要 爱的教育读书摘要 小学安全记录内容摘要 家长漂流日记摘选 摛 摛怎么读 摛敌拳十六动分解动作 铺采摛文体物写志 摧毁 摧毁迪诗 摧毁城市 摧毁英文 摧毁的意思 美国摧毁中国仅1小时 龙卷风摧毁停车场 大雄和静香摧毁童年图片 他正在摧毁时家 地下城堡2摧毁战争工厂 摧毁战争工厂 地下城堡摧毁战争工厂 模拟摧毁城市 摧毁的反义词 摧毁迪诗1-4短视 模拟摧毁城市下载 摧毁的近义词

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里