我说我为什么抽不到SSR，原来是这段代码在作祟...

news2024/10/7 6:40:54

本文是龚国玮所写，熊哥有所新增修改删减，原文见文末。

我说我为什么抽不到SSR，原来是加权随机算法在作祟

阅读本文需要做好心理准备，建议带着深究到底的决心和毅力进行学习！

灵魂拷问

为什么有 50% 的几率获得金币？

为什么有 40% 的几率获得钻石？

为什么只有 9% 的几率获得装备？

为什么才有 1% 的几率获得极品装备？

是人性的扭曲，还是道德的沦丧，请和我一起走进~~今日说法~~ ！

介绍

元素被选中的机会并不相等，而是由相对“权重”（或概率）被选中的，是偏心的，这就是加权随机。

举个栗子，假如现在有一个权重数组 w = {1, 2, 4, 8}，它们代表如下规则。

$ \frac{1}{(1+2+4+8)} = \frac{1}{15} \approx 6.6$ % 几率选中第1个
$ \frac{2}{(1+2+4+8)} = \frac{2}{15} \approx 13.3$ % 几率选中第2个
$ \frac{3}{(1+2+4+8)} = \frac{4}{15} \approx 26.6$ % 几率选中第3个
$ \frac{1}{(1+2+4+8)} = \frac{8}{15} \approx 53.3$ % 几率选中第4个

一个小小的概率问题，居然引出了大大的思考。

方案一、笨笨的办法

所以要设计一个加权算法的程序，你会怎么写呢？

第一个方法把权重所在的位置展开，然后从该列表中随机选择。

假设现在有权重列表 {1, 2, 4, 8}。

那我们得到的候选列表将是

{0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3}

然后通过 rand.Intn() ，获取一个随机数，就完成了，代码如下。

func weightedRandomS1(weights []int) int {
    if len(weights) == 0 {
        return 0
    }

    var indexList []int

    for i, weight := range weights {
        cnt := 0
        for weight > cnt {
            indexList = append(indexList, i)
            cnt++
        }
    }

    rand.Seed(time.Now().UnixNano())
    return indexList[rand.Intn(len(indexList))]
}

当权重特别大的时候，这种方案费时费力，又占空间。先别急往下看，你能想到更好的办法吗？

方案二、略显聪明

由于总权重为 15（1+2+4+8），我们可以生成一个 [0,15) 的随机整数，然后根据这个数字返回索引。代码如下。

func weightedRandomS2() int {
    rand.Seed(time.Now().UnixNano())
    r := rand.Intn(15)
    if r <= 1 {
        return 0
    } else if 1 < r && r <= 3 {
        return 1
    } else if 3 < r && r <= 7 {
        return 2
    } else {
        return 3
    }
}

妙不妙！！但你以为这就是效率最高的办法吗？

写那么多if else不痛苦吗我的宝贝。

方案三、神之一手

何必将随机数和所有的范围进行比较呢？直接遍历随机数减去权重，如果结果小于等于零，不就是我们要的结果下标吗？

func weightedRandomS3(weights []int) int {
    rand.Seed(time.Now().UnixNano())
    r := rand.Intn(len(weights))
    for i, v := range weights {
        r = r - v
        if r <= 0 {
            return i
        }
    }
    return len(weights) - 1
}

这种方法叫放弃临时名单。想不明白就评论问！

方案四、小小优化

对于方案三，怎么有效的减少遍历次数呢？

当r小于等于 0 的速度越快，算法越高效。那我们就让 r 到达 0 更快。先排序这样就能先减去权重大的，减少遍历次数。

func weightedRandomS4(weights []int) int {
    sort.Sort(sort.Reverse(sort.IntSlice(weights)))
    ....

有人就不服了，排序不是更浪费时间？

是的！虽然看起来减少遍历次数！但排序本身就要遍历就是更浪费时间。。。

但是一次排序，反复使用，还是能提高效率的！

方案五、不可思议！

有没有办法不用排序，而让原数组有序呢？

有人就说了，你这不是扯么？

如果每次遍历都加上上一个权重，那整个数字就是递增的！

再用二分就能加快速度了，时间复杂度从 $ O(n) $ 直接变为 $ O(log(n)) $。

func weightedRandomS5(weights []int) int {
    rand.Seed(time.Now().UnixNano())
    sum := 0
    var sumWeight []int
    for _, v := range weights {
        sum += v
        sumWeight = append(sumWeight, sum)
    }
    r := rand.Intn(sum)
    idx := sort.SearchInts(sumWeight, r)
    return weights[idx]
}

读到这里，对源码没有信心学习的朋友，可以直接撤了。 真正的高阶优化要来了。

方案六、不死不休

到目前的位置，我们的解决方案已经足够好了，但是仍然有改进的余地。

方案五中，我们使用了 Go 标准库的二分查找算法 sort.SearchInts() ，是封装了通用的 sort.Search() 函数，如下。

sort.SearchInts

sort.Search() 的函数参数需要一个闭包函数，并且这个闭包函数是在 for 循环中使用的，如下。

sort.Search

闭包函数反复调用，在编译期会产生额外的开销。因为会产生更多的跳转，跳转会引起压栈（函数参数都是会压栈的）。

我们手动提出取函数，就可以减少编译器的内联（文末会解释）。

func weightedRandomS5(weights []int) int {
...
idx := sort.SearchInts(sumWeight, r)
    return weights[idx]
}
func searchInts(a []int, x int) int {
    i, j := 0, len(a)
    for i < j {
        h := int(uint(i+j) >> 1)
        if a[h] < x {
            i = h + 1
        } else {
            j = h
        }
    }
    return i
}

通过基准测试可以看到吞吐量提升了 33% 以上。对于大型数据集，优势越明显。

优化前

优化后

方案七，“偷鸡”取巧--轮盘赌

目前为止我们所有的方案都有一个共同点 —— 生成一个介于 0 和“权重之和”之间的随机数，并找出它属于哪个“切片”。

还有一种不同的方法。

func weightedRandomS7(weights []float64) int {
    var sum float64
    var winner int
    rand.Seed(time.Now().UnixNano())
    for i, v := range weights {
        sum += v
        f := rand.Float64()
        if f*sum < v {
            winner = i
        }
    }
    return winner
}