如何设计随机算法从两千台服务器中抽取1台服务器进行调用？看看大师是怎么做的

// AliasTable 别名方法的数据结构
type AliasTable struct {
    Prob  []float64// 概率表
    Alias []int     // 别名表
}

// NewAliasTable 根据权重构建别名表
// 时间复杂度: O(n)，其中n是元素的数量
// 空间复杂度: O(n)
func NewAliasTable(weights []float64) *AliasTable {
    n := len(weights)
    table := &AliasTable{
        Prob:  make([]float64, n),
        Alias: make([]int, n),
    }

    // 计算权重总和
    sumWeight := 0.0
    for _, w := range weights {
        sumWeight += w
    }

    // 归一化权重，使其总和为n
    scaledWeights := make([]float64, n)
    for i, w := range weights {
        scaledWeights[i] = w * float64(n) / sumWeight
    }

    // 将选项分为两组：大于1的和小于1的
    small := make([]int, , n)
    large := make([]int, , n)

    for i, w := range scaledWeights {
        if w < 1.0 {
            small = append(small, i)
        } else {
            large = append(large, i)
        }
    }

    // 构建别名表
    forlen(small) >  && len(large) >  {
        s := small[len(small)-1]
        small = small[:len(small)-1]

        l := large[len(large)-1]
        large = large[:len(large)-1]

        table.Prob[s] = scaledWeights[s]
        table.Alias[s] = l

        // 更新大选项的权重
        scaledWeights[l] = (scaledWeights[l] + scaledWeights[s]) - 1.0
        if scaledWeights[l] < 1.0 {
            small = append(small, l)
        } else {
            large = append(large, l)
        }
    }

    // 处理剩余的选项
    forlen(large) >  {
        l := large[len(large)-1]
        large = large[:len(large)-1]
        table.Prob[l] = 1.0
    }

    forlen(small) >  {
        s := small[len(small)-1]
        small = small[:len(small)-1]
        table.Prob[s] = 1.0
    }

    return table
}

// Sample 从别名表中采样一个索引
// 时间复杂度: O(1)
func (table *AliasTable) Sample() int {
    // 随机选择一个桶
    n := len(table.Prob)
    i := rand.Intn(n)

    // 以概率表中的概率选择该桶或其别名
    if rand.Float64() < table.Prob[i] {
        return i
    } else {
        return table.Alias[i]
    }
}

// SelectN 使用别名方法选择n个不重复的元素
// 时间复杂度: O(n)，其中n是需要选择的元素数量
func SelectN(table *AliasTable, n int) []int {
    total := len(table.Prob)
    if n > total {
        n = total
    }

    selected := make(map[int]struct{})
    result := make([]int, , n)

    // 当结果集大小小于n时，继续选择
    forlen(result) < n {
        // 使用别名方法采样一个索引
        idx := table.Sample()

        // 如果该索引尚未被选择，则添加到结果集中
        if _, exists := selected[idx]; !exists {
            selected[idx] = struct{}{}
            result = append(result, idx)
        }
    }

    return result
}