生成1,000,000个随机排列的样本

Question

我正在处理大量的整数排列.每个排列中的元素数量为K.元素大小为1个字节.我需要生成N个唯一的随机排列.
约束:K <= 144,N <= 1,000,000.

我想出了以下简单的算法:

1. 生成N个随机排列的列表.将所有排列存储在RAM中.
2. 对列表进行排序并删除所有重复项(如果有).重复数量相对较少.
3. 如果有任何重复项,请将随机排列添加到列表中,直到有N个排列并返回到步骤2.

有一个更好的方法吗？特别是,有没有办法不将所有排列存储在RAM中(在生成时将它们写在磁盘上)？

编辑:最后,需要按顺序访问生成的排列(逐个访问,不需要随机访问).RAM是更关键的因素(我宁愿不在RAM中同时存储所有排列).

Answer 1

一个可能的解决方案是使用布隆过滤器.

将您的排列存储在磁盘上(按顺序写入)并在RAM中维护Bloom过滤器.
生成排列后 - 检查布隆过滤器中是否存在排列过滤器,如果布隆过滤器显示它尚未写入磁盘 - 写入,则布隆过滤器不会出现错误否定.
然而,如果布隆过滤器说它在磁盘上 - 它可能是错误的..

如果布隆过滤器说"排列已经存在",你可以决定是否要退出这个候选者并转到下一个候选者而不检查它是否真的已经在集合中,或者你可以搜索磁盘以查看它是否真的在那里.
如果选择后者,则应考虑为排列维护智能DS,例如哈希表或B +树.

布卢姆过滤器在这里是完美的匹配 - 它们被设计成代表一个扩展阅读的集合,同时给出0个假阴性,这是最重要的事情.

Answer 2

我有点晚了，但我想我有一个尚未展示的方法。

我记得有一个算法，给定所有 K 个项目的起始顺序和一个整数索引，它将在大致与 K 成比例的时间内生成 K 个项目的第索引排列。知道它们的 K！K项的（阶乘）排列，只要你能随机生成0到K之间的整数！您可以使用该例程在内存中生成 N 个唯一的随机索引，然后将相应的排列打印到磁盘。

这是该算法的 Python 版本，其中 N 设置为 10，k 设置为 25，尽管我已成功使用 k = 144：

from math import factorial
from copy import copy
import random

def perm_at_index(items, index):
    '''
    >>> for i in range(10):
            print i, perm_at_index([1,2,3], i)

            
    0 [1, 2, 3]
    1 [1, 3, 2]
    2 [2, 1, 3]
    3 [2, 3, 1]
    4 [3, 1, 2]
    5 [3, 2, 1]
    6 [1, 2, 3]
    7 [1, 3, 2]
    8 [2, 1, 3]
    9 [2, 3, 1]
    '''
    
    itms, perm = items[:], []
    itmspop, lenitms, permappend = itms.pop, len(itms), perm.append
    thisfact = factorial(lenitms)
    thisindex = index % thisfact
    while itms:
        thisfact /= lenitms
        thischoice, thisindex = divmod(thisindex, thisfact)
        permappend(itmspop(thischoice))
        lenitms -= 1
    return perm

if __name__ == '__main__':
    N = 10      # Change to 1 million
    k = 25      # Change to 144
    K = ['K%03i' % j for j in range(k)] # ['K000', 'K001', 'K002', 'K003', ...]
    maxperm = factorial(k)              # You need arbitrary length integers for this!
    indices = set(random.randint(0, maxperm) for r in range(N))
    while len(indices) < N:
        indices |= set(random.randint(0, maxperm) for r in range(N - len(indices)))
    for index in indices:
        print (' '.join(perm_at_index(K, index)))

其输出看起来像这样：

K008 K016 K024 K014 K003 K007 K015 K018 K009 K006 K021 K012 K017 K013 K022 K020 K005 K000 K010 K001 K011 K002 K019 K004 K023
K006 K001 K023 K008 K004 K017 K015 K009 K021 K020 K013 K000 K012 K014 K016 K002 K022 K007 K005 K018 K010 K019 K011 K003 K024
K004 K017 K008 K002 K009 K020 K001 K019 K018 K013 K000 K005 K023 K014 K021 K015 K010 K012 K016 K003 K024 K022 K011 K006 K007
K023 K013 K016 K022 K014 K024 K011 K019 K001 K004 K010 K017 K018 K002 K000 K008 K006 K009 K003 K021 K005 K020 K012 K015 K007
K007 K001 K013 K003 K023 K022 K016 K017 K014 K018 K020 K015 K006 K004 K011 K009 K000 K012 K002 K024 K008 K021 K005 K010 K019
K002 K023 K004 K005 K024 K001 K006 K007 K014 K021 K015 K012 K022 K013 K020 K011 K008 K003 K017 K016 K019 K010 K009 K000 K018
K001 K004 K007 K024 K011 K022 K017 K023 K002 K003 K006 K021 K010 K014 K013 K020 K012 K016 K019 K000 K015 K008 K018 K009 K005
K009 K003 K010 K008 K020 K024 K007 K018 K023 K013 K001 K019 K006 K002 K016 K000 K004 K017 K014 K011 K022 K021 K012 K005 K015
K006 K009 K018 K010 K015 K016 K011 K008 K001 K013 K003 K004 K002 K005 K022 K020 K021 K017 K000 K019 K024 K012 K023 K014 K007
K017 K006 K010 K015 K018 K004 K000 K022 K024 K020 K014 K001 K023 K016 K005 K011 K002 K007 K009 K013 K019 K012 K021 K003 K008