素数方阵

这是一道极度毒瘤的搜索题，考验代码能力，也考验耐心。

步入正题。这题题面说了，给出素数的各个数位上的和，要求所有素数的各个位数上的和必须相等，这对优化后来的搜索有极大帮助。第二个题面给出了左上角的数，又减少了一定的搜索量。

这题要求每行，每列，以及两条对角线上的数字得要是是五位的素数。（就是大于等于10000小于等于99999的素数）对于这个我们可以先用埃拉托色尼斯筛将10000到99999的所有素数找出来并记录。（线性筛也行，但影响不大，就90000个数）

老刘给的搜索顺序，写13重循环，但是我偏不。
我要这么搜

这题还有个比较毒瘤的是要求“按照这25个数字组成的25位数的大小排序”

从小到大排很简单，sort一下就好。

但是，显然用long long也存不下，这时就该派字符串上场了。我的方法是写了个函数，枚举25个点，将这25个点变为一个字符串。输出时注意一下换行就好了。

对于验证每一行的数是否是素数，我写了个检验函数，先将五个数字变为5位数，如果一开始筛完后那个数为素数就是true，否则就是false。

在13个for循环中还有很多优化，比如剩下的那个数如果小于0或者大于9就continue。

复杂点的是首位数字还有要加判断。

///                   _ooOoo_
///                  o8888888o
///                  88" . "88
///                  (| -_- |)
///                  O\  =  /O
///               ____/`---'\____
///             .'  \\|     |//  `.
///            /  \\|||  :  |||//  \
///           /  _||||| -:- |||||-  \
///           |   | \\\  -  /// |   |
///           | \_|  ''\---/''  |   |
///           \  .-\__  `-`  ___/-. /
///         ___`. .'  /--.--\  `. . __
///      ."" '<  `.___\_<|>_/___.'  >'"".
///     | | :  `- \`.;`\ _ /`;.`/ - ` : | |
///     \  \ `-.   \_ __\ /__ _/   .-` /  /
///======`-.____`-.___\_____/___.-`____.-'======
///                   `=---='
///^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#include<bits/stdc++.h>
using namespace std;
#define f(a,b,c) for(int c=a;c<=b;c++)
#define so1(a,n,mycmp) sort(a+1,a+n+1,mycmp);
#define so2(a,n) sort(a+1,a+n+1);
#define ll long long
#define in cin
#define out cout
const int twx=100000+100;
int a11,tot;
int m=0;
int asd=0;
int f[6][6],last[5]={
   
   0,1,3,7,9},num=0;
string ans[twx];
bool check[twx];
bool dfg(int a,int b,int c,int d,int e)
{
   
   
    int asd=a*10000+b*1000+c*100+d*10+e;	
    if(check[asd]) 
    {
   
   
        return true;
    }
    else 
    {
   
   
        return false;
    }
}
void primes()
{
   
   
    memset(check,true,sizeof(check));
    f(2,100000,i)
    {
   
   
        if(check[i])
        {
   
   
            f(i,100000/i,j)
            {
   
   
                check[i*j]=false;
            }
        }
    }
    return ;
    /*f(2,n,i)
    {
        if(v[i]==0)
        {
            v[i]=i;
            prime[++m]=i;
        }
        f(1,m,j)
        {
            if(prime[j]>v[i]||prime[j]>n/i)
            {
                break;
            }
            v[i*prime[j]]=prime[j];
        }
    }*/
    /*f(1,m,i)
    {
        out<<prime[i]<<" ";
    }*/
}
void init()
{
   
   
	in>>tot>>a11;
}
void ghj()
{
   
   	
    num++;
    f(1,5,i)
    {
   
   
        f(1,5,j)
        {
   
   
            ans[num]+=f[i][j]+48;
        }
    }
    return ;
}
void work()
{
   
   
    f(1,4,A)//f[5][5]   剪枝 
    {
   
   	
        f[5][5]=last[A];
        f(0,9,B)//f[4][4]	
        {
   
   
            f[4][4]=B;
            f(0,9,C)//f[3][3]
            {
   
   
                f[3][3]=C;
   	            f[2][2]=tot-f[1][1]-f[3][3]-f[4][4]-f[5][5];//f[2][2]可得出
                if(f[2][2]<0) 
                {
   
   
                    break;
                }
                if