【问题标题】:Generating M distinct random numbers (one at a time) from a given range 0..N-1 in less than O(M) memory在小于 O(M) 的内存中从给定范围 0..N-1 生成 M 个不同的随机数(一次一个)
【发布时间】:2013-10-10 19:35:33
【问题描述】:

有什么方法可以做到吗?

我的意思是,我们甚至不能使用 {0,1,..,N-1} 的“in”数组(因为它至少是 O(N) 内存)。

M 可以是 = N。N 可以是 > 2^64。结果应该是均匀随机的,最好是所有可能的序列(但可能不是)。

全范围 PRNG(和朋友)也不适合,因为它每次都会给出相同的序列。

时间复杂度无关紧要。

【问题讨论】:

  • 您的意思是O(m)?因为如果你不限制m 这很容易。
  • 只要m 与周期的比例足够小,PRNG 应该是合适的。
  • @usr:是的。我已经更正了标题。
  • N 可以很大,所以周期会是~N(或者不会?)。
  • 你的意思是真正随机的吗?还是伪随机?

标签: performance algorithm random


【解决方案1】:

如果您不关心随机选择的顺序,那么它可以在常量内存中完成。选择按顺序出现。

答案取决于估计集合{0, ..., N-1} 的M 个不同值的随机选择中的最小值是i 的概率,对于每个可能的i。将此值称为p(i, M, N)。有了比我耐心输入不支持 Latex 的界面更多的数学知识,您可以对 p 函数得出一些相当不错的估计;在这里,我将只展示一种简单、不省时的方法。

让我们只关注p(0, M, N),这是从N 对象中随机选择的M 将包含第一个对象的概率。然后我们可以一次一个地遍历对象(即数字0...N-1);通过翻转加权硬币来决定每个人是否包括在内。我们只需要计算每次翻转的硬币重量。

根据定义,有<sub>M</sub>C<sub>N</sub> 可能的M-选择一组N 对象。其中<sub>M</sub>C<sub>N-1</sub> 不包括第一个元素。 (这是N-1 对象的M-selections 的计数,这是缺少一个元素的集合的所有M-selections)。同样,<sub>M-1</sub>C<sub>N-1</sub> 选择确实包含第一个元素(即,N-1-set 的所有M-1-selections,第一个元素添加到每个选择中)。

这两个值加起来是<sub>M</sub>C<sub>N</sub>;著名的计算C的递归算法。

所以p(0, M, N) 就是<sub>M-1</sub>C<sub>N-1</sub>/<sub>M</sub>C<sub>N</sub>。由于<sub>M</sub>C<sub>N</sub> = N!/(M!*(N-M)!),我们可以将该分数简化为M/N。正如预期的那样,如果M == N,则结果为 1(N 个对象中的 M 个必须包含每个对象)。

所以现在我们知道第一个对象出现在选择中的概率是多少。然后我们可以减少集合的大小,或者减少剩余的选择大小,这取决于硬币翻转是否确定我们包含或不包含第一个对象。因此,这是基于加权随机布尔函数存在的伪代码的最终算法:

w(x, y) => true with probability X / Y; otherwise false.

我将把w 的实现留给读者,因为它很简单。

所以:

Generate a random M-selection from the set 0...N-1
Parameters: M, N

Set i = 0
while M > 0:
  if w(M, N):
     output i
     M = M - 1
  N = N - 1
  i = i + 1

这可能不是很明显,但请注意:

  • output i 语句必须精确执行M 次,因为它与M 的减量相结合,并且while 循环执行直到M 是0
  • M 越接近N,M 被递减的概率就越高。如果我们达到M == N,那么两者都将同步递减,直到它们都达到0。
  • i 正好在N 减少时增加,因此它必须始终在0...N-1 范围内。事实上,它是多余的。我们可以输出N-1 而不是输出i,这会改变算法以降序而不是升序生成集合。我没有这样做,因为我认为上面的内容更容易理解。

该算法的时间复杂度是O(N+M),它必须是O(N)。如果N 很大,那不是很好,但是问题陈述中说时间复杂度无关紧要,所以我将其留在那里。

【讨论】:

  • 统计上不合适。尤其是 M = N。
  • @user2651727:如果 M=N,则只有一种可能的选择。如果您需要随机排列,那么它当然不是一个sokution。但是如果你正在寻找一个随机样本,那么这个算法是无偏的,所以它在统计上是正确的..
  • @user2651727:我认为随机排列是不可能的。据我所知,O(1) 空间解只存在于随机样本。当然,如果你准备使用 O(M) 内存,随机排列问题就很简单了。
【解决方案2】:

不将其状态空间映射到用于输出的较低位数的 PRNG 应该可以正常工作。示例包括线性同余生成器和 Tausworthe 生成器。如果您使用相同的种子启动它们,它们将给出相同的序列,但这很容易更改。

【讨论】:

  • 对于 m = N > 10^12,他们会给出(一致地每个)/(一致地几乎每个)数字排列吗? “几乎每个”我的意思是〜N!
  • 尽管大多数 PRNG 不会在生成的数字序列中强制区分。
【解决方案3】:

蛮力: 如果时间复杂度无关紧要,它将是 0

init() {
        for (int idx = 0; idx < N; idx++) {
            a[idx] = -1;
        }
        for (int idx = 0; idx < M; idx++) {
            getNext();
        }
    }

    int getNext() {
        for (int idx = 1; idx < M; idx++) {
            a[idx -1] = a[idx];
        }
        while (true) {
            r = nextRandom(N);
            idx = 0;
            while (idx < M && a[idx] != r) idx++;
            if (idx == M) {
                a[idx - 1] = r;
                return r;
            }
        }
    }

O(M) 解决方案: 为简单起见,它是递归解决方案。它假设运行 nextRandom() 返回 [0..1) 中的随机数:

rnd(0, 0, N, M); // to get next M distinct random numbers

int rnd(int idx, int n1, int n2, int m) {
    if (n1 >= n2 || m <= 0) return idx;
    int r = nextRandom(n2 - n1) + n1;
    int m1 = (int) ((m-1.0)*(r-n1)/(n2-n1) + nextRandom()); // gives [0..m-1]
    int m2 = m - m1 - 1;
    idx = rnd(idx, n1, r-1, m1);
    print r;
    return rnd(idx+1, r+1, n2, m2);
}

这个想法是在第一步中选择一个介于 [0..N) 之间的随机 r,它将两个子范围的范围划分为每个子范围中的 N1 和 N2 个元素 (N1+N2==N-1)。我们需要对具有 N1 个元素和 [r+1..N) (N2 个元素) 的 [0..r) 重复相同的步骤,选择 M1 和 M2 (M1+M2==M-1) 以便 M1/M2 == N1/N2。 M1 和 M2 必须是整数,但是比例可以给出真实的结果,我们需要用概率对值进行四舍五入(1.2 将给出 1 与 p=0.8 和 2 与 p=0.2 等)。

【讨论】:

  • a[] 的大小为 M,因此不小于 O(M)
  • 我添加了第二个解决方案,如果您打印 r,则根本不需要 a[],它给出了 O(M) 的结果。递归是为了代码的可读性。
  • 在内存中仍然不少于O(M)。
  • @user2651727,我删除了一个 [] 引用,所以它不应该让你感到困惑。所以现在它不使用“堆”内存,只是堆叠一个。
  • 它不使用“堆”,但在 RAM 中仍然是 O(M)。
猜你喜欢
  • 2011-10-20
  • 2012-11-25
  • 2016-03-24
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2020-05-24
  • 2018-12-17
  • 2023-03-28
相关资源
最近更新 更多