poj 4093:倒排索引查询

poj 4093:倒排索引查询

题目：

总时间限制: 

1000ms 

内存限制: 

131072kB

描述

现在已经对一些文档求出了倒排索引，对于一些词得出了这些词在哪些文档中出现的列表。

要求对于倒排索引实现一些简单的查询，即查询某些词同时出现，或者有些词出现有些词不出现的文档有哪些。

输入

第一行包含一个数N，1 <= N <= 100，表示倒排索引表的数目。
接下来N行，每行第一个数c_i，表示这个词出现在了多少个文档中。接下来跟着c_i个数，表示出现在的文档编号，编号不一定有序。1 <= c_i <= 1000，文档编号为32位整数。
接下来一行包含一个数M，1 <= M <= 100，表示查询的数目。
接下来M行每行N个数，每个数表示这个词要不要出现，1表示出现，-1表示不出现，0表示无所谓。数据保证每行至少出现一个1。

输出

共M行，每行对应一个查询。输出查询到的文档编号，按照编号升序输出。
如果查不到任何文档，输出"NOT FOUND"。

样例输入

3
3 1 2 3
1 2
1 3
3
1 1 1
1 -1 0
1 -1 -1

样例输出

NOT FOUND
1 3
1

解题方案

我们先考虑两个子问题

1.求出两个有序递增数组的交集，并集，补集

我使用的是归并排序思想，只不过取得元素不同而已

2.求出多个有序递增数组的交集，并集

第一问题是这个问题的子问题，同时使用归并思想去做，如同擂台赛一样，每一个数组如同一个选手去争冠军

好了，子问题解决完毕，我们看看poj题目

1）对每一个索引表排序

2）对每一组查询，找出需要出现的文档号集合 wanted_list 和 不出现的文档号集合 not_wanted_list(这两个问题分别是上述第二个子问题求多个数组的交集，并集问题)

3）求出wanted_list 相对 not_wanted_list的补集即可 

代码c++如下

#include <iostream>
#include <list>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

class Node
{
public:
	int word_id;
	int bit;
};

int compare(const void * a,const void * b)
{
	return *(int*)a - *(int *)b;
}

void print_list(list<int> mylist);
list<Node> initialize_list(int **search,int row,int N,bool need);
list<int> sub_data(list<int> wanted_list,list<int> not_wanted_list);
list<int> find_same_need(list<Node> mylist,int ** data,const int length);
list<int> find_same_not_need(list<Node> mylist,int ** data,const int length);
void read_data(int ** &data,int ** & search,int &M,int &N);

int main()
{
	int ** data;
	int ** search;
	int M,N;
	list<int> wanted_list;
	list<int> not_wanted_list;
	list<Node> wanted_node_list;
	list<Node> not_wanted_node_list;
	list<int> result;
	read_data(data,search,M,N);

	for( int i=0;i<M;i++ )
	{
		wanted_node_list = initialize_list(search,i,N,true);
		not_wanted_node_list = initialize_list(search,i,N,false);
		wanted_list = find_same_need(wanted_node_list,data,N);
		not_wanted_list = find_same_not_need(not_wanted_node_list,data,N);
		result = sub_data(wanted_list,not_wanted_list);
		print_list(result);
	}
	system("pause");
	return 0;

}

list<int> find_same_need(list<Node> mylist,int ** data,const int length)
{
	list<int> result;
	bool same ;
	list<Node>::iterator min_node;
	int min_article_id;

	while( true )
	{
		// 1. 检查当前文档号是否是一样的
		same = true;
		Node one = mylist.front();
		for(list<Node>::iterator node = mylist.begin();node != mylist.end(); node++)
		{
			if( data[one.word_id][one.bit] != data[node->word_id][node->bit] )
			{
				same = false;
				break;
			}
		}

		// 2. 结果如果不相同时，则需要增加最小的
		if( ! same )
		{
			min_article_id = INT_MAX;
			for(list<Node>::iterator node = mylist.begin();node != mylist.end(); node++)
			{
				if( data[node->word_id][node->bit] < min_article_id )
				{
					min_article_id = data[node->word_id][node->bit];
					min_node = node;
				}
			}
			min_node->bit ++;
			// 已经得到所有结果
			if( min_node->bit > data[min_node->word_id][0] )
				return result;
		}

		// 3. 存储一个结果
		else
		{
			result.push_back( mylist.front().bit );
			for (list<Node>::iterator node = mylist.begin(); node != mylist.end(); node++)
			{
				node->bit ++;

				// 已经得到所有结果
				if( node->bit > data[node->word_id][0] )
					return result;
			}
		}
	}
}

list<int> find_same_not_need(list<Node> mylist,int ** data,const int length)
{
	map<int,bool> myamp;
	list<int> result;
	for(list<Node>::iterator it = mylist.begin();it != mylist.end() ;it++)
	{
		while(it->bit <= data[it->word_id][0])
		{
			if( myamp.find(data[it->word_id][it->bit]) == myamp.end() )
			{
				myamp.insert(make_pair(data[it->word_id][it->bit],true));
			}
			it->bit ++;
		}
	}
	for(map<int,bool>::iterator it = myamp.begin();it!=myamp.end();it++)
	{
		result.push_back(it->first);
	}
	return result;
}




list<int> sub_data(list<int> wanted_list,list<int> not_wanted_list)
{
	list<int> result;
	list<int>::iterator wanted_it,not_wanted_it;
	wanted_it = wanted_list.begin();
	not_wanted_it = not_wanted_list.begin();
	while( wanted_it!= wanted_list.end() && not_wanted_it != not_wanted_list.end() )
	{
		if( *wanted_it < *not_wanted_it )
		{
			result.push_back(*wanted_it) ;
			wanted_it++;
		}
		else if( *wanted_it > *not_wanted_it )
		{
			not_wanted_it++;
		}
		else
		{
			wanted_it++;
			not_wanted_it++;
		}
	}
	while(wanted_it != wanted_list.end())
	{
		result.push_back(*wanted_it);
		wanted_it++;
	}
	return result;
}

list<Node> initialize_list(int **search,int row,int N,bool need)
{
	list<Node> result;
	Node node;
	if( need )
	{
		for( int i=0;i<N;i++ )
		{
			if( search[row][i] == 1 )
			{
				node.word_id = i;
				node.bit = 1;
				result.push_back( node );
			}
		}
	}
	else
	{
		for( int i=0;i<N;i++ )
		{
			if( search[row][i] == -1 )
			{
				node.word_id = i;
				node.bit = 1;
				result.push_back( node );
			}
		}
	}
	return result;
}

void print_list(list<int> mylist)
{
	if(mylist.size() > 0)
	{
		for(list<int>::iterator it=mylist.begin();it != mylist.end();it++)
		{
			cout<<*it<<" ";
		}
	}
	else cout<<"NOT FOUND";
	cout<<endl;
}

void read_data(int ** &data,int ** & search,int &M,int &N)
{
	ifstream reader;
	reader.open("data.txt");
	reader>>N;
	data = new int* [N];
	int m;
	for(int i=0;i<N;i++)
	{
		reader>>m;
		data[i] = new int[m+1];
		data[i][0] = m;
		for(int j=1;j<m+1;j++)
		{
			reader>>data[i][j];
		}
		qsort(data[i]+1,data[i][0],sizeof(int),compare);
	}

	reader>>M;
	search = new int * [M];
	for(int i=0;i<M;i++)
	{
		search[i] = new int[N];
		for(int j =0;j<N;j++)
		{
			reader>>search[i][j];
		}
	}
	reader.close();
}

数据测试 data.txt

3
3 1 2 3
1 2
1 3
3
1 1 1
1 -1 0
1 -1 -1

程序结果