NOIP2009 靶形数独

---

Description

小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他们想用数独来一比高低。但普通的数独对他们来说都过于简单了，于是他们向Z博士请教，Z博士拿出了他最近发明的“靶形数独”，作为这两个孩子比试的题目。

靶形数独的方格同普通数独一样，在9格宽×9格高的大九宫格中有9个3格宽×3格高的小九宫格（用粗黑色线隔开的）。在这个大九宫格中，有一些数字是已知的，根据这些数字，利用逻辑推理，在其他的空格上填入1到9的数字。每个数字在每个小九宫格内不能重复出现，每个数字在每行、每列也不能重复出现。但靶形数独有一点和普通数独不同，即每一个方格都有一个分值，而且如同一个靶子一样，离中心越近则分值越高。

上图具体的分值分布是：最里面一格（黄色）为10分，黄色区域外面的一圈（红色）每个格子为9分，再外面一圈（蓝色）每个格子为8分，蓝色区域外面一圈（棕色）每个格子为7分，最外面一圈（白色）每个格子为6分，如上图所示。

比赛的要求是：每个人必须完成一个给定的数独（每个给定数独有可能有不同的填法），而且要争取更高的总分数。而这个总分数即每个方格上的分值和完成这个数独时填在相应格上的数字的乘积的总和。在上图这个已经填完数字的靶形数独游戏中，总分为2829。游戏规定，将以总分数的高低决出胜负。

由于求胜心切，小城找到了善于编程的你，让你帮他求出，对于给定的靶形数独，能够得到的最高分数。

Input

• 输入文件名为sudoku.in。
• 一共9行，每行9个整数（每个数都在0—9的范围内），表示一个尚未填满的数独方格，未填满的空格用“0”表示。每两个数字之间用一个空格隔开。
• 【数据范围】
  40%的数据，数独中非0数的个数不少于30。
  80%的数据，数独中非0数的个数不少于26。
  100%的数据，数独中非0数的个数不少于24。

Output

• 输出文件sudoku.out共1行。
• 输出可以得到的靶形数独的最高分数。如果这个数独无解，则输出整数-1。

Sample Input

7 0 0 9 0 0 0 0 1
1 0 0 0 0 5 9 0 0
0 0 0 2 0 0 0 8 0
0 0 5 0 2 0 0 0 3
0 0 0 0 0 0 6 4 8
4 1 3 0 0 0 0 0 0
0 0 7 0 0 2 0 9 0
2 0 1 0 6 0 8 0 4
0 8 0 5 0 4 0 1 2

0 0 0 7 0 2 4 5 3
9 0 0 0 0 8 0 0 0
7 4 0 0 0 5 0 1 0
1 9 5 0 8 0 0 0 0
0 7 0 0 0 0 0 2 5
0 3 0 5 7 9 1 0 8
0 0 0 6 0 1 0 0 0
0 6 0 9 0 0 0 0 1
0 0 0 0 0 0 0 0 6

Sample Output

2829

2852

---

首先最基本的思路肯定是每个位置依次枚举过去，我们可以将所有待处理的点全部提出来，方便在深搜过程中的维护，同时也可以按照可能性的大小，先枚举可选项少的，再枚举可选项多的。也是符合我们一般完成sudoku的做法。那么同理，在预处理的部分有下面这个剪枝：

• 将一开始给出的局面上所有已经可以唯一确定的空格填上数字。

接下来考虑深搜时的问题。为了便于维护该行，该列，该块内还剩下的可能性，我们定义$row,col,grid$三个数组来表示当前的填数情况。同N皇后问题的解法类似，每次通过回溯撤销之前的决定。还有统计分数的时候：

• 在递归过程中顺便统计分数而不要最后一次性统计。

写到这一步就已经能过很高的分数了，如果再加上譬如if(times>=15000000)return;这样恶心的卡时间代码说不定就可以Ac了。

---

正解算法应该是采用二进制枚举优化。

我们可以用二进制操作减少那些不必要的for枚举，上述的三个数组中分别存储对应某部分1~9有无填入的一段二进制即可。接下来处理的时候我们一行一行地枚举，因为有了二进制操作后可以直接跳过那些已经确定的位置。

有一个比较巨大的常数优化是预先处理出所有$Log2[1<<i]$值，因为系统的log()计算非常慢。

#include<cstdio>
#include<cstring>
#include<cmath>
int target[10][10]={
{6,6,6,6,6,6,6,6,6},
{6,7,7,7,7,7,7,7,6},
{6,7,8,8,8,8,8,7,6},
{6,7,8,9,9,9,8,7,6},
{6,7,8,9,10,9,8,7,6},
{6,7,8,9,9,9,8,7,6},
{6,7,8,8,8,8,8,7,6},
{6,7,7,7,7,7,7,7,6},
{6,6,6,6,6,6,6,6,6}};
int sudoku[10][10];
int Log2[1<<10],row[10],col[10],grid[10],Line[10],h[10],st[10];
bool flag=0;
int Maxsum=0;
const int Allset=(1<<9)-1;
void init(){for(int i=0;i<10;i++)Log2[1<<i]=i;}
void swap(int &a,int &b){a^=b,b^=a,a^=b;}
void lowbit(int x){return x&(-x);}
void add(int x,int y,int pos,int p){row[x]|=p,col[y]|=p,grid[pos]|=p;}
void del(int x,int y,int pos,int p){row[x]-=p,col[y]-=p,grid[pos]-=p;}
void dfs(int c,int sum){
    if(c==9){
        if(Maxsum<sum)Maxsum=sum;
        flag=true;return;
    }
    int x=st[c],setx=Allset-Line[x];//第st[c]行，以及该行目前未填的状态
    if(!setx){dfs(c+1,sum);return;}
    int sety=lowbit(setx),y=Log2[sety];//第y列
    Line[x]|=sety;
    int pos=x/3*3+y/3;
    int num=Allset-(row[x]|col[y]|grid[pos]);
    while(num){
        int p=lowbit(num);
        num-=p;
        sudoku[x][y]=Log2[p]+1;
        add(x,y,pos,p);

        if(setx==sety)dfs(c+1,sum+sudoku[x][y]*target[x][y]);
        else dfs(c,sum+sudoku[x][y]*target[x][y]);

        sudoku[x][y]=0; 
        del(x,y,pos,p);
    }
    Line[x]-=sety;
}
int main(){
    init();
    for(int i=0;i<9;i++)
        for(int j=0;j<9;j++){
            scanf("%d",&sudoku[i][j]);
            if(sudoku[i][j]){
                int num=sudoku[i][j];
                int pos=i/3*3+j/3;//所在块的编号
                add(i,j,pos,1<<num-1);
                Line[i]|=1<<j;
                Maxsum+=num*target[i][j];
            }
        }
    for(int i=0;i<9;i++)
        for(int j=0;j<9;j++)
            if(!sudoku[i][j]){//将可以唯一确定的位置处理出来
                int pos=i/3*3+j/3;
                int num=Allset-(row[i]|col[j]|grid[pos]);
                int cnt=0,tot=0,p=0;
                while(num){
                    p=lowbit(num);
                    num-=p;cnt++;
                    tot=Log2[p];
                }
                if(cnt==1){
                    sudoku[i][j]=tot+1;
                    add(i,j,pos,1<<tot);
                    Line[i]|=1<<j;
                    Maxsum+=sudoku[i][j]*target[i][j];
                }else h[i]++;
            }
    for(int i=0;i<9;i++)st[i]=i;
    for(int i=0;i<8;i++)
        for(int j=i+1;j<9;j++)//按照该行还剩下多少元素进行排序
            if(h[st[i]]>h[st[j]])swap(st[i],st[j]);
    dfs(0,Maxsum);
    if(flag)printf("%d\n",Maxsum);
    else puts("-1");
    return 0;
}

---

还有Dancing Link X的算法，但是现在学没什么用处。以后再待添加。