hdu 3476

The puzzle game of Sudoku is played on a board of N^2 × N^2 cells. The cells are grouped in N × N squares of N × N cells each. Each cell is either empty or contains a number between 1 and N^2.

The Sudoku position is correct when numbers in each row, each column and each square are different. The goal of the game is, starting from some correct positions; fill all empty cells so that the final position is still correct. (We call the final position is a solution to the starting position).

This problem is not about to solve a specific Sudoku puzzle, but ask you to find all correct positions that have a unique solution when N = 2.

There's no input for this problem.

Output x on a single line where x is the number of correct positions have a unique solution when N = 2.

Hint
The Sudoku description is quoted from problem "Sudoku Checker", Northeastern Europe 2005
这是一个数独题目，大概有两步骤
1） 求得 N=2 的 288个解
2） 判断每一个解 添加空格后 独一无二的解的个数 ，算总和
/*
#include <iostream>
using namespace std;
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
const int N=2;
typedef struct Node
{
    int num; // be chosen
    bool used[N*N+1];
    Node()
    {
        num=0;
        for(int i=1;i<=N*N;i++)
           used[i]=false;
    }
}node;
node map[N*N+1][N*N+1];
int result[300][N*N+1][N*N+1];
//// 存储 288 个解的矩阵的数组
int ans;

bool legal(int i,int j,int k)
{
    bool flag=false;
    //// 判断这一行合法
    for(int col=1;col<=j-1;col++)
        if(k==map[i][col].num) { flag=true;break;}
    ////判断这一列合法
    for(int row=1;row<=i-1;row++)
        if(k==map[row][j].num)  {flag=true;break;}
    int x,y;
    x=i;
    while(x%N!=1) x--;
    y=j;
    while(y%N!=1) y--;
    int ii,jj;
    ///判断所处小正方形合法
    for(ii=x;ii<i;ii++)
    {
        for(jj=y;jj<=y-1+N;jj++)
        {         
            if(map[ii][jj].num==k)
                return true;
        }
    }
  for(jj=y;jj<j;jj++)
     if(map[i][jj].num==k)
         return true;
    return flag;
}
void dfs(int i,int j)
{
    if(i==N*N+1)
    {
        ans++;
        for(int ii=1;ii<=N*N;ii++)
        {
           for(int jj=1;jj<=N*N;jj++)
            {
                result[ans][ii][jj]=map[ii][jj].num;
           //     cout<<map[ii][jj].num<<" ";
            }
             //       cout<<endl;
        }
        //cout<<endl;
       
        return ;
    }
    for(int k=1;k<=N*N;k++)
    {
        if(!map[i][j].used[k]&&!legal(i,j,k)) // row i ,col j ,kth number
        {
            map[i][j].num=k;
            map[i][j].used[k]=true;
            if(j+1>N*N)
                dfs(i+1,1);
            else
                dfs(i,j+1);
            /////从 1,1 开始，到 n+1,1判断结束
            ///当 j+1>N*N时，“拐弯”
            map[i][j].num=0;
            map[i][j].used[k]=false;
        }
    }
}
int main()
{
    freopen("cmp","w",stdout);
    time_t begin=clock(),end;
    dfs(1,1);
    cout<<ans<<endl;
    
    /////求解完成
    int re[300];
    bool rr[300];
    __int64 ad=0;
   for(int i=0;i<(1<<16);i++)
    ///借助2进制，0表示空格，1表示有数字
    {
        for(int j=1;j<=ans;j++)
        /// 288个矩阵
        {
            re[j]=0;
            ///相应于每一个i值的 jth矩阵 对于的值
            for(int k=0;k<16;k++)
            {
                int x=k/4+1,y=k%4+1;
                re[j]*=7;
                /// 这样的话，即使是一样的数字，但是位置不一样的话，re[j]也不一样
                if((1<<k)&i)
                    re[j]+=result[j][x][y];
            }
        }
        sort(re+1,re+1+ans);
   
        memset(rr,true,sizeof(rr));
        for(int j=2;j<=ans;j++)
            if(re[j]==re[j-1])
                rr[j]=rr[j-1]=false;
        for(int j=1;j<=ans;j++)
            ad+=rr[j];
    }
    cout<<ad<<endl;
    end=clock()-begin;
    printf("%d ms/n",end);
    return 1;
}
*/
#include <iostream>
using namespace std;
int main()
{
    cout<<"13579680"<<endl;
    return 1;
}