USACO 4.3.2 prime3

题目：

http://ace.delos.com/usacoprob2?a=0H14tt2CoyP&S=prime3

http://pingce.ayyz.cn:9000/usaco/data/20110129214306/index.html#Section_5.1

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

题解：
　　看着很和谐的搜索题又来了一道，但是这道题却也是最恶心的一道………………

　　首先把所有可能素数处理出来这是没说的，然后就开始搜索了………………网上MS有14重循环结束战斗的…………………………我觉得太可怕便换了种写法。

　　考虑以下将情况：

　　abcde
　　f      g
　　h      i
　　j      k
　　lmnop

　　则有b,c,d,e,f,h,j,l!=0 l,m,n,o,p,e,g,i,k!=0,2,4,5,6,8，而它们共同形成了四个质数，于是我们便可以把除首位外没有偶数的质数，和每一位均不为0,2,4,5,6,8的质数处理出来，这样就可以把周围一层的四个质数全部处理出来，于是只剩下了中间的3*3de方阵。

　　abc
　　def
　　ghi

　　此时枚举a,b，然后c就出来了，然后通过解六元六次方程便可以把剩下的数全部解出来了。

/*
ID:zhongha1
PROB:prime3
LANG:C++
*/

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>

using namespace std;

int n,sum,l1,l2,l3,prime1[100000],prime2[100000],prime3[100000],map[6][6],ansl;

bool first=true,able[20][20];

struct node
{
    node *next[10];
    node()
    {
        for (int a=0;a<=9;a++)
            next[a]=NULL;
    }
}*root;

struct ans_node
{
    int map[6][6];
    void print()
    {
        if (!first) printf("\n");
        first=false;
        for (int a=1;a<=5;a++)
        {
            for (int b=1;b<=5;b++)
                printf("%d",map[a][b]);
            printf("\n");
        }
    }
    bool operator<(const ans_node &c)const
    {
        for (int a=1;a<=5;a++)
            for (int b=1;b<=5;b++)
                if (map[a][b]!=c.map[a][b]) return map[a][b]<c.map[a][b];
        return false;
    }
}ans[10000];

bool prime(int now)
{
    int orz=now,nowsum=0;
    while (orz)
    {
        nowsum+=orz % 10;
        orz/=10;
    }
    if (nowsum!=sum) return false;
    for (int a=2;a*a<=now;a++)
        if (now % a==0) return false;
    able[now / 10000][now % 10]=true;
    return true;
}

void check1(int now)
{
    l1++;
    prime1[l1]=now;
    int orz=0;
    while (now)
    {
        orz=orz*10+now % 10;
        now/=10;
    }
    /*for (int a=1;a<=5;a++)
    {
        int hehe=orz % 10;
        if (p->next[hehe]==NULL) p->next[hehe]=new node;
        p=p->next[hehe];
        orz/=10;
    }*/
}

void check2(int now)
{
    if (now / 10000!=n) return;
    int l=0,r=l1;
    while (l+1!=r)
    {
        int m=(l+r)>>1;
        if (prime1[m]>=now) r=m;
        else l=m;
    }
    if (prime1[r]!=now) return;
    l2++;
    prime2[l2]=now;
}

void check3(int now)
{
    int orz=now;
    while (orz)
    {
        int hehe=orz % 10;
        if (hehe % 2==0 || hehe==5) return;
        orz/=10;
    }
    l3++;
    prime3[l3]=now;
}

bool check4(int a,int b,int c)
{
    if (b % 10!=c / 10000) return false;
    for (int d=1;d<=5;d++)
    {
        if (!able[a % 10][c % 10]) return false;
        a/=10;
        c/=10;
    }
    return true;
}

void fill(int a,int b,int c,int d)
{
    for (int e=1;e<=5;e++)
    {
        map[1][6-e]=a % 10;
        a/=10;
    }
    for (int e=1;e<=5;e++)
    {
        map[6-e][1]=b % 10;
        b/=10;
    }
    for (int e=1;e<=5;e++)
    {
        map[5][6-e]=c % 10;
        c/=10;
    }
    for (int e=1;e<=5;e++)
    {
        map[6-e][5]=d % 10;
        d/=10;
    }
}

bool exist(int now)
{
    int l=0,r=l1;
    while (l+1!=r)
    {
        int m=(l+r)>>1;
        if (prime1[m]>=now) r=m;
        else l=m;
    }
    if (prime1[r]!=now) return false;
    else return true;
}

bool check_map()
{
    for (int a=1;a<=5;a++)
        for (int b=1;b<=5;b++)
            if (map[a][b]<0 || map[a][b]>9) return false;
    for (int a=1;a<=5;a++)
    {
        int now=0;
        for (int b=1;b<=5;b++)
            now=now*10+map[a][b];
        if (!exist(now)) return false;
    }
    for (int a=1;a<=5;a++)
    {
        int now=0;
        for (int b=1;b<=5;b++)
            now=now*10+map[b][a];
        if (!exist(now)) return false;
    }
    int now=0;
    for (int a=1;a<=5;a++)
        now=now*10+map[a][a];
    if (!exist(now)) return false;
    now=0;
    for (int a=1;a<=5;a++)
        now=now*10+map[6-a][a];
    if (!exist(now)) return false;
    return true;
}

void get_add_ans()
{
    ansl++;
    for (int a=1;a<=5;a++)
        for (int b=1;b<=5;b++)
            ans[ansl].map[a][b]=map[a][b];
}

int main()
{
    freopen("prime3.in","r",stdin);
    freopen("prime3.out","w",stdout);

    scanf("%d%d",&sum,&n);
    root=new node;
    for (int a=10000;a<100000;a++)
        if (prime(a))
        {
            check1(a);
            check3(a);
        }
    for (int a=1;a<=l1;a++)
        check2(prime1[a]);
    for (int a=1;a<=l2;a++)
        for (int b=1;b<=l2;b++)
            if (able[prime2[b] % 10][prime2[a] % 10])
            {
                for (int c=1;c<=l3;c++)
                    if (able[n][prime3[c] % 10] && check4(prime2[a],prime2[b],prime3[c]))
                    {
                        for (int d=1;d<=l3;d++)
                            if (prime3[d] % 10==prime3[c] % 10 && check4(prime2[b],prime2[a],prime3[d]))
                            {
                                fill(prime2[a],prime2[b],prime3[c],prime3[d]);
                                for (map[2][2]=0;map[2][2]<=9;map[2][2]++)
                                    for (map[3][2]=0;map[3][2]<=9;map[3][2]++)
                                    {
                                        map[4][2]=sum-map[1][2]-map[2][2]-map[3][2]-map[5][2];
                                        int now=0;
                                        for (int a=1;a<=5;a++)
                                            now=now*10+map[a][2];
                                        if (!exist(now)) continue;
                                        now=(sum-map[2][1]-map[2][2]-map[2][5])+2*(sum-map[3][1]-map[3][2]-map[3][5])+(sum-map[4][1]-map[4][2]-map[4][5])+(sum-map[5][1]-map[4][2]-map[1][5])+(sum-map[1][1]-map[2][2]-map[5][5])-(sum-map[1][3]-map[5][3])-2*(sum-map[1][4]-map[5][4]);
                                        if (now % 3!=0) continue;
                                        map[3][3]=now / 3;
                                        map[4][4]=sum-map[1][1]-map[2][2]-map[3][3]-map[5][5];
                                        map[4][3]=sum-map[4][1]-map[4][2]-map[4][4]-map[4][5];
                                        map[2][3]=sum-map[1][3]-map[3][3]-map[4][3]-map[5][3];
                                        map[3][4]=sum-map[3][1]-map[3][2]-map[3][3]-map[3][5];
                                        map[2][4]=sum-map[2][1]-map[2][2]-map[2][3]-map[2][5];
                                        if (check_map()) get_add_ans();
                                    }
                            }
                    }
            }
    sort(ans+1,ans+ansl+1);
    for (int a=1;a<=ansl;a++)
        ans[a].print();

    return 0;
}