DFS神题——jzyzoj1188：素数方阵

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

　　这是一道真的神题，下面给出题面：

　　

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

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

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

　　以下是需要注意的几点：

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

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

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

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

　　代码如下：

　　

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<string>
#include<algorithm>
using namespace std;
const int MAX=100000;
int row[6],column[6],diagonal1=0,diagonal2=0,a[6][6],num[5]={0,1,3,7,9},n,len=0;
bool f[200000];
string s[100001];
void primenumber()//筛法求质数
{
    bool flag[MAX];
    memset(flag,false,sizeof(flag));
    for (int i=2; i<MAX; i+=2)
    {
        flag[i]=true;
    }
    for (int i=3; i<MAX; i+=2)
    {
        if (!flag[i]) 
        {
            f[i]=true;
            for (int j=i; j<MAX; j+=i)
                flag[j]=true;
        }
    }
}
void dfs (int p)
{
    if (p==25) 
    {
        len++;
        for (int i=1; i<=5; i++)
            for (int j=1; j<=5; j++)
                s[len]=s[len]+char(a[i][j]+'0');
    }
    else if (p<5||(p>5&&p<9))
    {
        for (int i=1;i<5;i++)
        {
            if (p==1) 
            {
                if (row[1]+num[i]>n||column[5]+num[i]>n||diagonal2+num[i]>n) 
                    return;
                row[1]+=num[i];    column[5]+=num[i];    diagonal2+=num[i];
                a[1][5]=num[i];
                dfs(p+1);
                row[1]-=num[i];    column[5]-=num[i];    diagonal2-=num[i];
            }
            else if (p>1&&p<5)
            {
                if (row[p]+num[i]>n||column[5]+num[i]>n) 
                    return;
                row[p]+=num[i];    column[5]+=num[i];
                a[p][5]=num[i];
                dfs(p+1);
                row[p]-=num[i];    column[5]-=num[i];
            }
            else if (p==6)
            {
                if (row[5]+num[i]>n||column[1]+num[i]>n||diagonal2+num[i]>n) 
                    return;
                row[5]+=num[i];    column[1]+=num[i];    diagonal2+=num[i];
                a[5][1]=num[i];
                dfs(p+1);
                row[5]-=num[i];    column[1]-=num[i];    diagonal2-=num[i];
            }
            else 
            {
                if (row[5]+num[i]>n||column[p-5]+num[i]>n) 
                    return;
                row[5]+=num[i];    column[p-5]+=num[i];
                a[5][p-5]=num[i];
                dfs(p+1);
                row[5]-=num[i];    column[p-5]-=num[i];
            }
        }
    }
    else if (p==5)
    {
        int i=n-column[5];
        if (!f[a[1][5]*10000+a[2][5]*1000+a[3][5]*100+a[4][5]*10+i]||
                row[5]+i>n||diagonal1+i>n||i>9) 
            return;
        a[5][5]=i;
        row[5]+=i;    diagonal1+=i;    column[5]+=i;
        dfs(p+1);
        row[5]-=i;    diagonal1-=i;    column[5]-=i;
    }
    else if (p==9)
    {
        int i=n-row[5];
        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) 
        {
            return;
        }
        a[5][4]=i;
        column[4]+=i;    row[5]+=i;
        dfs(p+1);
        column[4]-=i;    row[5]-=i;
    }
    else if (p==10)
    {
        for (int i=0; i<10; i++)
        {
            if (i+column[3]>n||i+row[3]>n||i+diagonal1>n||i+diagonal2>n)
                return;
            a[3][3]=i;
            column[3]+=i;    row[3]+=i;    diagonal1+=i;    diagonal2+=i;
            dfs(p+1);
            column[3]-=i;    row[3]-=i;    diagonal1-=i;    diagonal2-=i;
        }
    }
    else if (p==11)
    {
        for (int i=0; i<10; i++)
        {
            if (i+column[2]>n||i+row[2]>n||i+diagonal1>n) 
                return;
            a[2][2]=i;
            column[2]+=i;row[2]+=i; diagonal1+=i;
            dfs(p+1);
            column[2]-=i;row[2]-=i; diagonal1-=i;
        }
    }
    else if (p==12)
    {
        int i=n-diagonal1;
        if (!f[a[1][1]*10000+a[2][2]*1000+a[3][3]*100+i*10+a[5][5]]||
                row[4]+i>n||column[4]+i>n||i>9)
            return;
        a[4][4]=i;
        row[4]+=i;    column[4]+=i;    diagonal1+=i;
        dfs(p+1);
        row[4]-=i;    column[4]-=i;    diagonal1-=i;
    }
    else if (p==13)
    {
        for (int i=0; i<10; i++)
        {
            if (i+column[4]>n||i+row[2]>n||i+diagonal2>n)
                return;
            a[2][4]=i;
            column[4]+=i;    row[2]+=i;    diagonal2+=i;
            dfs(p+1);
            column[4]-=i;    row[2]-=i;    diagonal2-=i;
        }
    }
    else if (p==14)
    {
        int i=n-diagonal2;
        if (!f[a[5][1]*10000+i*1000+a[3][3]*100+a[2][4]*10+a[1][5]]||
                i+row[4]>n||i+column[2]>n||i>9)
            return;
        a[4][2]=i;
        diagonal2+=i;    row[4]+=i;    column[2]+=i;
        dfs(p+1);
        diagonal2-=i;    row[4]-=i;    column[2]-=i;
    }
    else if (p==15)
    {
        for (int i=1; i<10; i++)
        {
            if (i+column[2]>n||i+row[1]>n) 
                return;
            a[1][2]=i;
            column[2]+=i;    row[1]+=i;
            dfs(p+1);
            column[2]-=i;    row[1]-=i;
        }
    }
    else if (p==16)
    {
        int i=n-column[2];
        if (!f[a[1][2]*10000+a[2][2]*1000+i*100+a[4][2]*10+a[5][2]]||
                row[3]+i>n||i>9) 
            return;
        a[3][2]=i;
        column[2]+=i;    row[3]+=i;
        dfs(p+1);
        column[2]-=i;    row[3]-=i;
    }
    else if (p==17)
    {
        for (int i=1; i<10; i++)
        {
            if (i+row[1]>n||i+column[4]>n)
                return;
            a[1][4]=i;
            row[1]+=i;    column[4]+=i;
            dfs(p+1);
            row[1]-=i;    column[4]-=i;
        }
    }
    else if (p==18)
    {
        int i=n-column[4];
        if (!f[a[1][4]*10000+a[2][4]*1000+i*100+a[4][4]*10+a[5][4]]||
                row[3]+i>n||i>9)
            return;
        a[3][4]=i;
        row[3]+=i;    column[4]+=i;
        dfs(p+1);
        row[3]-=i;    column[4]-=i;
    }
    else if (p==19)
    {
        int i=n-row[3];
        if (!f[i*10000+a[3][2]*1000+a[3][3]*100+a[3][4]*10+a[3][5]]||
                column[1]+i>n||i==0||i>9)
            return;
        a[3][1]=i;
        row[3]+=i;    column[1]+=i;
        dfs(p+1);
        row[3]-=i;    column[1]-=i;
    }
    else if (p==21)
    {
        for (int i=1; i<10; i++)
        {
            if (i+row[2]>n||i+column[1]>n||i==0||i>9)
                return;
            a[2][1]=i;
            row[2]+=i;    column[1]+=i;
            dfs(p+1);
            row[2]-=i;    column[1]-=i;
        }
    }
    else if (p==23)
    {
        int i=n-column[1];
        if (!f[a[1][1]*10000+a[2][1]*1000+a[3][1]*100+i*10+a[5][1]]||
                i+row[4]>n||i==0||i>9)
            return;
        a[4][1]=i;
        row[4]+=i;    column[1]+=i;
        dfs(p+1);
        row[4]-=i;    column[1]-=i;
    }
    else if (p==24)
    {
        int i=n-row[4];
        if (!f[a[4][1]*10000+a[4][2]*1000+i*100+a[4][4]*10+a[4][5]]||
                !f[a[1][3]*10000+a[2][3]*1000+a[3][3]*100+i*10+a[5][3]]||
                column[3]!=row[4]||i>9)
            return;
        a[4][3]=i;
        row[4]+=i;    column[3]+=i;
        dfs(p+1);
        row[4]-=i;    column[3]-=i;
    }
    else if (p==22)
    {
        int i=n-row[2];
        if (!f[a[2][1]*10000+a[2][2]*1000+i*100+a[2][4]*10+a[2][5]]||
                i+row[2]>n||i>9)
            return;
        a[2][3]=i;
        row[2]+=i;    column[3]+=i;
        dfs(p+1);
        row[2]-=i;    column[3]-=i;
    }
    else if (p==20)
    {
        int i=n-row[1];
        if (!f[a[1][1]*10000+a[1][2]*1000+i*100+a[1][4]*10+a[1][5]]||
                column[3]+i>n||i>9||i==0)
            return;
        a[1][3]=i;
        row[1]+=i;    column[3]+=i;
        dfs(p+1);
        row[1]-=i;    column[3]-=i;
    }
}
int main()
{
    freopen("add.in","r",stdin);
    freopen("add.out","w",stdout);
    memset(row,0,sizeof(row));
    memset(column,0,sizeof(column));
    memset(f,false,sizeof(f));
    scanf("%d%d",&n,&a[1][1]);
    row[1]=a[1][1];    column[1]=a[1][1];    diagonal1=a[1][1];
    primenumber();
    dfs(1);
    sort(s+1,s+1+len);
    for (int k=1;k<=len;k++)
    {
        
        for (int i=0;i<5;i++)
        {
            for (int j=0;j<5;j++)
                cout<<s[k][i*5+j];
            cout<<endl;
        }
        if (k<len)
            cout<<endl;
    }
    return 0;
}

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