poj 3349 Snowflake Snow Snowflakes

题目：http://poj.org/problem?id=3349

这道题太纠结了，卡了一个晚上，一开始题意理解错了，顺时针和逆时针没有看到，还有就是知道用哈希可是不知道怎样设置key的值来处理冲突，后来搜了一下解题报告然后说是取999983，然后就是用哈希链表，用到了指针，总是出错，错误太难找了，好不容易运行OK了，结果TLE，直接被伤，后来在discuss里有人说是用cin会超时，就改成了scanf，试了一下就A了，唉，这个纠结的啊。。。

代码：

View Code

  1 #include <iostream>
  2 #include<algorithm>
  3 #include<cstdio>
  4 #define prim 999983
  5 using namespace std;
  6 
  7 struct node
  8 {
  9     int data;
 10    int a[6];
 11    struct node *next;
 12 }hash[prim+1];
 13 int main()
 14 {
 15     int s[6];
 16     int n;
 17     int i,j,k,t;
 18     __int64 sum;
 19     int fflag=0;
 20     for(i=0;i<=prim;i++)
 21     {
 22         hash[i].next=NULL;
 23         hash[i].data=0;
 24     }
 25     scanf("%d",&n);
 26     for(i=1;i<=n;i++)
 27     {
 28         sum=0;
 29         for(j=0;j<6;j++)
 30         {
 31             scanf("%d",&s[j]);
 32             sum+=(s[j]%prim);
 33             sum%=prim;
 34         }
 35 
 36         if(fflag==0)
 37         {
 38             if(hash[sum].data!=0)
 39             {
 40                 struct node *q;
 41                 q=hash[sum].next;
 42                 for(k=0;k<6;k++)
 43                 {
 44                     int flag=1;
 45                     for(t=0;t<6;t++)
 46                     {
 47                         if(q->a[t]!=s[(k+t)%6])
 48                         {
 49                             flag=0;
 50                             break;
 51                         }
 52                     }
 53                     if(flag)
 54                     {
 55                         fflag=1;
 56                         break;
 57                     }
 58                 }
 59                 for(k=0;k<6;k++)
 60                 {
 61                     int flag=1;
 62                     for(t=0;t<6;t++)
 63                     {
 64                         if(q->a[t]!=s[(5-k-t+6)%6])
 65                         {
 66                             flag=0;
 67                             break;
 68                         }
 69                     }
 70                     if(flag)
 71                     {
 72                         fflag=1;
 73                         break;
 74                     }
 75                 }
 76 
 77                 while(q->next!=NULL&&fflag==0)
 78                 {
 79                     q=q->next;
 80                     for(k=0;k<6;k++)
 81                     {
 82                         int flag=1;
 83                         for(t=0;t<6;t++)
 84                         {
 85                             if(q->a[t]!=s[(k+t)%6])
 86                             {
 87                                 flag=0;
 88                                 break;
 89                             }
 90                         }
 91                         if(flag)
 92                         {
 93                             fflag=1;
 94                             break;
 95                         }
 96                     }
 97                     if(fflag)
 98                     break;
 99                     for(k=0;k<6;k++)
100                     {
101                         int flag=1;
102                         for(t=0;t<6;t++)
103                         {
104                             if(q->a[t]!=s[(11-k-t)%6])
105                             {
106                                 flag=0;
107                                 break;
108                             }
109                         }
110                         if(flag)
111                         {
112                             fflag=1;
113                             break;
114                         }
115                     }
116                     if(fflag)
117                     break;
118 
119                 }
120                 if(fflag==0)
121                 {
122                     struct node *p;
123                     p=(struct node *)malloc(sizeof(struct node));
124                     p->data=i;
125                     for(k=0;k<6;k++)
126                     {
127                         p->a[k]=s[k];
128                     }
129                     p->next=q->next;
130                     q->next=p;
131                 }
132             }
133             else
134             {
135                 struct node *p;
136                 p=(struct node *)malloc(sizeof(struct node));
137                 p->data=i;
138                 for(k=0;k<6;k++)
139                 {
140                     p->a[k]=s[k];
141                 }
142                 p->next=hash[sum].next;
143                 hash[sum].next=p;
144                 hash[sum].data=1;
145             }
146 
147         }
148 
149     }
150     if(fflag==0)
151     cout<<"No two snowflakes are alike."<<endl;
152     else
153     cout<<"Twin snowflakes found."<<endl;
154     return 0;
155 }