usaco 4.3 Letter Game 搜索

 搜索题目，状态很多，需要优化：
1.优化搜索顺序：先确定对角线，因为对角线对行列的影响最大。然后每次选取已确定数字个数最多的行列进行枚举，这样最省时间
2.合理设计数据结构：假设我们需要迅速查找到第一位和第五位分别为1,3的素数集合，该如何处理？预处理是搜索问题优化的好方法，可以在搜索前将各种需要枚举的素数集合分别存起来，这样速度将会快很多
3.如果某行或者某列已经有四个数确定了，那么第五个数可以直接算出来，如果它在0到9之间并且五个数组成起来是素数的话，那么就是符合条件的

下面图示解释了枚举顺序
processing order
03332
71?28
64156
72?18
24?51

 

错误总结：
1.写程序的时候忘记首位不能为0的要求了，所以，对于比较长的程序，最好列一下大纲，或者把关键步骤写出来，这样不容易错
2.边界问题。计算机处理的数据一般都有上下界，所以边界要时刻考虑，负数不能作下标
3.排序出错。对关键字是数字串的数组排序，很容易出错，compare时要注意如果当前可以比较出大小，要立即返回

 

1. /*
2. PROG: prime3
3. LANG: C++
4. ID: heben991
5. */
6. #include <iostream>
7. #include <algorithm>
8. using namespace std;
11. const int n = 5, N = 100010, PN = 200, R = 10;
13. int p[N], p1[R][PN*R], p3[R][PN*R],
14.     p15[R][R][PN], p124[R][R][R][PN],
15.     p234[R][R][R][PN], p135[R][R][R][PN];
17. int sum;
18. bool del[N];
19. char a[n+1][n+1];
21. struct data
22. {
23.     char a[n+1][n+1];
24. }ans[PN*PN], *out[PN*PN];
25. int ans_num;
28. bool cmp(const data *x, const data *y)
29. {
30.     int i, j;
31.     for(i = 1; i <= n; ++i)
32.         for(j = 1; j <= n; ++j)
33.         {
34.             if(x->a[i][j] < y->a[i][j]) return true;
35.             if(x->a[i][j] > y->a[i][j]) return false; // don't forget this
36.         }
37.     return false;
38. }
40. void seperate(int x, char *num)
41. {
42.     int i, j;
44.     for(i = n; i >= 1; --i)
45.     {
46.         num[i] = x%10;
47.         x /= 10;
48.     }
49. }
51. void get_prime()
52. {
53.     int i, j;
54.     char num[n+1];
56.     for(i = 2; i < N; ++i)
57.     {
58.         if(!del[i])
59.         {
60.             p[++p[0]] = i;
62.             if(i >= 10000)
63.             {
64.                 seperate(i, num);
65.                 if(num[1]==1 && num[5]==2)
66.                 {
67.                     printf("%d/n", i);
68.                     for(j = 1; j <= n; ++j) printf("%d ", num[j]);
69.                     exit(0);
70.                 }
71.                 int t=0;
72.                 bool zero=false;
73.                 for(j = 1; j <= n; ++j)
74.                 {
75.                     t += num[j];
76.                     if(num[j]==0) zero=1;
77.                 }
78.                 if(t == sum)
79.                 {
81.                     p1[num[1]][ ++p1[num[1]][0] ] = i;
82.                     p3[num[3]][ ++p3[num[3]][0] ] = i;
83.                     if(!zero) p15[num[1]][num[5]][ ++p15[num[1]][num[5]][0] ] = i;
84.                     // zero!!
85.                     p124[num[1]][num[2]][num[4]][ ++p124[num[1]][num[2]][num[4]][0] ] = i;
86.                     p234[num[2]][num[3]][num[4]][ ++p234[num[2]][num[3]][num[4]][0] ] = i;
87.                     p135[num[1]][num[3]][num[5]][ ++p135[num[1]][num[3]][num[5]][0] ] = i;
88.                 }
89.             }
91.         }
93.         for(j = 1; j <= p[0] && p[j]*i < N; ++j)
94.         {
95.             del[p[j]*i] = true;
96.             if(i%p[j]==0) break;
97.         }
98.     }
99. }
101. void update()
102. {
103.     memcpy(ans[++ans_num].a, a, sizeof(a));
104. }
106. bool fail_row(int row)
107. {
108.     int i, x=0, t=0;
109.     for(i = 1; i <= n; ++i)
110.     {
111.         x *= 10;
112.         x += a[row][i];
113.         t += a[row][i];
114.     }
115.     return t!=sum || del[x];
116. }
118. bool fail_col(int col)
119. {
120.     int i, x=0, t=0;
121.     for(i = 1; i <= n; ++i)
122.     {
123.         x *= 10;
124.         x += a[i][col];
125.         t += a[i][col];
126.     }
127.     return t!=sum || del[x];
128. }
132. /*
133. process order
134. 03332
135. 71?28
136. 64156
137. 72?18
138. 24?51
140. the set of prime
141. p1
142. p3
143. p15
144. p124
145. p234
146. p135
147. */
149. int main()
150. {
151.     int i, j, k, d1, d2, r1, c2, c4, r3, c1, c5;
152.     int s[3];
153.     char num[n+1];
155.     freopen("prime3.in","r",stdin);
156.     freopen("prime3.out","w",stdout);
157.     scanf("%d%d", &sum, &a[1][1]);
158.     get_prime();
159.     for(d1 = 1; d1 <= p1[a[1][1]][0]; ++d1)
160.     {
161.         seperate(p1[a[1][1]][d1], num);
163.         for(i = 2; i <= n; ++i)
164.         {
165.             a[i][i] = num[i];
166.         }
168.         for(d2 = 1; d2 <= p3[a[3][3]][0]; ++d2)
169.         {
170.             seperate(p3[a[3][3]][d2], num);
171.             for(i = 1; i <= n; ++i)
172.             {
173.                 a[n-i+1][i] = num[i];
174.             }
176.             for(r1 = 1; r1 <= p15[a[1][1]][a[1][n]][0]; ++r1)
177.             {
178.                 seperate(p15[a[1][1]][a[1][n]][r1], num);
179.                 for(i = 2; i < n; ++i)
180.                 {
181.                     a[1][i] = num[i];
182.                 }
184.                 for(c2 = 1; c2 <= p124[a[1][2]][a[2][2]][a[4][2]][0]; ++c2)
185.                 {
186.                     seperate(p124[a[1][2]][a[2][2]][a[4][2]][c2], num);
187.                     a[3][2] = num[3], a[5][2] = num[5];
189.                     for(c4 = 1; c4 <= p124[a[1][4]][a[2][4]][a[4][4]][0]; ++c4)
190.                     {
191.                         seperate( p124[a[1][4]][a[2][4]][a[4][4]][c4], num);
192.                         a[3][4] = num[3], a[5][4] = num[5];
194.                         for(r3 = 1; r3 <= p234[a[3][2]][a[3][3]][a[3][4]][0]; ++r3)
195.                         {
196.                             seperate(p234[a[3][2]][a[3][3]][a[3][4]][r3], num);
197.                             a[3][1] = num[1], a[3][5] = num[5];
199.                             for(c1 = 1; c1 <= p135[a[1][1]][a[3][1]][a[5][1]][0]; ++c1)
200.                             {
201.                                 seperate(p135[a[1][1]][a[3][1]][a[5][1]][c1], num);
202.                                 if(num[2]==0 || num[4]==0) continue;
203.                                 a[2][1] = num[2], a[4][1] = num[4];
205.                                 for(c5 = 1; c5 <= p135[a[1][5]][a[3][5]][a[5][5]][0]; ++c5)
206.                                 {
207.                                     seperate( p135[a[1][5]][a[3][5]][a[5][5]][c5], num);
208.                                     a[2][5] = num[2], a[4][5] = num[4];
211.                                     a[2][3] = sum - (a[2][1]+a[2][2]+a[2][4]+a[2][5]);
212.                                     if(a[2][3]<0 || a[2][3]>9 || fail_row(2)) continue;
213.                                     // 0<=a[2][i]<=9 && sum(a[2])==sum && prime(a[2])
215.                                     a[4][3] = sum - (a[4][1]+a[4][2]+a[4][4]+a[4][5]);
216.                                     if(a[4][3]<0 || a[4][3]>9 || fail_row(4)) continue;
218.                                     a[5][3] = sum - (a[1][3]+a[2][3]+a[3][3]+a[4][3]);
219.                                     if(a[5][3]<0 || a[5][3]>9 || fail_col(3) || fail_row(5)) continue;
222.                                     update();
223.                                 }
224.                             }
225.                         }
226.                     }
227.                 }
228.             }
229.         }
230.     }
232.     for(i = 1; i <= ans_num; ++i)
233.     {
234.         out[i] = ans+i;
235.     }
237.     sort(out+1, out+ans_num+1, cmp);
239.     for(i = 1; i <= ans_num; ++i)
240.     {
241.         for(j = 1; j <= n; ++j)
242.         {
243.             for(k = 1; k <= n; ++k)
244.             {
245.                 printf("%d", out[i]->a[j][k]);
246.             }
247.             putchar('/n');
248.         }
249.         if(i!=ans_num) putchar('/n');
250.     }
253.     return 0;
254. }