HDU 1880 魔咒词典

                        魔咒词典

Problem Description

哈利波特在魔法学校的必修课之一就是学习魔咒。据说魔法世界有100000种不同的魔咒，哈利很难全部记住，但是为了对抗强敌，他必须在危急时刻能够调用任何一个需要的魔咒，所以他需要你的帮助。

给你一部魔咒词典。当哈利听到一个魔咒时，你的程序必须告诉他那个魔咒的功能；当哈利需要某个功能但不知道该用什么魔咒时，你的程序要替他找到相应的魔咒。如果他要的魔咒不在词典中，就输出“what?”

Input

首先列出词典中不超过100000条不同的魔咒词条，每条格式为：

[魔咒] 对应功能

其中“魔咒”和“对应功能”分别为长度不超过20和80的字符串，字符串中保证不包含字符“[”和“]”，且“]”和后面的字符串之间有且仅有一个空格。词典最后一行以“@END@”结束，这一行不属于词典中的词条。
词典之后的一行包含正整数N（<=1000），随后是N个测试用例。每个测试用例占一行，或者给出“[魔咒]”，或者给出“对应功能”。

Output

每个测试用例的输出占一行，输出魔咒对应的功能，或者功能对应的魔咒。如果魔咒不在词典中，就输出“what?”

Sample Input

[expelliarmus] the disarming charm
[rictusempra] send a jet of silver light to hit the enemy
[tarantallegra] control the movement of one's legs
[serpensortia] shoot a snake out of the end of one's wand
[lumos] light the wand
[obliviate] the memory charm
[expecto patronum] send a Patronus to the dementors
[accio] the summoning charm
@END@
4
[lumos]
the summoning charm
[arha]
take me to the sky

Sample Output

light the wand
accio
what?
what?

题目分析

总所周知，几乎不存在绝对完美的哈希函数，也就是说哈希冲突是难以避免的。最近看到了一种很不错的方法来处理哈希冲突，采用了链式前向星建图的方法来存储字符串，利用每个结点中的next，可以指向哈希值相同的其余字符串，这个方法感觉挺不错的。

然后，本题使用的哈希函数是 BKDRHash，听说这种Hash函数挺不错的......

代码区

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<string>
#include<cmath>
#include<fstream>
#include<vector>
#include<stack>
#include <map>
#include <iomanip> 
#define bug cout << "**********" << endl
#define out cout<<"---------------"<<endl
#define show(x, y) cout<<"["<<x<<","<<y<<"] "
//#define LOCAL = 1;
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int mod = 1e5 + 7;
const int Max = 1e5 + 10;

/*此处以两个字符串相互匹配为模板，相当于手写map<string,string>*/
struct Node
{
	char que[25];
	char ans[85];
	int next;				//记录哈希值相同的组合下，指向另一个各拥有相同哈希值的组合（链式前向星建图思想）
}nodeA[Max],nodeB[Max];		//分别记录用咒语和功能作为哈希得到的

int n, m;
int headA[Max], headB[Max], totA, totB;	
/*
 * hashTableA[i]记录hash值为i的时候，最后一个que的哈希值为i的魔法组合
 * hashTableB[i]记录hash值为i的时候，最后一个ans的哈希值为i的魔法组合
 * 类比链式前向星建图
*/

void init()
{
	memset(headA, -1, sizeof(headA));
	memset(headB, -1, sizeof(headB));
	totA = totB = 0;
}

unsigned int BKDRHash(char *raw)
{
	unsigned int seed = 131313;				//也可以取 13,131,1313....
	unsigned int hash = 0;
	while (*raw)
	{
		hash = hash * seed + (*raw++);
	}
	return hash % mod;						//哈希值不能太大，规定其范围
}

void insert(char* que,char* ans)			//和链式前向星建图几乎是一个板子的
{
	unsigned int pos = BKDRHash(que);
	strcpy(nodeA[totA].que, que);
	strcpy(nodeA[totA].ans, ans);
	nodeA[totA].next = headA[pos];
	headA[pos] = totA;
	totA++;

	pos = BKDRHash(ans);
	strcpy(nodeB[totB].que, que);
	strcpy(nodeB[totB].ans, ans);
	nodeB[totB].next = headB[pos];
	headB[pos] = totB;
	totB++;
}

int find_ans(char* que)						//怎么看都像链式前向星...返回组合的下标
{
	unsigned int pos = BKDRHash(que);
	for(int i = headA[pos]; i != -1;  i = nodeA[i].next)
	{
		if(strcmp(nodeA[i].que,que) == 0) return i;
	}
	return -1;
}

int find_que(char* ans)						//怎么看都像链式前向星...返回组合的下标
{
	unsigned int pos = BKDRHash(ans);
	for (int i = headB[pos]; i != -1; i = nodeB[i].next)
	{
		if (strcmp(nodeB[i].ans, ans) == 0) return i;
	}
	return -1;
}

int main()
{
#ifdef LOCAL
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	char que[25], ans[85];
	char str[120];
	init();
	while(gets(str))
	{
		if (str[0] == '@')break;
		int len = 0;
		int i = 1;
		for (; str[i] != ']'; i++)
			que[len++] = str[i];
		que[len] = '\0';		//字符串结尾标志
		len = 0;
		for (i += 2;str[i] != 0;i++)
			ans[len++] = str[i];
		ans[len] = '\0';
		insert(que, ans);
	}
	scanf("%d", &n);
	getchar();
	while(n--)
	{
		gets(str);
		if(str[0] == '[')
		{
			int len = 0;
			for (int i = 1;str[i] != ']';i++)
				que[len++] = str[i];
			que[len] = '\0';
			int pos = find_ans(que);
			if (pos == -1)
				printf("what?\n");
			else
				printf("%s\n", nodeA[pos].ans);
		}
		else
		{
			int len = 0;
			for (int i = 0;str[i] != 0;i++)
				ans[len++] = str[i];
			ans[len] = '\0';
			int pos = find_que(ans);
			if (pos == -1)
				printf("what?\n");
			else
				printf("%s\n", nodeB[pos].que);
		}
	}
	return 0;
}