usaco training 4.3.2 The Primes 题解

The Primes题解
IOI'94

In the square below, each row, each column and the two diagonals can be read as a five digit prime number. The rows are read from left to right. The columns are read from top to bottom. Both diagonals are read from left to right.

+---+---+---+---+---+
| 1 | 1 | 3 | 5 | 1 |
+---+---+---+---+---+
| 3 | 3 | 2 | 0 | 3 |
+---+---+---+---+---+
| 3 | 0 | 3 | 2 | 3 |
+---+---+---+---+---+
| 1 | 4 | 0 | 3 | 3 |
+---+---+---+---+---+
| 3 | 3 | 3 | 1 | 1 |
+---+---+---+---+---+ 

• The prime numbers' digits must sum to the same number.
• The digit in the top left-hand corner of the square is pre-determined (1 in the example).
• A prime number may be used more than once in the same square.
• If there are several solutions, all must be presented (sorted in numerical order as if the 25 digits were all one long number).
• A five digit prime number cannot begin with a zero (e.g., 00003 is NOT a five digit prime number).

PROGRAM NAME: prime3

INPUT FORMAT

A single line with two space-separated integers: the sum of the digits and the digit in the upper left hand corner of the square.

SAMPLE INPUT (file prime3.in)

11 1

OUTPUT FORMAT

Five lines of five characters each for each solution found, where each line in turn consists of a five digit prime number. Print a blank line between solutions. If there are no prime squares for the input data, output a single line containing "NONE".

SAMPLE OUTPUT (file prime3.out)

The above example has 3 solutions.

11351
14033
30323
53201
13313

11351
33203
30323
14033
33311

13313
13043
32303
50231
13331

描述

在下面的方格中，每行，每列，以及两条对角线上的数字可以看作是五位的素数。方格中的行按照从左到右的顺序组成一个素数，而列按照从上到下的顺序。两条对角线也是按照从左到右的顺序来组成。

+---+---+---+---+---+
| 1 | 1 | 3 | 5 | 1 |
+---+---+---+---+---+
| 3 | 3 | 2 | 0 | 3 |
+---+---+---+---+---+
| 3 | 0 | 3 | 2 | 3 |
+---+---+---+---+---+
| 1 | 4 | 0 | 3 | 3 |
+---+---+---+---+---+
| 3 | 3 | 3 | 1 | 1 |
+---+---+---+---+---+ 

• 这些素数各个数位上的和必须相等。
• 左上角的数字是预先定好的。
• 一个素数可能在方阵中重复多次。
• 如果不只有一个解，将它们全部输出（按照这25个数字组成的25位数的大小排序）。
• 一个五位的素数开头不能为0（例如：00003 不是五位素数）

[编辑]格式

PROGRAM NAME: prime3

INPUT FORMAT:

(file prime3.in)

一行包括两个被空格分开的整数:各数位上的数字的和 以及左上角的数字。

OUTPUT FORMAT:

(file prime3.out)

对于每一个找到的方案输出5行，每行5个字符, 每行可以转化为一个5位的质数.在两组方案中间输出一个空行. 如果没有解就单独输出一行"NONE"。

[编辑]SAMPLE INPUT

11 1

[编辑]SAMPLE OUTPUT

上面的例子有三组解。

11351
14033
30323
53201
13313

11351
33203
30323
14033
33311

13313
13043
32303
50231
13331

序言：总算AC了。我花了一个半小时编完了程序，又花了两个小时调试程序，眼睛都花了。尽管在种种挫折前，我屡次萌生“放弃此题，随便贴个代码”的想法，但最终还是挺过去了。

这种方阵题很是多见。原来我都是直接暴力地顺序枚举（准确地说是有顺序枚举）。在这个题目面前，效率显然是非常低的。经过很长时间的探索，我总结出了一张枚举顺序的图。                                             如图，黄色的代表不能为0，绿色的代表必须是1,3,5,7,9（这些是结尾）。

枚举的顺序要遵循3个原则：①控制位置多的先来，以便剪枝。②相对有些规律，不要杂乱无章。③有些数字可以通过计算出来，无需枚举。（即图中的粉红数字，共12个）

但是问题很快就出来了：这样不就不能有规律地递归了吗？

为了不TLE，我毅然打起了13（25-12）个循环。

刚开始的时候，我开了xie1-xie2，hang1-hang5,lie1-lie5这些变量来分别记录各块的数字和。（以下为某处代码）

for (i2=1;i2<=5;i2++)
    {
      a[5][1]=mei[i2];lie1=a[1][1]+a[5][1];hang5=a[5][1]+a[5][5];if (hang5>sum||lie1>sum) break;

这个很实用。举个例子，xie1代表从左上到右下的（部分）数字和。这样，我不仅第6次枚举时把第8块的区域值算出来，还可以在之前的某处来个剪枝（比如，枚举到第5块方格时，若xie1=a[1][1]+a[5][5]+a[3][3]>sum(sum为给定的各块的数字和）时，直接跳掉）。我们还能看出这个剪枝很有效——由样例输出可知，大的个位数字几乎不曾出现。

然而这是有问题的。假设xie1累加后在某处直接break掉，它的值是不会改变的。下一次枚举另外一个数字时，xie1会继续加上。要避免问题，不能在循环里改变值，而要在函数里带入形参。很明显，这是不现实的。

就没有解决方案了吗？我想了一会，改了一些地方。如刚才的代码：

for (i1=1;i1<=5;i1++)
{
    a[5][5]=mei[i1];xie1=a[1][1]+a[5][5];if (xie1>sum) {xie1=0;break;}
    for (i2=1;i2<=5;i2++)
    {
      a[5][1]=mei[i2];lie1=a[1][1]+a[5][1];hang5=a[5][1]+a[5][5];if (hang5>sum||lie1>sum) {hang5=0;lie1=0;break;}

这好像递归中的回溯操作。
但是问题又来了：如果当时i1的值是5,而且到i2时被break掉了，那么xie1的值不能被减掉！
思考再三，我只好采用直接赋值的方法，放弃每次+=的优化方法，也减掉了一些剪枝。
还好，我最终成功了！
代码：

/*
PROG:prime3
ID:juan1973
LANG:C++
*/

#include<stdio.h>
#include<cstring>
#include<cmath>
using namespace std;
const int maxn=500+5;
int mei[6]={0,1,3,5,7,9};
int a[6][6],i1,i2,i3,jj,j2,j3,j4,k1,k2,p1,p2,p3,p4,p5,p6,sum,p,up,cnt,i,j,k,min,ans[maxn][6][6],num[maxn];
int hang1,hang2,hang3,hang4,hang5,lie1,lie2,lie3,lie4,lie5,xie1,xie2;
bool f[10][10][10][10][10],flag[maxn];
void first()                                        //预处理10000-99999之间的质数
{
  int w1,w2,w3,w4,w5,s;
  memset(f,1,sizeof(f));
  for (int i=2;i<=trunc(sqrt(99999));i++)
    for (int j=10000/i;j<=99999/i;j++)
    {
      s=i*j;w5=s%10;s=s/10;
      w4=s%10;s=s/10;
      w3=s%10;s=s/10;
      w2=s%10;s=s/10;
      f[s][w2][w3][w4][w5]=false;
    }
}
bool xiao(int p,int q)                              //比大小，用于排序
{
  for (int i=1;i<=5;i++)
    for (int j=1;j<=5;j++)
      if (ans[p][i][j]<ans[q][i][j]) return true;
      else if (ans[p][i][j]>ans[q][i][j]) return false;
}
int main()
{
  freopen("prime3.in","r",stdin);
  freopen("prime3.out","w",stdout);
  scanf("%ld%ld",&sum,&p);
  a[1][1]=p;up=9;if (sum<up) up=sum;
  first();
  for (i1=1;i1<=5;i1++)
  {
    a[5][5]=mei[i1];
    for (i2=1;i2<=5;i2++)
    {
      a[5][1]=mei[i2];
      for (i3=1;i3<=5;i3++)
      {
        a[1][5]=mei[i3];
        for (p1=0;p1<=up;p1++)
        {
          a[3][3]=p1;
          if (a[1][1]+a[5][5]+a[3][3]>sum||a[5][1]+a[1][5]+a[3][3]>sum) continue;
          for (p2=0;p2<=up;p2++)
          {
            a[4][4]=p2;
            if (a[5][5]==1&&a[5][1]==1&&a[1][5]==3&&a[3][3]==3&&a[4][4]==3)
                    a[3][3]=3;
            xie1=a[1][1]+a[5][5]+a[3][3]+a[4][4];if (xie1>sum) continue;
            a[2][2]=sum-xie1;
/*1-------*/if (a[2][2]<0||a[2][2]>9||!f[a[1][1]][a[2][2]][a[3][3]][a[4][4]][a[5][5]]) continue;
            for (p3=0;p3<=up;p3++)
            {
              a[4][2]=p3;
              if (a[5][5]==1&&a[5][1]==1&&a[1][5]==3&&a[3][3]==3&&a[4][4]==3&&a[4][2]==0)
                    a[3][3]=3;
              xie2=a[5][1]+a[1][5]+a[3][3]+a[4][2];if (xie2>sum) continue;
/*2-------*/  a[2][4]=sum-xie2;if (a[2][4]<0||a[2][4]>9||!f[a[5][1]][a[4][2]][a[3][3]][a[2][4]][a[1][5]]) continue;
            for (jj=1;jj<=5;jj++)
            {
              a[5][2]=mei[jj];if (a[5][1]+a[5][5]+a[5][2]>sum||a[2][2]+a[4][2]+a[5][2]>sum) continue;
              if (a[5][5]==1&&a[5][1]==1&&a[1][5]==3&&a[3][3]==3&&a[4][4]==3&&a[4][2]==0&&a[5][2]==3)
                    a[3][3]=3;
              for (j2=1;j2<=5;j2++)
              {
                a[5][3]=mei[j2];hang5=a[5][1]+a[5][5]+a[5][2]+a[5][3];if (hang5>sum) continue;
/*3-------*/    a[5][4]=sum-hang5;if (a[5][4]<0||a[5][4]>9||!f[a[5][1]][a[5][2]][a[5][3]][a[5][4]][a[5][5]]) continue;
                if (a[2][4]+a[4][4]+a[5][4]>sum) continue;
                for (j3=1;j3<=5;j3++)
                {
                  a[2][5]=mei[j3];
                  if (a[1][5]+a[2][5]+a[5][5]>sum||a[2][2]+a[2][4]+a[2][5]>sum) continue;
                  for (j4=1;j4<=5;j4++)
                  {
                    a[3][5]=mei[j4];lie5=a[1][5]+a[2][5]+a[5][5]+a[3][5];a[4][5]=sum-lie5;
/*4-------*/        if (a[4][5]<0||a[4][5]>9||!f[a[1][5]][a[2][5]][a[3][5]][a[4][5]][a[5][5]]) continue;
                    if (a[4][2]+a[4][4]+a[4][5]>sum) continue;
                    for (p4=1;p4<=up;p4++)
                    {
                      a[1][2]=p4;
                      lie2=a[2][2]+a[4][2]+a[5][2]+a[1][2];if (lie2>sum||a[1][1]+a[1][5]+a[1][2]>sum) continue;
/*5-------*/          a[3][2]=sum-lie2;if (a[3][2]<0||a[3][2]>9||!f[a[1][2]][a[2][2]][a[3][2]][a[4][2]][a[5][2]]) continue;
                      if (a[3][2]+a[3][3]+a[3][5]>sum) continue;
                      for (p5=1;p5<=up;p5++)
                      {
                        a[1][3]=p5;
                        hang1=a[1][1]+a[1][5]+a[1][2]+a[1][3];if (hang1>sum||a[1][3]+a[3][3]+a[5][3]>sum)continue;
/*6-------*/            a[1][4]=sum-hang1;if (a[1][4]<1||a[1][4]>9||!f[a[1][1]][a[1][2]][a[1][3]][a[1][4]][a[1][5]]) continue;
                        lie4=a[2][4]+a[4][4]+a[5][4]+a[1][4];
/*7-------*/            a[3][4]=sum-lie4;if (a[3][4]<0||a[3][4]>9||!f[a[1][4]][a[2][4]][a[3][4]][a[4][4]][a[5][4]]) continue;
                        hang3=a[3][2]+a[3][3]+a[3][5]+a[3][4];if (hang3>sum) continue;
/*8-------*/            a[3][1]=sum-hang3;if (a[3][1]<1||a[3][1]>9||!f[a[3][1]][a[3][2]][a[3][3]][a[3][4]][a[3][5]]) continue;
                        if (a[1][1]+a[3][1]+a[5][1]>sum) continue;
                        for (p6=1;p6<=up;p6++)
                        {
                          a[2][1]=p6;
                        hang2=a[2][2]+a[2][4]+a[2][5]+a[2][1];lie1=a[1][1]+a[3][1]+a[5][1]+a[2][1];if (hang2>sum||lie1>sum) continue;
/*9-------*/             a[2][3]=sum-hang2;if (a[2][3]<0||a[2][3]>9||!f[a[2][1]][a[2][2]][a[2][3]][a[2][4]][a[2][5]]) continue;
/*10------*/             a[4][1]=sum-lie1;if (a[4][1]<1||a[4][1]>9||!f[a[1][1]][a[2][1]][a[3][1]][a[4][1]][a[5][1]]) continue;
                        lie3=a[1][3]+a[3][3]+a[5][3]+a[2][3];hang4=a[4][2]+a[4][4]+a[4][5]+a[4][1];if (lie3>sum||hang4>sum) continue;
                          if (lie3!=hang4||sum-hang4<0||sum-hang4>9) continue;
                          a[4][3]=sum-hang4;
/*11-----*//*12----*/if (!f[a[1][3]][a[2][3]][a[3][3]][a[4][3]][a[5][3]]||!f[a[4][1]][a[4][2]][a[4][3]][a[4][4]][a[4][5]]) continue;
                          cnt++;
                          for (k1=1;k1<=5;k1++)
                            for (k2=1;k2<=5;k2++)
                              ans[cnt][k1][k2]=a[k1][k2];
                        }
                      }
                    }
                  }
                }
              }
            }
            }
          }
        }
      }
    }
  }
  memset(flag,0,sizeof(flag));
  for (i=1;i<=cnt;i++)                                //用n^2的标号法排序，避免交换。
  {
    for (j=1;j<=cnt;j++)
      if (!flag[j]) break;
    min=j;
    for (k=j+1;k<=cnt;k++)
      if (!flag[k]&&xiao(k,min)) min=k;
    flag[min]=true;num[min]=i;
  }
  if (cnt==0) printf("NONE");
  else
  {
  for (i=1;i<=cnt;i++)
    {
    for (j=1;j<=cnt;j++)
      if (num[j]==i) break;
    for (i2=1;i2<=5;i2++)
      {
        for (i3=1;i3<=5;i3++)
          printf("%ld",ans[j][i2][i3]);
        printf("\n");
      }
    if (i<cnt) printf("\n");
    }
  }
  return 0;
}