DFS神题——jzyzoj1188:素数方阵

  检查了300行的代码后发现自己只是少加了一个i==0的条件....

  这是一道真的神题,下面给出题面:

  

  这道题最难的是搜索顺序的推理,这里给出我对这道题的理解:

  http://www.cnblogs.com/hinanawitenshi/p/6476422.html

  有了搜索顺序其实这道题就简单了一点,没错只是一点...

  以下是需要注意的几点:

    1.特判做差之后的结果可能大于9;

    2.对于横坐标或纵坐标为1的点,特判后的结果可能等于0;

    3.有了搜索顺序之后代码会非常长,细心调试。

    4.判断质数可以建立bool数组,先用筛法求出所有五位质数,然后用O(1)的复杂度进行判断。

  代码如下:

  

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<cstring>
  4 #include<cmath>
  5 #include<string>
  6 #include<algorithm>
  7 using namespace std;
  8 const int MAX=100000;
  9 int row[6],column[6],diagonal1=0,diagonal2=0,a[6][6],num[5]={0,1,3,7,9},n,len=0;
 10 bool f[200000];
 11 string s[100001];
 12 void primenumber()//筛法求质数
 13 {
 14     bool flag[MAX];
 15     memset(flag,false,sizeof(flag));
 16     for (int i=2; i<MAX; i+=2)
 17     {
 18         flag[i]=true;
 19     }
 20     for (int i=3; i<MAX; i+=2)
 21     {
 22         if (!flag[i]) 
 23         {
 24             f[i]=true;
 25             for (int j=i; j<MAX; j+=i)
 26                 flag[j]=true;
 27         }
 28     }
 29 }
 30 void dfs (int p)
 31 {
 32     if (p==25) 
 33     {
 34         len++;
 35         for (int i=1; i<=5; i++)
 36             for (int j=1; j<=5; j++)
 37                 s[len]=s[len]+char(a[i][j]+'0');
 38     }
 39     else if (p<5||(p>5&&p<9))
 40     {
 41         for (int i=1;i<5;i++)
 42         {
 43             if (p==1) 
 44             {
 45                 if (row[1]+num[i]>n||column[5]+num[i]>n||diagonal2+num[i]>n) 
 46                     return;
 47                 row[1]+=num[i];    column[5]+=num[i];    diagonal2+=num[i];
 48                 a[1][5]=num[i];
 49                 dfs(p+1);
 50                 row[1]-=num[i];    column[5]-=num[i];    diagonal2-=num[i];
 51             }
 52             else if (p>1&&p<5)
 53             {
 54                 if (row[p]+num[i]>n||column[5]+num[i]>n) 
 55                     return;
 56                 row[p]+=num[i];    column[5]+=num[i];
 57                 a[p][5]=num[i];
 58                 dfs(p+1);
 59                 row[p]-=num[i];    column[5]-=num[i];
 60             }
 61             else if (p==6)
 62             {
 63                 if (row[5]+num[i]>n||column[1]+num[i]>n||diagonal2+num[i]>n) 
 64                     return;
 65                 row[5]+=num[i];    column[1]+=num[i];    diagonal2+=num[i];
 66                 a[5][1]=num[i];
 67                 dfs(p+1);
 68                 row[5]-=num[i];    column[1]-=num[i];    diagonal2-=num[i];
 69             }
 70             else 
 71             {
 72                 if (row[5]+num[i]>n||column[p-5]+num[i]>n) 
 73                     return;
 74                 row[5]+=num[i];    column[p-5]+=num[i];
 75                 a[5][p-5]=num[i];
 76                 dfs(p+1);
 77                 row[5]-=num[i];    column[p-5]-=num[i];
 78             }
 79         }
 80     }
 81     else if (p==5)
 82     {
 83         int i=n-column[5];
 84         if (!f[a[1][5]*10000+a[2][5]*1000+a[3][5]*100+a[4][5]*10+i]||
 85                 row[5]+i>n||diagonal1+i>n||i>9) 
 86             return;
 87         a[5][5]=i;
 88         row[5]+=i;    diagonal1+=i;    column[5]+=i;
 89         dfs(p+1);
 90         row[5]-=i;    diagonal1-=i;    column[5]-=i;
 91     }
 92     else if (p==9)
 93     {
 94         int i=n-row[5];
 95         if (!f[a[5][1]*10000+a[5][2]*1000+a[5][3]*100+i*10+a[5][5]]||column[4]+i>n||i>9) 
 96         {
 97             return;
 98         }
 99         a[5][4]=i;
100         column[4]+=i;    row[5]+=i;
101         dfs(p+1);
102         column[4]-=i;    row[5]-=i;
103     }
104     else if (p==10)
105     {
106         for (int i=0; i<10; i++)
107         {
108             if (i+column[3]>n||i+row[3]>n||i+diagonal1>n||i+diagonal2>n)
109                 return;
110             a[3][3]=i;
111             column[3]+=i;    row[3]+=i;    diagonal1+=i;    diagonal2+=i;
112             dfs(p+1);
113             column[3]-=i;    row[3]-=i;    diagonal1-=i;    diagonal2-=i;
114         }
115     }
116     else if (p==11)
117     {
118         for (int i=0; i<10; i++)
119         {
120             if (i+column[2]>n||i+row[2]>n||i+diagonal1>n) 
121                 return;
122             a[2][2]=i;
123             column[2]+=i;row[2]+=i; diagonal1+=i;
124             dfs(p+1);
125             column[2]-=i;row[2]-=i; diagonal1-=i;
126         }
127     }
128     else if (p==12)
129     {
130         int i=n-diagonal1;
131         if (!f[a[1][1]*10000+a[2][2]*1000+a[3][3]*100+i*10+a[5][5]]||
132                 row[4]+i>n||column[4]+i>n||i>9)
133             return;
134         a[4][4]=i;
135         row[4]+=i;    column[4]+=i;    diagonal1+=i;
136         dfs(p+1);
137         row[4]-=i;    column[4]-=i;    diagonal1-=i;
138     }
139     else if (p==13)
140     {
141         for (int i=0; i<10; i++)
142         {
143             if (i+column[4]>n||i+row[2]>n||i+diagonal2>n)
144                 return;
145             a[2][4]=i;
146             column[4]+=i;    row[2]+=i;    diagonal2+=i;
147             dfs(p+1);
148             column[4]-=i;    row[2]-=i;    diagonal2-=i;
149         }
150     }
151     else if (p==14)
152     {
153         int i=n-diagonal2;
154         if (!f[a[5][1]*10000+i*1000+a[3][3]*100+a[2][4]*10+a[1][5]]||
155                 i+row[4]>n||i+column[2]>n||i>9)
156             return;
157         a[4][2]=i;
158         diagonal2+=i;    row[4]+=i;    column[2]+=i;
159         dfs(p+1);
160         diagonal2-=i;    row[4]-=i;    column[2]-=i;
161     }
162     else if (p==15)
163     {
164         for (int i=1; i<10; i++)
165         {
166             if (i+column[2]>n||i+row[1]>n) 
167                 return;
168             a[1][2]=i;
169             column[2]+=i;    row[1]+=i;
170             dfs(p+1);
171             column[2]-=i;    row[1]-=i;
172         }
173     }
174     else if (p==16)
175     {
176         int i=n-column[2];
177         if (!f[a[1][2]*10000+a[2][2]*1000+i*100+a[4][2]*10+a[5][2]]||
178                 row[3]+i>n||i>9) 
179             return;
180         a[3][2]=i;
181         column[2]+=i;    row[3]+=i;
182         dfs(p+1);
183         column[2]-=i;    row[3]-=i;
184     }
185     else if (p==17)
186     {
187         for (int i=1; i<10; i++)
188         {
189             if (i+row[1]>n||i+column[4]>n)
190                 return;
191             a[1][4]=i;
192             row[1]+=i;    column[4]+=i;
193             dfs(p+1);
194             row[1]-=i;    column[4]-=i;
195         }
196     }
197     else if (p==18)
198     {
199         int i=n-column[4];
200         if (!f[a[1][4]*10000+a[2][4]*1000+i*100+a[4][4]*10+a[5][4]]||
201                 row[3]+i>n||i>9)
202             return;
203         a[3][4]=i;
204         row[3]+=i;    column[4]+=i;
205         dfs(p+1);
206         row[3]-=i;    column[4]-=i;
207     }
208     else if (p==19)
209     {
210         int i=n-row[3];
211         if (!f[i*10000+a[3][2]*1000+a[3][3]*100+a[3][4]*10+a[3][5]]||
212                 column[1]+i>n||i==0||i>9)
213             return;
214         a[3][1]=i;
215         row[3]+=i;    column[1]+=i;
216         dfs(p+1);
217         row[3]-=i;    column[1]-=i;
218     }
219     else if (p==21)
220     {
221         for (int i=1; i<10; i++)
222         {
223             if (i+row[2]>n||i+column[1]>n||i==0||i>9)
224                 return;
225             a[2][1]=i;
226             row[2]+=i;    column[1]+=i;
227             dfs(p+1);
228             row[2]-=i;    column[1]-=i;
229         }
230     }
231     else if (p==23)
232     {
233         int i=n-column[1];
234         if (!f[a[1][1]*10000+a[2][1]*1000+a[3][1]*100+i*10+a[5][1]]||
235                 i+row[4]>n||i==0||i>9)
236             return;
237         a[4][1]=i;
238         row[4]+=i;    column[1]+=i;
239         dfs(p+1);
240         row[4]-=i;    column[1]-=i;
241     }
242     else if (p==24)
243     {
244         int i=n-row[4];
245         if (!f[a[4][1]*10000+a[4][2]*1000+i*100+a[4][4]*10+a[4][5]]||
246                 !f[a[1][3]*10000+a[2][3]*1000+a[3][3]*100+i*10+a[5][3]]||
247                 column[3]!=row[4]||i>9)
248             return;
249         a[4][3]=i;
250         row[4]+=i;    column[3]+=i;
251         dfs(p+1);
252         row[4]-=i;    column[3]-=i;
253     }
254     else if (p==22)
255     {
256         int i=n-row[2];
257         if (!f[a[2][1]*10000+a[2][2]*1000+i*100+a[2][4]*10+a[2][5]]||
258                 i+row[2]>n||i>9)
259             return;
260         a[2][3]=i;
261         row[2]+=i;    column[3]+=i;
262         dfs(p+1);
263         row[2]-=i;    column[3]-=i;
264     }
265     else if (p==20)
266     {
267         int i=n-row[1];
268         if (!f[a[1][1]*10000+a[1][2]*1000+i*100+a[1][4]*10+a[1][5]]||
269                 column[3]+i>n||i>9||i==0)
270             return;
271         a[1][3]=i;
272         row[1]+=i;    column[3]+=i;
273         dfs(p+1);
274         row[1]-=i;    column[3]-=i;
275     }
276 }
277 int main()
278 {
279     freopen("add.in","r",stdin);
280     freopen("add.out","w",stdout);
281     memset(row,0,sizeof(row));
282     memset(column,0,sizeof(column));
283     memset(f,false,sizeof(f));
284     scanf("%d%d",&n,&a[1][1]);
285     row[1]=a[1][1];    column[1]=a[1][1];    diagonal1=a[1][1];
286     primenumber();
287     dfs(1);
288     sort(s+1,s+1+len);
289     for (int k=1;k<=len;k++)
290     {
291         
292         for (int i=0;i<5;i++)
293         {
294             for (int j=0;j<5;j++)
295                 cout<<s[k][i*5+j];
296             cout<<endl;
297         }
298         if (k<len)
299             cout<<endl;
300     }
301     return 0;
302 }
AC代码

  有点乱,不过懒得整理了。

原文地址:https://www.cnblogs.com/hinanawitenshi/p/6476520.html