題目描述

小城和小華都是熱愛數學的好學生，最近，他們不約而同地迷上了數獨遊戲，好勝的他

們想用數獨來一比高低。但普通的數獨對他們來說都過於簡單了，於是他們向 Z 博士請教，

Z 博士拿出了他最近發明的“靶形數獨”，作為這兩個孩子比試的題目。

靶形數獨的方格同普通數獨一樣，在 9 格寬×9 格高的大九宮格中有 9 個 3 格寬×3 格

高的小九宮格（用粗黑色線隔開的）。在這個大九宮格中，有一些數字是已知的，根據這些數字，利用邏輯推理，在其他的空格上填入 1 到 9 的數字。每個數字在每個小九宮格內不能

重復出現，每個數字在每行、每列也不能重復出現。但靶形數獨有一點和普通數獨不同，即

每一個方格都有一個分值，而且如同一個靶子一樣，離中心越近則分值越高。（如圖）

上圖具體的分值分布是：最裏面一格（黃色區域）為 10 分，黃色區域外面的一圈（紅

色區域）每個格子為 9 分，再外面一圈（藍色區域）每個格子為 8 分，藍色區域外面一圈（棕

色區域）每個格子為 7 分，最外面一圈（白色區域）每個格子為 6 分，如上圖所示。比賽的

要求是：每個人必須完成一個給定的數獨（每個給定數獨可能有不同的填法），而且要爭取

更高的總分數。而這個總分數即每個方格上的分值和完成這個數獨時填在相應格上的數字

的乘積的總和

總分數即每個方格上的分值和完成這個數獨時填在相應格上的數字

的乘積的總和。如圖，在以下的這個已經填完數字的靶形數獨遊戲中，總分數為 2829。遊戲規定，將以總分數的高低決出勝負。

由於求勝心切，小城找到了善於編程的你，讓你幫他求出，對於給定的靶形數獨，能

夠得到的最高分數。

輸入輸出格式

輸入格式：

一共 9 行。每行 9 個整數（每個數都在 0―9 的範圍內），表示一個尚未填滿的數獨方

格，未填的空格用“0”表示。每兩個數字之間用一個空格隔開。

輸出格式：

輸出文件 sudoku.out 共 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

sudoku1
2829

sudoku2
2852

說明

【數據範圍】

40%的數據，數獨中非 0 數的個數不少於 30。

80%的數據，數獨中非 0 數的個數不少於 26。

100%的數據，數獨中非 0 數的個數不少於 24。

NOIP 2009 提高組 第四題

思路：暴力做法基本上與數獨挑戰一樣，都是直接枚舉+判斷，然而這樣有一個問題。數據給的空位可能會很多，這樣搜索復雜度也會很高，怎麽辦呢？這時候我們就需要一個玄學優化：優先搜索可能情況少的，這樣先局部減少復雜度，再限制後面的復雜度的增長，可以減少一些總體的復雜度，當然還有其他的優化，例如：倒著搜、倒著枚舉數字、O2優化、inline等等。我主要是用的優先搜索少的。

搜索很簡單，枚舉即可。

PS:這題排序有坑，我把sort換成stable_sort就玄學過了。。。（stable_sort大法好）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
const int maxn=12;
inline int read()
{
    int ret=0,f=1;
    char c=getchar();
    while(c<‘0‘||c>‘9‘)
    {if(c==‘-‘) f=-1;c=getchar();}
    while(c>=‘0‘&&c<=‘9‘)
    {ret=ret*10+c-‘0‘;c=getchar();}
    return ret*f;
}
int mmp[maxn][maxn];
struct node{
    int x,y,k;
}p[maxn*maxn];
bool row[maxn][maxn],col[maxn][maxn],gz[4][4][maxn];
int tot=0;
int f[maxn][maxn]={{0,0,0,0,0,0,0,0,0,0},
{0,6,6,6,6,6,6,6,6,6},
{0,6,7,7,7,7,7,7,7,6},
{0,6,7,8,8,8,8,8,7,6},
{0,6,7,8,9,9,9,8,7,6},
{0,6,7,8,9,10,9,8,7,6},
{0,6,7,8,9,9,9,8,7,6},
{0,6,7,8,8,8,8,8,7,6},
{0,6,7,7,7,7,7,7,7,6},
{0,6,6,6,6,6,6,6,6,6},
};
inline void place(int x,int y,int v,bool t)
{
    row[x][v]=t,col[y][v]=t;
    gz[(x-1)/3][(y-1)/3][v]=t;
}
bool cmp(node A,node B)
{
    return A.k>B.k;
}
void make_pre()
{
    for(int i=1;i<=tot;i++)
    {
        int x=p[i].x,y=p[i].y;
        int xx=(x-1)/3,yy=(y-1)/3;
        for(int j=1;j<=9;j++)
        {
            if(row[x][j]||col[y][j]||gz[xx][yy][j]) p[i].k++;
        }
    }
    stable_sort(p+1,p+1+tot,cmp);
}
int ans=0;
void dfs(int step,int sum)
{
    if(step==tot+1)
    {
        ans=max(ans,sum);
        return;
    }
    if(sum+(tot+1-step)*90<=ans) return;
    int x=p[step].x,y=p[step].y;
    int xx=(x-1)/3,yy=(y-1)/3;
    for(int i=1;i<=9;i++)
    {
        if(row[x][i]||col[y][i]||gz[xx][yy][i]) continue;
        mmp[x][y]=i;
        place(x,y,i,1);
        dfs(step+1,sum+i*f[x][y]);
        mmp[x][y]=0;
        place(x,y,i,0);
    }
    return;
}
int main()
{
    int ansp=0;
    for(int i=1;i<=9;i++)
        for(int j=1;j<=9;j++)
        {
            mmp[i][j]=read();
            ansp+=mmp[i][j]*f[i][j];
            if(!mmp[i][j])
            {
                tot++;
                p[tot].x=i,p[tot].y=j;
                
            }
            else place(i,j,mmp[i][j],1);
        }
    make_pre();
    dfs(1,ansp);
    if(!ans) printf("-1\n");
    else printf("%d\n",ans);
    return 0;
}

NOIP2009 靶形數獨