金字塔数独

问题描述

蒜头君天资聪颖，酷爱数学，尤其擅长做数独游戏。不过普通的数独游戏已经满足不了蒜头君了，于是他发明了一种“金字塔数独”：
下图即为金字塔数独。和普通数独一样，在 9 × 9 的大九宫格中有 9 个 3 ×3 的小九宫格（用粗黑色线隔开的）。要求每个格子上都有一个 1 到 9 的数字，每个数字在每个小九宫格内不能重复出现，每个数字在每行、每列也不能重复出现。
但金字塔数独的每一个格子都有一个分值，类似金字塔的俯视图。如图所示，白色格子为 6 分，蓝色格子为 7 分，绿色格子为 8 分，紫色格子为 9 分，红色格子为 10 分。颜色相同的格子分值一样，离中心越近则分值越高。

金字塔数独的总分等于每个格子上的数字和对应的分值乘积之和。现在蒜头君给定金字塔数独的若干数字，请问如何填写，可以使得金字塔数独的总分最高。
输入格式
输入一共 9 行。每行输入 9 个整数（每个数都在 0—9 的范围内），每两个整数之间用一个空格隔开，“0”表示该格子为空。
输出格式
输出为一行，输出一个整数，代表金字塔数独的最高总分。如果数独无解，则输出 −1。
样例输入
0 0 0 0 0 0 0 0 0
0 0 3 0 0 0 9 0 0
7 9 0 0 0 2 0 1 3
0 0 9 1 5 0 0 0 0
0 7 4 0 2 6 1 3 9
0 0 6 0 0 0 0 0 0
6 0 0 0 0 7 0 0 0
3 1 0 4 0 5 7 9 6
0 0 7 0 0 1 0 4 0
样例输出
2864

//把要填的数和已填的数分离
#include<iostream>
#include<algorithm>
using namespace std;
struct f
{
    int rank,sum;
	//定义结构体，将行号与0的个数对应，每一行要填几个数
}cou[10];

int a[10][10],hang[10][10],lie[10][10];
int gong[10][10],s[100][4],u,ok,most=-1,have;

int which(int,int)
{
    if(i<=3)
    {
        if(j<=3)        return 1;
        else if(j<=6)   return 2;
        else            return 3;
    }
    else if(i<=6)
    {
        if(j<=3)        return 4;
        else if(j<=6)   return 5;
        else            return 6;
    }
    else
    {
        if(j<=3)        return 7;
        else if(j<=6)   return 8;
        else            return 9;
    }
}
//给出两个整型变量代表坐标，返回此坐标的所在小的3X3的九宫
int point(int,int)
{
    if(i==1||j==1||i==9||j==9)   return 6;//白格子
    if(i==2||j==2||i==8||j==8)   return 7;//蓝格子
    if(i==3||j==3||i==7||j==7)   return 8;//绿格子
    if(i==4||j==4||i==6||j==6)   return 9;//紫格子
    return 10;//红格子
}
//给出两个整型变量代表坐标，返回此坐标的分值
void dfs(int p,int score)
{
    if(p==u)//合法填完了所有的数
    {
        if(score>most)  most=score;//更大就更新
        return;
    }
    for(int i=1;i<=9;i++)
    {
        // 这个数度的规则只要求不重复，不要求和相等
        // 每个数字在每个小九宫格内不能重复出现，每个数字在每行、每列也不能重复出现
    	// if(!hang[行号][i]&&!lie[列号][i]&&!gong[小九宫号][i])
		// 用于判断这个点可不可以填数（已经填过了就不可以再填了）
        if(!hang[s[p][0]][i]&&!lie[s[p][1]][i]&&!gong[s[p][3]][i])
        {
            hang[s[p][0]][i]=lie[s[p][1]][i]=gong[s[p][3]][i]=1;
			//填了后就将这个点的值在其所在行、列、宫中标记
            dfs(p+1,score+(s[p][2]*i));//下一层递归
            hang[s[p][0]][i]=lie[s[p][1]][i]=gong[s[p][3]][i]=0;//回溯
        }
    }
    return;
}
// 表示正在搜s[p],score为目前分数
bool cmp(f a,f b)
{
    return a.sum<b.sum;
}
int main()
{
    for(int i=1;i<=9;i++)  cou[i].rank=i;
	//rank存其初始行号，排序后就不会丢失
    for(int i=1;i<=9;i++)
    for(int j=1;j<=9;j++)
    {
    	
        cin>>a[i][j];
        //有三个图一个保存行信息，一个保存列信息，一个保存小九宫的信息
        //hang[i][a[i][j]]=lie[j][a[i][j]]=gong[which(i,j)][a[i][j]]=1
        //hang[行号][桶排序]=lie[列号][桶排序]=gong[小九宫号][桶排序]=标记不用在填入其他数据
        if(a[i][j]>0)
        hang[i][a[i][j]]=lie[j][a[i][j]]=gong[which(i,j)][a[i][j]]=1,have+=a[i][j]*point(i,j);
		//非零就不存储到搜索数组s中，但将这个点的值在其所在行、列、宫中标记 ，计算加分
		//因为非零是需要填入的空
        else  cou[i].sum++;//是0就计数
    }
    sort(cou+1,cou+10,cmp);
	//排序，0少的在前,即不确定性最小的那一行在前面最先开始填
	
    for(int i=1;i<=9;i++)//整理s数组，准备搜索
    {
        for(int j=1;j<=9;j++)//从空最少的一行开始填
        if(a[cou[i].rank][j]==0)//当前行从左往右，如果当前位置是要来填数的
        s[u][0]=cou[i].rank,s[u][1]=j,s[u][2]=point(cou[i].rank,j),s[u++][3]=which(cou[i].rank,j);
		//保存行号，列号，权重，小九宫
    }
    dfs(0,have);//搜索
    cout<<most<<endl;//most保存答案，初始值为-1
    return 0;
}

整体的思想就是模拟人写数度的过程，按行来填，先找到代填入数最少的那一行，一步步减少不确定性，难点在数据的多维性，保存每一个点的属性值比较繁琐