等概率随机数问题

首先来看编程珠玑上面的一个题目，两个整数m和n， 其中m < n。输出时0~n-1范围内的m个随机整数的有序列表，不允许重复。

方法一：

核心思想，如果要从r个剩余的整数中选出s个，我们以概率s/r选择下一个数。

代码如下：

#include<stdlib.h>
#include<stdio.h>
#include<assert.h>
#include<time.h>

void randMfromN(int, int);
int bigrand();
int main()
{
	int n, m;
	scanf("%d %d", &n, &m);
	assert(n >= m);
	randMfromN(n, m);
}

void randMfromN(int n, int m)
{
	int i = 0;
	srand((unsigned)time(NULL));
	for(i = 0; i < n; ++i)
		if((bigrand() % (n-i)) < m)
		{
			printf("%d ", i);
			m--;
		}
}

int bigrand()
{
	return RAND_MAX * rand() + rand();
}

刚开始rand函数用错了，每次运行的时候输出的序列都相同。

原因如下：

各种编程语言返回的随机数（确切地说是伪随机数）实际上都是根据递推公式计算的一组数值，当序列足够长，这组数值近似满足均匀分布。如果计算伪随机序列的初始数值（称为种子）相同，则计算出来的伪随机序列就是完全相同的。这个特性被有的软件利用于加密和解密。加密时，可以用某个种子数生成一个伪随机序列并对数据进行处理；解密时，再利用种子数生成一个伪随机序列并对加密数据进行还原。这样，对于不知道种子数的人要想解密就需要多费些事了。当然，这种完全相同的序列对于你来说是非常糟糕的。要解决这个问题，需要在每次产生随机序列前，先指定不同的种子，这样计算出来的随机序列就不会完全相同了。你可以在调用rand()函数之前调用srand((unsigned)time( NULL ) )，这样以time函数值（即当前时间）作为种子数，因为两次调用rand函数的时间通常是不同的，这样就可以保证随机性了。你也可以使用srand函数来人为指定种子数。

方法二：

在一个初始为空的集合里面插入随机整数，直到个数足够。

代码如下：

void gensets(int m, int n)
{
	set<int> s;
	srand((unsigned)time(NULL));
	while(s.size() < m)
		s.insert(bigrand() % n);
	set<int>::iterator iter;
	for(iter = s.begin(); iter != s.end(); ++iter)
		cout<<*iter<<" ";
}

方法三：

把包含整数0~n-1的数组顺序打乱，然后把前m个元素排序输出

代码如下：

#include<stdlib.h>
#include<stdio.h>
#include<assert.h>
#include<time.h>
#include<malloc.h>

void genshuf(int m, int n);
int main()
{
	int n, m;
	scanf("%d %d", &n, &m);
	assert(n >= m);
	genshuf(m, n);
}

int bigrand()
{
	return RAND_MAX * rand() + rand();
}
int randint(int l, int u)
{
	return l + bigrand()%(u-l+1);
}
int cmp(const void *a, const void *b)
{
	int *p, *q;
	p = (int *)a;
	q = (int *)b;
	if(*p > *q)
		return 1;
	else if(*p == *q)
		return 0;
	else
		return -1;
}
void genshuf(int m, int n)
{
	int i, j;
	int temp;
	int *p = (int *)malloc(sizeof(int) * n);
	if(p == NULL)
		return;
	srand((unsigned)time( NULL)) ;
	for(i = 0; i < n; ++i)
		p[i]  = i;
	for(i = 0; i < m; ++i)
	{
		j = randint(i, n-1);
	    temp = p[i];
     	p[i] = p[j];
	    p[j] = temp;
	}
	qsort(p, m, sizeof(int), cmp);
	for(i = 0; i < m; ++i)
		printf("%d ", p[i]);
	free(p);
	p = NULL;
}

题目二：

给定一个函数randn()，能产生1~n之间的随机数，设计等概率产生1~m的随机函数randm()。

n < m && m < n*n;

代码如下：

#include<stdio.h>
#include<time.h>
#include<assert.h>
#include<malloc.h>
#include<stdlib.h>

int randm(int n, int m);
int main()
{
	int n, m;
	int i = 0;
	scanf("%d %d", &n, &m);
	assert(n < m && m < n*n);
	srand((unsigned)time(NULL));
	for(i = 0; i < 10; ++i)
		printf("%d ", randm(n, m));
}

int randn(int n)
{
	return 1+rand()%n;
}
int randm(int n, int m)
{
	int x = 0;
	do
	{
		x = n * (randn(n)-1) + randn(n);//生成0~n*n之间的等概率随机数，原因见下面的解释
	}while(x > (n*n - n*n%m));
	return 1+x%m;
}

以n= 7，证明n * (randn(n)-1) + randn(n)的正确性。

首先rand7()-1得到一个离散整数集合{0，1，2，3，4，5，6}，其中每个整数的出现概率都是1/7。那么(rand7()-1)*7得到一个离散整数集合A={0，7，14，21，28，35，42}，其中每个整数的出现概率也都是1/7。而rand7()得到的集合B={1，2，3，4，5，6，7}中每个整数出现的概率也是1/7。显然集合A和B中任何两个元素组合可以与1-49之间的一个整数一一对应，也就是说1-49之间的任何一个数，可以唯一确定A和B中两个元素的一种组合方式，反过来也成立。由于A和B中元素可以看成是独立事件，根据独立事件的概率公式P(AB)=P(A)P(B)，得到每个组合的概率是1/7*1/7=1/49。因此(rand7()-1)*7+rand7()生成的整数均匀分布在1-49之间，每个数的概率都是1/49。

题目三：

已知随机函数rand（），以p的概率产生0，以1-p的概率产生1，现在要求设计一个新的函数newrand（），使其以1/n的等概率产生1-n之间的每一个数。

解题思路：

一：首先构造一个等概率产生0和1的函数rand0and1()；

二：计算出n的最高位1的位置为k；

三：调用k次rand0and1()，每次右移一位。得到结果。

代码如下：

int rand0and1()
{
	int i = rand();
	int j = rand();
	if(i == 0 && j == 1)
		return 0;
	if(i == 1 && j == 0)
		return 1;
	else
		return rand0and1();
}

int BitofN(int n)
{
	int count = 0;
	while(n > 0)
	{
		n >>= 1;
		count++;
	}
	return count;
}

int newrand(int n)
{
	int result = 0;
	int k = BitofN(int n);
	int i = 0;
	for(i = 0; i < k; ++i)
		result |= (rand0and1()<<i);
	if(result > n)
		return newrand(n);
	return result;
}