程序员面试金典： 9.10 扩展性与存储限制 10.3产生1个不在含40亿个整数文件中的整数---优化解法

#include <iostream>
#include <stdio.h>
#include <bitset>
#include <vector>

using namespace std;

/*
问题：给定一个输入文件，包含40亿个非负整数，请设计一种算法，产生一个不在该文件中的整数。假定你有10MB内存来完成该项任务。
分析：10MB的内存只够存放10MB / 4B = 2.5 * 2^(20)， 约为 250万个整数，大约2^(21)个元素
      40亿个整数 40亿 / 250万 = 1600 共需操作1600次
	  需要明确的是即使每次把10MB内存用完，得到的也只是那些在这250万个整数中出现的整数，以及出现的次数。
	  采用分批处理的目的是每次分批处理得到若干个候选值，最后一次将个分批处理的候选值全放在一起，最终得出结果。
	  但这里用分批，似乎得不到需要的候选值

这里用一个简单例子作为说明：假设100万个数中寻找丢失的数。可以分为1000组，每组1000个数
读取整数n，将其分配到对应的组g=n/1000中，
则发现:0  ~ 999  的数在组1中，每当整数分配到数组1中，就累加数组1次数，如果最终发现次数不是1000，说明数组1丢失整数，再用位图对1000个数统计缺少哪个数
	    100~ 1999 的数在组2中
		...
		999000~999999的数在组1000中
		问题的关键变成如何分组
		10MB对应约2^(21)个整数，则最多拥有2^(21)个分组，设分组个数arraySize，每个数组包含元素为rangeSize
		arraySize=2^(32) / rangeSize <= 2^(21)
		位图向量大小 = 一个数组中数组个数
		所以: rangeSize >= 2^(11)，由于最多一次放入2^(23)字节到内存(10MB)，即需要2^(26)比特，即为位图向量所占内存最多情况
		2^(11) <= rangeSize <= 2^(26)
		可以取rangeSize = 2^(20)，即元素个数为2^20,分组个数= 2^32 / 2^20 = 2^12
		但该方法有限制条件：元素不能重复，否则统计失效

输入:
10(n个整数)
1 2 3 6 4 5 9 10 8 11
输出:
7

关键:
1 两次读取，第一次读取文件，进行分组，统计各组内次数，寻找次数不等于数组长度的组，记组号b
              二           ，统计分组后落入组b的元素，生成该组的位图，遍历位图，确定丢失的元素
2 
读取整数n，将其分配到对应的组g=n/1000中，
则发现:0  ~ 999  的数在组1中，每当整数分配到数组1中，就累加数组1次数，如果最终发现次数不是1000，说明数组1丢失整数，再用位图对1000个数统计缺少哪个数
	    100~ 1999 的数在组2中
		...
		999000~999999的数在组1000中
		问题的关键变成如何分组
		10MB对应约2^(21)个整数，则最多拥有2^(21)个分组，设分组个数arraySize，每个数组包含元素为rangeSize
		arraySize=2^(32) / rangeSize <= 2^(21)
		位图向量大小 = 一个数组中数组个数
		所以: rangeSize >= 2^(11)，由于最多一次放入2^(23)字节到内存(10MB)，即需要2^(26)比特，即为位图向量所占内存最多情况
		2^(11) <= rangeSize <= 2^(26)
		可以取rangeSize = 2^(20)，即元素个数为2^20,分组个数= 2^32 / 2^20 = 2^12
		但该方法有限制条件：元素不能重复，否则统计失效
*/

const unsigned long gRangeSize =1048576; // 2^20
//这里必须用long，否则溢出,C++中long和int都是4字节，所以long最大2^31大概为20亿，必须用unsigned long
bitset<gRangeSize> gBitset; //设置biteset长度为40亿

void process()
{
	int n;
	unsigned long value;
	unsigned long result = 0;
	//防止溢出用unsigned long
	unsigned long totalNum = int( pow(2, 32) );
	unsigned long blockNum = totalNum / gRangeSize;
	vector<int> vecValue;//存储输入数据
	unsigned i;
	while(cin >> n)
	{
		int* blockArr = new int[blockNum];
		memset(blockArr , 0 , sizeof(blockArr) * blockNum);
		gBitset.reset();//设置所有位为0
		for(i = 0 ; i < n ; i++)
		{
			cin >> value;
			vecValue.push_back(value);
			//判断当前元素所在组，并累加次数，但这个只适用于非重复的情况，如果有整数重复了，比如两个1，都会累加，除非能判断当前整数是否已经出现过
			blockArr[ value / gRangeSize ]++;
			//将元素存储在对应组的位图中
		}
		//寻找丢失元素的数组
		unsigned long lostBlockNumber = 0; 
		//正整数，必须从1开始
		for(i = 0 ; i < blockNum ; i++)
		{
			if( blockArr[i] < gRangeSize )
			{
				lostBlockNumber = i;
				break;
			}
		}

		//第二次读取数据，将凡是属于丢失元素的数组中元素找出，生成位图，寻找丢失元素
		unsigned long blockNum;
		unsigned long bit;
		for(i = 0 ; i < n ; i++)
		{
			blockNum = vecValue.at(i)/ gRangeSize;
			//生成位图
			if(blockNum == lostBlockNumber)
			{
				bit = vecValue.at(i) % gRangeSize;
				gBitset.at(bit) = 1;
			}
		}

		//在位图中寻找丢失的元素
		for( i = 1 ; i < gRangeSize ; i++)
		{
			if( gBitset.at(i) == 0 )
			{
				//还原丢失的数
				result = i + lostBlockNumber * gRangeSize;
				break;
			}
		}
		cout << result << endl;
		delete[] blockArr;
	}
}

int main(int argc, char* argv[])
{
	process();
	getchar();
	return 0;
}