hdu1880

大致题意：有一本魔法词典，里面记述了魔法和其对应的功能，让你通过输入魔法查询其功能和输入功能判断他是哪种魔法，若没有找到则输出what？

测试案例：

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

output：

light the wand
accio
what?
what?

解题思路：我的思路用了我之前那个哈希表的结构，可能比较麻烦，我在哈希节点定义了judge变量，如果为false，则表示为魔咒找功能，为true则为功能找魔咒，然后开了一个z的二维数组用来存放魔咒，g的二维数组用来存放功能，每次输入魔咒和功能的时候分别把魔咒指向功能和功能指向魔咒插入哈希表，为了节约时间，将哈希表代表咒语和功能的量变为指向之前二维数组的整型值，比如0，代表的是第一条魔咒或第一条功能。然后进行查找，如果是魔咒查找功能，那么进入哈希表判断，并且输出的是g这个数组的值等等。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;
const int maxn=200110;//魔咒+功能总数

char z[maxn/2][25],g[maxn/2][85];//最多10w条魔咒
int k=0;

struct hashNode
{
    int s;
    bool judge;//false为魔咒找功能
    int postion;//指示位置
};

hashNode hashTable[2*maxn];//哈希表大小为插入数据数目*2

void magic(char s[],char s1[])//用于去掉魔咒的[]
{
    for (int i=1; i<strlen(s)-1; i++)
        s1[i-1]=s[i];
    s1[strlen(s)-2]='\0';
}
void magic(char s[],int k)//将功能和魔咒拆分
{
    int i=1;
    for (i=1; i<strlen(s)&&s[i]!=']'; i++)
        z[k][i-1]=s[i];
    z[k][i-1]='\0';
    i+=2;
    int j=0;
    for (; i<strlen(s); i++)
        g[k][j++]=s[i];
    g[k][j]='\0';

}

int hashf(char key[],int hashlen)//hash函数
{
    int v=0;
    for (int i=0; i<strlen(key); i++)
        v+=key[i];
    return v%hashlen;
}

void hash_insert(int pos,int key,int hashlen,int &cnt,bool judge)//插入表
{

    while (hashTable[pos].postion!=-1)//当pos位上的hash表已经存储了位置时，找到没有存储位置的hash表
    {
        pos=hashTable[pos].postion;
    }
    hashTable[pos].postion=cnt;
    hashTable[pos].s=key;
    hashTable[pos].judge=judge;
    cnt++;
}

void hash_search(char key[],int hashlen,bool judge)//查找
{
    int pos=hashf(key,hashlen);
    if (!judge)//魔咒找功能
    {
        while (pos<2*maxn&&hashTable[pos].postion!=-1)
        {
            int temp=hashTable[pos].s;
            if (hashTable[pos].s<k)
            {
                if (strcmp(z[temp],key)==0)
                {
                    printf("%s\n",g[hashTable[pos].s]);
                    return;
                }
                else
                    pos=hashTable[pos].postion;
            }
            else
                break;
        }
    }
    else//功能找魔咒
    {
        while (pos<2*maxn&&hashTable[pos].postion!=-1)
        {
            int temp=hashTable[pos].s;
            if (hashTable[pos].s<k)
            {
                if (strcmp(g[hashTable[pos].s],key)==0)
                {
                    printf("%s\n",z[hashTable[pos].s]);
                    return;
                }
                else
                    pos=hashTable[pos].postion;
            }
            else
                break;
        }
    }

    printf("what?\n");//未找到,如果找到了之前就好return
}


int main()
{

    memset(hashTable,-1,sizeof (hashTable));
    int hashlen=maxn,cnt=hashlen;//就按这么写，拉链法出来的位置从cnt开始

    char s[100],s1[100];
    int n,i,pos;
    while (gets(s))
    {
        if (s[0]=='@')
            break;
        magic(s,k);
        //printf("%s\n%s\n",s1,s2);
        pos=hashf(z[k],hashlen);
        hash_insert(pos,k,hashlen,cnt,false);//cnt与链式前向星的思路有点类似
        pos=hashf(g[k],hashlen);
        hash_insert(pos,k,hashlen,cnt,true);
        k++;
    }
    scanf("%d",&n);
    for (i=0; i<n;)
    {
        gets(s);
        if (s[0]=='\0'||s[0]=='\n')
            continue;
        else if (s[0]=='[')
        {
            magic(s,s1);
            hash_search(s1,hashlen,false);
            i++;
        }
        else
        {
            hash_search(s,hashlen,true);
            i++;
        }
    }

    return 0;
}