题解：洛谷 P1074 [NOIP 2009 提高组] 靶形数独

【题目来源】

洛谷：[P1074 NOIP 2009 提高组] 靶形数独 - 洛谷

【题目描述】

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

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

上图具体的分值分布是：最里面一格（黄色区域）为 10 分，黄色区域外面的一圈（红色区域）每个格子为 9 分，再外面一圈（蓝色区域）每个格子为 8 分，蓝色区域外面一圈（棕色区域）每个格子为 7 分，最外面一圈（白色区域）每个格子为 6 分，如上图所示。比赛的要求是：每个人必须完成一个给定的数独（每个给定数独可能有不同的填法），而且要争取更高的总分数。而这个总分数即每个方格上的分值和完成这个数独时填在相应格上的数字的乘积的总和

总分数即每个方格上的分值和完成这个数独时填在相应格上的数字的乘积的总和。如图，在以下的这个已经填完数字的靶形数独游戏中，总分数为 2829。游戏规定，将以总分数的高低决出胜负。

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

【输入】

一共 9 行。每行 9 个整数（每个数都在 0∼9 的范围内），表示一个尚未填满的数独方格，未填的空格用“0”表示。每两个数字之间用一个空格隔开。

【输出】

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

【输入样例】

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

【输出样例】

2829

【算法标签】

《洛谷 P1074 靶形数独》 #搜索# #剪枝# #位运算# #NOIP提高组# #2009#

【代码详解】

#include <bits/stdc++.h>
using namespace std;

const int N = 3245;  // 1的个数5000+列表头500
int n, m, cnt;       // 矩阵的长，宽，点的编号
int u[N], d[N], l[N], r[N];  // 每个点的上下左右指针
int row[N], col[N];  // 每个点所在行，列
int h[N];            // 每行的头节点
int s[N];            // 每列的节点数
int ans[N];          // 选了哪些行
int a[15][15];       // 存储数独初始状态
int res = -1;        // 存储最终结果

// 数独每个位置的权重矩阵
const int w[9][9] = {
    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
};

// 初始化第0行的列表头
void init()
{
    for (int y = 0; y <= m; y++)
    {
        u[y] = d[y] = y;
        l[y] = y - 1;
        r[y] = y + 1;
    }
    l[0] = m;
    r[m] = 0;
    cnt = m;
}

// 在x行y列插入点
void link(int x, int y)
{
    row[++cnt] = x;
    col[cnt] = y;
    s[y]++;
    u[cnt] = u[y];  // u[y]<->cnt<->y
    d[u[y]] = cnt;
    d[cnt] = y;
    u[y] = cnt;
    if (h[x] == 0)
    {
        h[x] = r[cnt] = l[cnt] = cnt;  // x行无点
    }
    else
    {
        l[cnt] = l[h[x]];  // l[h[x]]<->cnt<->h[x]
        r[l[h[x]]] = cnt;
        r[cnt] = h[x];
        l[h[x]] = cnt;
    }
}

// 删除y列与关联行
void remove(int y)
{
    r[l[y]] = r[y];
    l[r[y]] = l[y];
    for (int i = d[y]; i != y; i = d[i])  // 向下
    {
        for (int j = r[i]; j != i; j = r[j])  // 向右
        {
            u[d[j]] = u[j];
            d[u[j]] = d[j];
            s[col[j]]--;
        }
    }
}

// 恢复y列与关联行
void resume(int y)
{
    r[l[y]] = y;
    l[r[y]] = y;
    for (int i = u[y]; i != y; i = u[i])  // 向上
    {
        for (int j = l[i]; j != i; j = l[j])  // 向左
        {
            u[d[j]] = j;
            d[u[j]] = j;
            s[col[j]]++;
        }
    }
}

// 在十字链表上跳舞（精确覆盖问题的核心算法）
void dance(int dep)
{
    if (r[0] == 0)  // 所有列都被覆盖，找到解
    {
        int ss = 0;
        for (int i = 0, x, y, v; i < dep; i++)
        {
            x = (ans[i] - 1) / 9 / 9;  // 链表行->数独行
            y = (ans[i] - 1) / 9 % 9;   // 链表行->数独列
            v = (ans[i]) % 9;           // 链表行->数值
            a[x][y] = v ? v : 9;        // 0表示9
            ss += w[x][y] * a[x][y];    // 计算加权和
        }
        res = max(res, ss);  // 更新最大结果
        return;
    }

    int y = r[0];  // 找出1的个数最少的列
    for (int i = r[0]; i; i = r[i])
    {
        if (s[i] < s[y])
        {
            y = i;
        }
    }
    remove(y);
    for (int i = d[y]; i != y; i = d[i])
    {
        ans[dep] = row[i];
        for (int j = r[i]; j != i; j = r[j])
        {
            remove(col[j]);
        }
        dance(dep + 1);
        for (int j = l[i]; j != i; j = l[j])
        {
            resume(col[j]);
        }
    }
    resume(y);
}

int main()
{
    n = 729;  // 行数：9 * 9 * 9
    m = 324;  // 列数：4 * 81
    init();
    
    // 读取数独初始状态并构建精确覆盖矩阵
    for (int i = 0; i < 9; i++)  // 数独的行
    {
        for (int j = 0, x; j < 9; j++)  // 数独的列
        {
            cin >> x;
            a[i][j] = x;
            for (int k = 1; k <= 9; k++)  // 9个可能的数字
            {
                if (x == 0 || x == k)  // 空格或已匹配的数字
                {
                    int r = i * 9 * 9 + j * 9 + k;  // 数独->链表行
                    link(r, i * 9 + j + 1);         // 行-列约束
                    link(r, 81 * 1 + i * 9 + k);    // 行-数字约束
                    link(r, 81 * 2 + j * 9 + k);    // 列-数字约束
                    link(r, 81 * 3 + (i / 3 * 3 + j / 3) * 9 + k);  // 宫-数字约束
                }
            }
        }
    }
    
    dance(0);  // 开始舞蹈链算法
    cout << res;  // 输出最大加权和
    return 0;
}

【运行结果】

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
2829