3

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

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

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

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

编辑：最后，生成的排列需要顺序访问（一个接一个，不需要随机访问）。RAM 是更关键的因素（我不希望一次将所有排列存储在 RAM 中）。

4

4 回答 4

6

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

将排列存储在磁盘上（按顺序写入）并在 RAM 中维护一个布隆过滤器。
一旦你生成了一个排列——检查它是否存在于布隆过滤器中，如果布隆过滤器说它还没有写入磁盘——写它，布隆过滤器没有误报。
但是，如果布隆过滤器说它在磁盘上 - 它可能是错误的..

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

布隆过滤器在这里是完美的匹配——它们被设计为代表一个易于阅读的集合，同时给出 0 个假阴性，这是这里最重要的事情。

于 2012-10-14T17:41:41.370 回答
4

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

我记得有一种算法，给定所有 K 个项目的起始顺序和一个整数索引，它会在大致与 K 成比例的时间内生成 K 个项目的第 index 个排列。知道它们的 K！（阶乘）K个项目的排列，只要你能随机生成一个零到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
于 2012-10-24T20:01:40.413 回答
0

这是一种方法。

1) 生成前 N 个排列并将它们存储在磁盘上。

2）然后对排列运行随机化算法。

您可以使用 Divide and Conquer 进行优化，方法是仅从磁盘中选择第一个 X 元素，然后对其进行随机化，然后在下一次迭代中选择下一个 X 元素，依此类推……然后合并结果。

您可能不需要这里的磁盘。

于 2012-10-14T17:41:23.523 回答
0

鉴于10! ~= 3e6即K > ~15如果你使用适当的 Fischer-Yates 或 Knuth 洗牌一百万次洗牌 K 个项目的列表，那么你很可能每次都得到一个独特的洗牌。

如果您可以将所有一百万个唯一排列保存在一个集合数据结构中的内存中，那么您可以打乱 K 个项目的列表并将它们添加到集合中，直到您拥有一百万个。

下面是一些 Python，它还显示了 shuffle 在为不同的 K 生成唯一烫发方面的效果：

>>> from math import factorial
>>> from random import shuffle
>>> 
>>> n = 1000000
>>> for k in range(16, 9, -1):
    perms = set()
    perm = list(range(k))
    trials = 0
    while len(perms) < n:
        trials += 1
        for i in range(n - len(perms)):
            shuffle(perm)
            perms.add(tuple(perm))
    print('N=%i, K=%i, trials=%i, K!//N= %i' % (n, k, trials, factorial(k)//n))


N=1000000, K=16, trials=1, K!//N= 20922789
N=1000000, K=15, trials=1, K!//N= 1307674
N=1000000, K=14, trials=2, K!//N= 87178
N=1000000, K=13, trials=2, K!//N= 6227
N=1000000, K=12, trials=3, K!//N= 479
N=1000000, K=11, trials=5, K!//N= 39
N=1000000, K=10, trials=11, K!//N= 3
>>>
于 2014-08-27T21:45:08.853 回答