#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
struct Data
{
    void assign(int x,int y,int z)
    {
        row=x;
        col=y;
        val=z;
    }
    int row,col,val;
} data[730];
struct Node
{
    Node(int x=0,int y=0):
        row(x),col(y),up(this),down(this),left(this),right(this) {}
    int row,col;
    Node *up,*down,*left,*right;
}**rowHead,**colHead;
char tempData[9][10];
int rowCounter[730],colCounter[325];
int ans[10][10];
int belong[10][10],belong1[10][10],belong2[10][10],belong3[10][10],belong4[10][10];
int belongX[325],belongY[325];
void init()
{
    rowHead=new Node*[730],colHead=new Node*[325];
    for(int i=0; i<=729; i++)rowHead[i]=new Node(i,0);
    for(int i=0; i<=324; i++)colHead[i]=new Node(0,i);
    for(int i=0; i<=729; i++)
        if(i&&i!=729)
        {
            rowHead[i]->up=rowHead[i-1];
            rowHead[i]->down=rowHead[i+1];
        }
        else if(!i)
        {
            rowHead[i]->up=rowHead[729];
            rowHead[i]->down=rowHead[i+1];
        }
        else
        {
            rowHead[i]->up=rowHead[i-1];
            rowHead[i]->down=rowHead[0];
        }
    for(int i=0; i<=324; i++)
        if(i&&i!=324)
        {
            colHead[i]->left=colHead[i-1];
            colHead[i]->right=colHead[i+1];
        }
        else if(!i)
        {
            colHead[i]->left=colHead[324];
            colHead[i]->right=colHead[i+1];
        }
        else
        {
            colHead[i]->left=colHead[i-1];
            colHead[i]->right=colHead[0];
        }
    memset(rowCounter,0,sizeof(rowCounter));
    memset(colCounter,0,sizeof(colCounter));
    memset(ans,0,sizeof(ans));
}
void link(int x,int y)
{
    Node *newNode=new Node(x,y);
    if(rowHead[x]->right==rowHead[x])
    {
        newNode->left=newNode->right=rowHead[x];
        rowHead[x]->left=rowHead[x]->right=newNode;
        rowCounter[x]++;
    }
    else
    {
        for(Node *i=rowHead[x]->right;; i=i->right)
            if(newNode->col<i->col||!i->col)
            {
                newNode->left=i->left;
                newNode->right=i;
                i->left->right=newNode;
                i->left=newNode;
                rowCounter[x]++;
                break;
            }
    }
    if(colHead[y]->down==colHead[y])
    {
        newNode->up=newNode->down=colHead[y];
        colHead[y]->up=colHead[y]->down=newNode;
        colCounter[y]++;
    }
    else
    {
        for(Node *i=colHead[y]->down;; i=i->down)
            if(newNode->row<i->row||!i->row)
            {
                newNode->up=i->up;
                newNode->down=i;
                i->up->down=newNode;
                i->up=newNode;
                colCounter[y]++;
                break;
            }
    }
}
void remove(Node *&x)
{
    x->left->right=x->right,x->right->left=x->left;
    for(Node *i=x->down; i!=x; i=i->down)
        for(Node *j=i->right; j!=i; j=j->right)
            if(j!=rowHead[i->row])
            {
                j->up->down=j->down;
                j->down->up=j->up;
                colCounter[j->col]--;
            }
}
void resume(Node *&x)
{
    for(Node *i=x->up; i!=x; i=i->up)
        for(Node *j=i->left; j!=i; j=j->left)
            if(j!=rowHead[i->row])
            {
                colCounter[j->col]++;
                j->down->up=j;
                j->up->down=j;
            }
    x->right->left=x,x->left->right=x;
}
bool dance()
{
    if(colHead[0]->right==colHead[0])return true;
    int best=2147483647;
    Node *bestNode;
    for(Node *i=colHead[0]->right; i!=colHead[0]; i=i->right)
        if(best>colCounter[i->col])
        {
            best=colCounter[i->col];
            bestNode=i;
        }
    remove(bestNode);
    for(Node *i=bestNode->down; i!=bestNode; i=i->down)
    {
        ans[data[i->row].row][data[i->row].col]=data[i->row].val;
        for(Node *j=i->right;j!=i;j=j->right)
            if(j!=rowHead[i->row])
                remove(colHead[j->col]);
        if(dance())return true;
        for(Node *j=i->left;j!=i;j=j->left)
            if(j!=rowHead[i->row])
                resume(colHead[j->col]);
    }
    resume(bestNode);
    return false;
}
int main()
{
    for(int i=1; i<=9; i++)
        for(int j=1; j<=9; j++)
            belong[i][j]=3*((i-1)/3)+(j-1)/3+1,
                         belong1[i][j]=9*(i-1)+j,
                                       belong2[i][j]=9*(i+8)+j,
                                               belong3[i][j]=9*(i+17)+j,
                                                       belong4[i][j]=9*(i+26)+j;
    for(int i=1; i<=81; i++)
        belongX[i]=(i-1)/9+1,
                   belongY[i]=(i-1)%9+1;
    for(int i=82; i<=162; i++)
        belongX[i]=(i-82)/9+1,
                   belongY[i]=(i-82)%9+1;
    for(int i=163; i<=243; i++)
        belongX[i]=(i-163)/9+1,
                   belongY[i]=(i-163)%9+1;
    for(int i=244; i<=324; i++)
        belongX[i]=(i-244)/9+1,
                   belongY[i]=(i-244)%9+1;
    int T;
    scanf("%d",&T);
    getchar();
    for(int countT=1; countT<=T; countT++)
    {
        init();
        int countRow=0;
        for(int i=0; i<9; i++)
        {
            gets(tempData[i]);
            for(int j=0; j<9; j++)
                if(tempData[i][j]!='0')
                {
                    int tempNumber=tempData[i][j]-'0';
                    countRow++;
                    data[countRow].assign(i+1,j+1,tempNumber);
                    link(countRow,belong1[i+1][j+1]);
                    link(countRow,belong2[i+1][tempNumber]);
                    link(countRow,belong3[j+1][tempNumber]);
                    link(countRow,belong4[belong[i+1][j+1]][tempNumber]);
                }
                else
                {
                    int counter=9,tempNumber=1;
                    while(counter--)
                    {
                        countRow++;
                        data[countRow].assign(i+1,j+1,tempNumber);
                        link(countRow,belong1[i+1][j+1]);
                        link(countRow,belong2[i+1][tempNumber]);
                        link(countRow,belong3[j+1][tempNumber]);
                        link(countRow,belong4[belong[i+1][j+1]][tempNumber]);
                        tempNumber++;
                    }
                }
        }
        if(dance())
        {
            for(int i=1; i<=9; i++)
            {
                for(int j=1; j<=9; j++)printf("%d",ans[i][j]);
                putchar('\n');
            }
        }
    }
    return 0;
}

之前水平不够，写了一个不加任何优化，直接搜的解数独程序。

现在水平提高，学会如何用双向十字链表优化时间复杂度来解数独游戏，还不能直接使用它，必须将它转化成“精确覆盖模型”。

为什么？

我尝试着写了一个单纯用双向十字链表来解数独游戏的程序，它有优点也有缺点。之前暴搜的那个程序解特别稀疏的数独就会超时，比如：全是空儿的数独。但是单纯用双向十字链表的程序能够解决这样“全是空儿”的数独，但是还不够~对于有些数独，尤其是唯一解的数独，也同样会超时的，比如下面这个很难很难的数独：

800 000 000

003 600 000

070 090 200

050 007 000

000 045 700

000 100 030

001 000 068

008 500 010

090 000 400

上面的数独对于单纯使用双向十字链表的程序就是克星，因为它的解用一种哲学上的思维来说就是：这个问题的解被排在了后面。对的，深度优先搜索都是一直搜到底的，对于有些问题解被“排在后面”的，深度优先搜索就不行了。

到底什么地方还能优化呢？

其实我们在单纯使用双向十字链表而不进行模型转化的时候，我们与以往搜索唯一的不同就在于我们能够直接找到哪些有空儿、哪些没有空儿，但是有一点：我们还是从1到9枚举了每一个数字，然后对于每个数字通过之前打上的标记判断能不能填，虽然只有9个数字，但是这9个数字的枚举是放在递归层次里的，非常费时。

现在我们不仅需要能够直接知道哪些空儿可以填，我们还需要直接知道哪些数字是可以填的，这样可以加快进程~~~

怎样转化成精确覆盖模型？

构造这样的矩阵：

对于第1~81列：

第1列：在(1,1)填了数字

第2列：在(1,2)填了数字

。。。。。。

第n列：。。。。。。

映射：row=(n-1)/9+1，col=(n-1)%9+1，n=9*(row-1)+col

对于第81~162列：

第1列：在第1行填了数字1

第2列：在第2行填了数字2

。。。。。。

第n列：。。。。。。

映射：row=(n-82)/9+1，num=(n-82)%9+1，n=9*(row+8)+num

对于第163~243列：

第1列：在第1列填了数字1

第2列：在第2列填了数字2

。。。。。。

第n列：。。。。。。

映射：col=(n-163)/9+1，col=(n-163)%9+1，n=9*(col+17)+num

对于第244~324列：

第1列：在第1宫填了数字1

第2列：在第1宫填了数字2

。。。。。。

第n列：。。。。。。

映射：grid=(n-244)/9+1，num=(n-244)%9+1，n=9*(grid+26)+num

对于一个给出的矩阵，如果在(x,y)处是3，那么就插入这样一行

它的9*(x-1)+y，9*(x+8)+3，9*(y+17)+3，9*(grid(x,y),26)+num（坐标映射到宫：3*((x-1)/3)+(y-1)/3+1）

以上四列都是1，但是插入行的时候要记录对应行所代表的意义是什么，这样在搜索时就能很轻易得到信息。

如果是空儿，那么就按照上面的方法在对应坐标将1~9依次插入，总共就是4*9=36个节点。

接下来直接解精确覆盖就可以了，通过选的行的编号，可以知道在那个位置填入几，当然这也要预处理一下，我用的方法就是直接将信息放在Data结构体中，当然可能也有公式，我就不推了。

写的有些潦草，不如网上一些大牛写的好。

下面是一个测试样例和结果：

1
800000000
003600000
070090200
050007000
000045700
000100030
001000068
008500010
090000400

812753649
943682175
675491283
154237896
369845721
287169534
521974368
438526917
796318452

时间相当快，可见双向十字链表+精确覆盖模型的解题速度之快。

不过感觉本文还是写挫了，凑合看吧。