洛谷 P1074 靶形数独

题目描述

小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他

们想用数独来一比高低。但普通的数独对他们来说都过于简单了，于是他们向 Z 博士请教，

Z 博士拿出了他最近发明的“靶形数独”，作为这两个孩子比试的题目。

靶形数独的方格同普通数独一样，在 9 格宽×9 格高的大九宫格中有 9 个 3 格宽×3 格

高的小九宫格（用粗黑色线隔开的）。在这个大九宫格中，有一些数字是已知的，根据这些数字，利用逻辑推理，在其他的空格上填入 1 到 9 的数字。每个数字在每个小九宫格内不能

重复出现，每个数字在每行、每列也不能重复出现。但靶形数独有一点和普通数独不同，即

每一个方格都有一个分值，而且如同一个靶子一样，离中心越近则分值越高。（如图）

上图具体的分值分布是：最里面一格（黄色区域）为 10 分，黄色区域外面的一圈（红

色区域）每个格子为 9 分，再外面一圈（蓝色区域）每个格子为 8 分，蓝色区域外面一圈（棕

色区域）每个格子为 7 分，最外面一圈（白色区域）每个格子为 6 分，如上图所示。比赛的

要求是：每个人必须完成一个给定的数独（每个给定数独可能有不同的填法），而且要争取

更高的总分数。而这个总分数即每个方格上的分值和完成这个数独时填在相应格上的数字

的乘积的总和

总分数即每个方格上的分值和完成这个数独时填在相应格上的数字

的乘积的总和。如图，在以下的这个已经填完数字的靶形数独游戏中，总分数为 2829。游戏规定，将以总分数的高低决出胜负。

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

够得到的最高分数。

输入输出格式

输入格式：

一共 9 行。每行 9 个整数（每个数都在 0―9 的范围内），表示一个尚未填满的数独方

格，未填的空格用“0”表示。每两个数字之间用一个空格隔开。

输出格式：

输出文件 sudoku.out 共 1 行。

输出可以得到的靶形数独的最高分数。如果这个数独无解，则输出整数-1。

输入输出样例

输入样例#1：

sudoku1
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

sudoku2
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

输出样例#1：

sudoku1
2829

sudoku2
2852

有几个点可以优化：

1、打表，预先将每个格子对应的分数，和每个格子属于哪个小九宫格，输出到两个二维数组中，后面就可以直接用了。

2、在生成解答树的过程中，越靠近根的位置分支数越少越好，及 dfs 时，优先选择可选数字少的格子。

3、用二进制表示一个集合，确定一个状态，这个状态中有多少个可选的数字，将其直接用数组存起来，在更新每个格子可选择的数字的数量时，就可以不用算了。

4、用 vector 会超时，自己写个数组。

代码：

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

#define getI(i, j) (i-1)/3*3 + (j-1)/3 + 1

const int MAX = 12;

struct Node{
    int x, y, num;
    Node(){}
    Node(int nx, int ny, int nn) : x(nx), y(ny), num(nn){}
};

int visr[MAX], visc[MAX], visn[MAX];    //行、列、小九宫格
int G[MAX][MAX];            //图 
int level[MAX][MAX];         //每个格子所对应的分数 
int geti[MAX][MAX];            // (x, y) 坐标在哪个小九宫格里面 
int getNum[(1<<12)];        //获得这个状态下，可选择数字的数量 
Node node[200];                //可以放数字的格子
int len;                    //可以放数字的格子的数量 
int ans;

void dfs(int i, int sum);    //深搜（构造解答树） 
bool cmp(Node a, Node b){
    return a.num < b.num;
}

int main(){
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
    
    //打表，算出每个格子对应的分数和其所在的小九宫格。 
    for(int i=1; i<=9; i++){
        for(int j=1; j<=9; j++){
            if(i >= 5 && i <= 5 && j >= 5 && j <= 5){
                level[i][j] = 10;
            }else if(i >= 4 && i <= 6 && j >= 4 && j <= 6){
                level[i][j] = 9;
            }else if(i >= 3 && i <= 7 && j >= 3 && j <= 7){
                level[i][j] = 8;
            }else if(i >= 2 && i <= 8 && j >= 2 && j <= 8){
                level[i][j] = 7;
            }else{
                level[i][j] = 6;
            }
        }
    }
    for(int i=1; i<=9; i++){
        for(int j=1; j<=9; j++){
            geti[i][j] = getI(i, j);
        }
    }
    
    //输入 
    memset(visr, 0, sizeof(visr));
    memset(visc, 0, sizeof(visc));
    memset(visn, 0, sizeof(visn));
    int sum = 0;
    for(int i=1; i<=9; i++){
        for(int j=1; j<=9; j++){
            cin >> G[i][j];
            if(G[i][j] != 0){
                int t = G[i][j];
                visr[i] = (visr[i] | (1<<t));
                visc[j] = (visc[j] | (1<<t));
                visn[geti[i][j]] = (visn[geti[i][j]] | (1<<t));
                sum += G[i][j] * level[i][j];
            }
        }
    }
    
    //每种状态对应的可选择的数字的数量
    for(int i=0; i<(1<<11); i++){
        int tot = 0;
        for(int j=1; j<=9; j++){
            if(!((1<<j) & i))
                tot++;
        }
        getNum[i] = tot;
    } 
    
    //找出可以放数字的点
    len = 0; 
    for(int i=1; i<=9; i++){
        for(int j=1; j<=9; j++){
            if(G[i][j] == 0){
                int num = 0;
                for(int k=1; k<=9; k++){
                    if((visr[i] & (1<<k)) || (visc[j] & (1<<k)) || (visn[geti[i][j]] & (1<<k)))
                        continue;
                    num++;
                }
                node[len].x = i;
                node[len].y = j;
                node[len].num = num;
                len++;
            }
        }
    }
    
    //按照可以放的数字的数量从小到大排序（越靠近根结点的地方，分支越少，可以剪很多枝） 
    sort(node, node + len, cmp);
    
    ans = -1;
    dfs(0, sum);
    cout << ans;
    
    return 0;
}

void dfs(int i, int sum){
    if(i >= len){            //已经找到填数的一种方法 
        ans = max(ans, sum);
        return ;
    }
    
    int x = node[i].x;        //转化成 x y 坐标 
    int y = node[i].y;
    
    //开始枚举
    for(int j=1; j<=9; j++){
        if((visr[x] & (1<<j)) || (visc[y] & (1<<j)) || (visn[geti[x][y]] & (1<<j)))
            continue;
        //标记这一行、这一列、这一小九宫格中，j 数字放过了 
        visr[x] = (visr[x] | (1<<j));
        visc[y] = (visc[y] | (1<<j));
        visn[geti[x][y]] = (visn[geti[x][y]] | (1<<j));
        G[x][y] = j;
        
        //对于后面的结点，其可以放的数字的数量可能会改变，进行更新 
        for(int k=i+1; k<len; k++){
            int r = node[k].x, c = node[k].y;
            int t = (visr[r] | visc[c] | visn[geti[r][c]]);
            node[k].num = getNum[t];
        }
        sort(node + i + 1, node + len, cmp);
        
        //枚举下一个位置 
        dfs(i + 1, sum + level[x][y]*j);
        
        //收回标记 
        visr[x] = (visr[x] ^ (1<<j));
        visc[y] = (visc[y] ^ (1<<j));
        visn[geti[x][y]] = (visn[geti[x][y]] ^ (1<<j));
    } 
}