POJ_3349_Snowflake Snow Snowflakes(哈希表)

 http://poj.org/problem?id=3349

/*
题意：输入n个雪花，判断这些雪花中是否有两片是一样的，包括顺时针判断和逆时针判断
如果输入过程发现已经有一样的了还得继续输入。
使用哈希就是为了减少比较的次数，即只有当哈希地址相同的时候才比较，因为哈希地址不同
说明两片雪花肯定是不一样的。
在这里主要是解决哈希地址冲突的问题，此处是用的链式存储。
 1:计算哈希地址的时候用的是连加取余法；为了避免产生大数，使用了同余模定理：
(a+b+c)%r=(a%r+b%r+c%r)%r;
2：在顺时针逆时针判断是否一样的时候使用了取余。
*/

/*
题意：输入n个雪花，判断这些雪花中是否有两片是一样的，包括顺时针判断和逆时针判断
如果输入过程发现已经有一样的了还得继续输入。
使用哈希就是为了减少比较的次数，即只有当哈希地址相同的时候才比较，因为哈希地址不同
说明两片雪花肯定是不一样的。
在这里主要是解决哈希地址冲突的问题，此处是用的链式存储。
 1:计算哈希地址的时候用的是连加取余法；为了避免产生大数，使用了同余模定理：
(a+b+c)%r=(a%r+b%r+c%r)%r;
2：在顺时针逆时针判断是否一样的时候使用了取余。
*/
# include <stdio.h>
# include <string.h>
#include<iostream>
using namespace std;
const __int64 prime=999983; //100w内的最大素数
struct node
{
    __int64 len[6]; 
}leaf[100001]; //存储输入的叶子。
typedef struct HashTable
{
    __int64 len[6];  //6瓣叶子的长度
    HashTable *next; //用于冲突的时候开放地址。
    HashTable()    //Initial；也可以在申请空间的时候初始化。但是如果加上下面的
                   //申请空间的时候不用初始化。
    {
        next=0;
    }
}Hashtable;
Hashtable *hash[prime+1]; //指针数组，数组元素是指向Hashtable的指针；
__int64 compute_key(int k)  //计算哈希地址；
{
    __int64 key=0;
    for(int i=0;i<6;i++)
    {
        key+=(leaf[k].len[i]) % prime;
        key%=prime;   
    }
    return key++;  
}
bool clockwise(Hashtable *p,int k) //顺时针判断
{
    for(int j=0;j<6;j++)  
    {
        bool flag=true;
        for(int i=0;i<6;i++)
            if(leaf[k].len[i] != p->len[(i+j)%6])
            {
                flag=false; //有一片不相同剩余的就不用判断了。
                break;
            }
        if(flag) //一个循环下来相同直接返回true
            return true;
    }
    return false;
}
bool counterclockwise(Hashtable *p,int k) //逆时针判断。
{
    for(int j=0;j<6;j++)  
    {
        bool flag=true;
        for(int i=0;i<6;i++)
            if(leaf[k].len[i] != p->len[(12-i-j)%6])
            {
                flag=false;
                break;
            }
        if(flag)
            return true;
    }
    return false;
}
bool insert(int k)
{
    __int64 key=compute_key(k);  //得到哈希地址。

    if(!hash[key]) //如果不冲突也就是这个地址没有存数据，
    {
        Hashtable* temp=new Hashtable; //申请空间
    //    temp->next=0;
        for(int i=0;i<6;i++)
            temp->len[i]=leaf[k].len[i];

        hash[key]=temp; //保存数值
    }
    else   //地址冲突，那么开放地址，顺便比较是否雪花相同
    {
        Hashtable *temp=hash[key]; //临时存放原来哈希地址存的数据。
    //    temp->next=0;
        if(clockwise(temp,k) || counterclockwise(temp,k))  //检查雪花是否相同
            return true;
        while(temp->next)   
        {
            temp=temp->next;
            if(clockwise(temp,k) || counterclockwise(temp,k))  //检查雪花是否相同
                return true;
        }
        //如果在hash冲突的数据中还没有相同的
        temp->next=new Hashtable; //开辟新空间存放数据
        //temp->next->next=0;
        for(int i=0;i<6;i++)
            temp->next->len[i]=leaf[k].len[i];
    }
    return false;
}

int main()
{
    int n,i,j;  
    while(scanf("%d",&n) != EOF)
    {
        memset(hash,0,sizeof(hash));  
        bool flag=false; 
        for(i=1;i<=n;i++)
        {
            for(j=0;j<6;j++)
                scanf("%I64d",&leaf[i].len[j]);
            if(!flag) 
                flag=insert(i);
        }
        if(flag)
            printf("Twin snowflakes found.\n");
        else 
            printf("No two snowflakes are alike.\n");


    }
    return 0;
}