P1784 数独

admin

https://www.luogu.org/problemnew/show/P1784
这个题目很有讨论意义，我觉得可以列方程来解，不需要搜索。

admin

数独（Sudoku）是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。 每一道合格的数独谜题都有且仅有唯一答案，推理方法也以此为基础，任何无解或多解的题目都是不合格的。

如下图所示，就是一个数独的题目

关于数独的详细介绍，参看“百度百科——数独”

数独的基本解法就是利用规则的摒弃法

一些定义

每一行称为数独的行，每一列称为数独的列，每一个小九宫格称为数独的宫。数独的基本规则就是每一行、每一列、每一宫中，1-9这9个数字都只出现一次。

用（行，列）表示上图的单元格，例如（1，1）表示第一行第一列的单元格，（2，4）表示第二行第四列的单元格

如上图，每个空白单元格中能填的数字都是有限制的。

例如：（1，1）就只能填7和8；而（6，4），只能填8；

那些只能填一个数字的空白单元格，我们称之为唯一数单元格，上图中（6，4）就是唯一数单元格

解题的顺序，就是从唯一数单元格开始，由于唯一数单元格只能填一个数，故先在这个单元格里填数。在这个单元格里填数，由于规则的定义，那么这个单元格所在的行、所在的列、所在的宫的其他单元格就不能再填这个数了。这些单元格能填的数的可能性就少了。有可能会产生新的唯一数单元格。

在相当的一些的数独题目中，从唯一数单元格开始填数，不停的在唯一数单元格填数就可以把数独解出来。

如果在解题的过程中，发现某些空白单元格没有数字能填这样的单元格称之为无解单元格，那就说明：要么这个数独没有解；要么之前的解题过程有问题，需要返回检查之前的解题过程查看。

但是还有不少的数独的题目，在解题的过程中，在还有空白单元格的情况下，却找不到唯一数单元格，也就是意味着每个空白单元格中能填的数字至少有2个。我们称之为无唯一数单元格的状况

这个时候怎么办？我们找到其中一个可能数最少的空白单元格（这个没有定论，可以是可能数最少的空白单元格；也可以是第一个空白单元格；也可以是可能数最多的空白单元格，选哪个空白单元格对后面的解题是否有影响，没有证明过，不好妄下定论。凭感觉选可能数最少的空白单元格是最好的选择），由于能填的数字不止一个，先把当前的状态保存起来，再在能选的数字中选择一个数字填写（从小到大选择），然后继续求解下去。如果能解出最后的结果，说明当前的选择是正确的；如果后面的求解过程有问题，说明当前的数字的选择有问题，那么再挑选另一个数填写，继续求解。如果，所有的选择都求不出最后的结果，还是说明：要么这个数独没有解；要么之前的解题过程有问题，需要返回检查之前的解题过程查看。如此反复，直到求出最终的答案。

会有种极端的情况（可能性不大）。那就是在当前的空白单元格的所有可能的数字都选择了一遍，都没有解。而之前又没有出现无唯一数单元格的状况。那就说明这个数独根本就没有解

下图是数独求解的流程图

下面谈谈该算法的具体实现

1、数独状态的表示

用计算机来求解数独。基本的一点就是如何表示数独的状态。

用整形一维数组来表示数独的状态

用Num（80）表示数独的状态（数组的下标从0开始），数独是一个二维表格，而数组是一维数组。那么就存在一维和二维之间的转换

一维数组的下标Index（小标从0开始）和二维下标X、Y（下标从0开始）之间的转换公式

一维到二维的转换

X=Int（Index/9）

Y=Index mod 9

二维到一维的转换

Index=X*9+Y

数组中的每个整数表示数独对应的单元格的状态

正数表示空白单元格能填的数的组合，用二进制表示。用位来表示该单元格是否能填相应的数字，1表示能填，0表示不能填。

如文章开始的数独的单元格（1，1）可能填7和8，则第7位和第8位上是1（位数是从后往前数），其余位都是0，用整数表示就是Num（0）=0110000002=192

每在单元格中填一个数字，则把相应的行、列、宫中其余的单元格把该数字去掉。

我们可以充分利用位运算来简化去数字的过程。如：要把单元格去掉7这个数字的可能。首先7对应的二进制位0010000002，取其反数得到1101111112，再和目标单元格的数值进行AND的位运算，来实现去除该单元格7这个数字的可能性（由于位运算的便捷，不需要考虑该单元格是否原本包含7这个数字的可能性）。

如：（1，1）=0110000002 AND 1101111112=0100000002，去除7这个可能性，只剩8这个可能性了，也就是成为唯一数单元格

再比如：（1，9）=0100000102 AND 1101111112=0100000102，原本单元格就没有7这个可能性，执行位运算后，还是原来的可能性，没有发生变化。

负数表示该单元格已经确定的数，例如：（1，2）=-6，表示该单元格已近填了数字6

0表示该单元格既没有填确定的数字，也没有可填数的可能性。也就是上文说的无解单元格

为了算法中计算的方便，事先把这些二进制数都缓存起来，用一个一维的数组表示

用数组V来表示各个位对应的数字

V（0）=0000000012=1

V（1）=0000000102=2

V（2）=0000001002=4

V（3）=0000010002=8

V（4）=0000100002=16

V（5）=0001000002=32

V（6）=0010000002=64

V（7）=0100000002=128

V（8）=1000000002=256

V（9）=1111111112=511

数字7对应的二进制数为V（6）=0010000002=64，7的反数为V（9）-V（6）=1101111112=447

每个单元格初始的值都是V（9）=1111111112=511

2、如何获得一个单元格的可填数的个数

由于是用二进制来表示单元格的状态，那么可填数的个数就是该数字中1的个数。我们之前有一个很方便的方法快速计算一个数中1的个数，参看算法的强大——快速计算一个正二进制整数中包含多少个1。

3、状态的缓存

依据之前的说法，在碰到无唯一数单元格的情况时，要把当前的状态缓存起来。考虑到实际情况，从算法的角度上来说，用栈（先进后出）这个数据结构来实现比较合适。可以自己写一个栈的实现。但是，目前很多的编程语言都实现了基本的数据结构，提供了基本的数据结构的类和方法供我们调用。

以Visual Studio为例，它有Stack这个类，实现了栈的基本操作。有两个栈的方法：Push（压栈）——把数据写到栈里面；Pop（出栈）——把数据从栈里提出来，并删除栈中的数据。

4、代码说明

基本的变量

    Private _Num(80) As Integer
    Private _V(9) As Integer
    Private _S As System.Text.StringBuilder
    Private _HasString As Boolean

_Num数组表示数独的状态；_V数组是辅助数组，缓存常用的二进制数

_S是一个文本对象，保存数独求解的过程；_HasString是个开关变量，表示是否记录求解过程；这两个变量是辅助变量，仅仅起到记录的作用。

类的初始化

    Public Sub New(Optional ByVal HasString As Boolean = True)
        Dim I As Integer
        _V(0) = 1
        For I = 1 To 8
            _V(I) = _V(I - 1) * 2
        Next
        _V(9) = 511

        For I = 0 To 80
            _Num(I) = _V(9)
        Next

        _S = New System.Text.StringBuilder
        _HasString = HasString
    End Sub

代码的前半段生成V这个数组，_V（9）=511。后半段，初始化数独数组。由于是空白数独数组，故每个单元格的值都是_V（9）

在给定的单元格里移除某个数字的可能性代码

    Private Function RemoveNum(ByVal Row As Integer, ByVal Col As Integer, ByVal Num2 As Integer) As Integer
        Dim Index As Integer = Row * 9 + Col
        If _Num(Index) > 0 Then _Num(Index) = _Num(Index) And Num2
        Return _Num(Index)
    End Function

3个参数，Row表示行，Col表示列（都是下标从0开始），Num2表示要去除的数的反码，以二进制表示。

例如：在（1，1）这个单元格去除7这个可能性，则调用RemoveNum（0，0，1101111112）

返回值是该单元格的状态值，如果返回0，表示该单元就成了无解单元格，要后面的代码做适当的处理

在给定的单元格填某个数的代码

    Private Function SetNumPri(ByVal Row As Integer, ByVal Col As Integer, ByVal Num As Integer) As Boolean
        If (_V(Num) And _Num(Row * 9 + Col)) = 0 Then Return False
        _Num(Row * 9 + Col) = -(Num + 1)
        Num = _V(9) - _V(Num)

        Dim I As Integer, J As Integer

        For I = 0 To 8
            If RemoveNum(I, Col, Num) = 0 Then Return False
            If RemoveNum(Row, I, Num) = 0 Then Return False
        Next

        Dim R1 As Integer = Int(Row / 3) * 3
        Dim C1 As Integer = Int(Col / 3) * 3

        For I = R1 To R1 + 2
            For J = C1 To C1 + 2
                If RemoveNum(I, J, Num) = 0 Then Return False
            Next
        Next

        Return True
    End Function

3个参数，Row表示行，Col表示列，Num表示要填充的数字（下标从0开始），这个方法是供类内部调用，从程序的角度来说，程序处理下标，从0开始比从1开始要来得简单。

例如：在（1，1）中填入数字7，则调用SetNumPri（0，0，6）

代码的第1行，先利用位运算判断当前单元格能否填制定的数字，不能填返回False

代码的第2行，设置当前单元格为指定数字，之前说了，用负数表示已填好的数字

代码的第3行，获得当前数字的反码，为后面去除该单元格所在的行、列、宫的其他单元格的该数字做准备

后面有两个循环，第一个循环去除行、列的其他单元格的该数字；第二个双循环去除宫的其他单元格的该数字。在调用RomoveNum方法时，若返回的是0，说明产生了无解单元格，那说明在这个单元格填该数字是不合理的，故返回False

当全部的代码都能顺利完成了，说明这个单元格填该数字是合理的，返回True

该方法的另一个重载形式

    Private Function SetNumPri(ByVal Index As Integer, ByVal Num2 As Integer) As Boolean
        Dim Row As Integer = Int(Index / 9)
        Dim Col As Integer = Index Mod 9
        Dim I As Integer
        For I = 0 To 8
            If _V(I) = Num2 Then Exit For
        Next
        Return SetNumPri(Row, Col, I)
    End Function

这也是一个供内部调用的方法，两个参数，Index是一维数组的下标；Num2是数字的二进制的形式。整个方法就是参数的转换，然后调用之前的方法

下面是两个供外面调用的方法

    Public Function SetNum(ByVal Row As Integer, ByVal Col As Integer, ByVal Num As Integer) As Boolean
        Return SetNumPri(Row - 1, Col - 1, Num - 1)
    End Function

    Public Function SetLine(ByVal Row As Integer, ByVal ParamArray Num() As Integer) As Boolean
        If Num.Length = 0 Then Return True

        Dim I As Integer

        For I = 0 To IIf(Num.Length - 1 > 8, 8, Num.Length - 1)
            If Num(I) > 0 AndAlso SetNumPri(Row - 1, I, Num(I) - 1) = False Then Return False
        Next

        Return True

    End Function

第一个方法是公开给外部调用的填数的方法。对外来说，从直观性上来说，下标是从1开始比较合适，但是内部的方法从0开始比较好。

如在（1，1）填7，调用SetNum（1，1，7），这个方法转而调用SetNumPri（0，0，6）

这个方法一般用在初始化数独时候调用

第二个方法也是公开给外部的方法，一次填写一行数的方法，如果是空白单元格，则用0替代

如本文开始的数独，填写第一行代码就是SetLine（1，0，6，0，5，9，3，0，0，0）

几个辅助方法

    Private Sub RestoreNum(ByVal L As List(Of Integer))
        Dim I As Integer
        For I = 0 To 80
            _Num(I) = L.Item(I)
        Next

        AppendString("Restore Matrix")
    End Sub

恢复L中的数据到数独数组中，L是之前缓存的数据。AppendString这个方法是将数据记录到文本对象

    Private Function Get1Count(ByVal Value As Integer) As Integer
        Dim C As Integer = 0
        Do While Value > 0
            Value = Value And (Value - 1)
            C += 1
        Loop
        Return C
    End Function

获得一个数中1的个数，也就是获得一个空白单元格的可填数的数目

例如：（1，1）=0110000002，Get1Count（0110000002）=2，说明（1，1）这个单元格能填2个数

    Private Function GetIndexOfNum(ByVal Num As Integer, ByVal Index As Integer) As Integer
        Dim I As Integer, K As Integer = 0
        For I = 0 To 8
            If (_V(I) And Num) <> 0 Then
                K += 1
                If K = Index Then Return I + 1
            End If
        Next
        Return -1
    End Function

获得指定数Num（二进制形式）的第Index个的可填数

还是以上面的为例，（1，1）=0110000002，

GetIndexOfNum（0110000002，1）=7，表示第1个可填数是7

GetIndexOfNum（0110000002，2）=8，表示第2个可填数是8

GetIndexOfNum（0110000002，3）=-1，表示没有第3个可填数

辅助记录函数

这些函数对求解算法没啥太大的帮助，仅仅是将求解的过程记录到文本中，以供日后研究参考

    Private Function ReturnNumString(ByVal Num As Integer) As String
        If Num < 0 Then Return "#" & (-Num) & " "
        Dim I As Integer, S As String = ""
        For I = 0 To 8
            If (_V(I) And Num) <> 0 Then S &= (I + 1)
        Next
        Return S.PadRight(10)
    End Function

返回一个数字的文本格式，如果是空白单元格，返回该单元格的所有可填数；如果是已填单元格，返回#+数字的字符串。返回的字符串经过对齐处理。

    Private Function ReturnMatrix() As String
        Dim I As Integer, J As Integer, S As String = ""
        For I = 0 To 8
            For J = 0 To 8
                S &= ReturnNumString(_Num(I * 9 + J))
            Next
            S &= vbNewLine
        Next
        Return S
    End Function

返回整个数独的状态文本

    Private Sub AppendString(ByVal Text As String, Optional ByVal AppendMatrix As Boolean = True)
        If _HasString = False Then Exit Sub
        _S.AppendLine(Text)
        _S.AppendLine()
        If AppendMatrix = True Then
            _S.AppendLine(ReturnMatrix)
            _S.AppendLine()
        End If
    End Sub

将文本添加到文本对象，并根据AppendMatrix参数来决定是否将整个数独的状态添加到文本对象

    Private Function IndexToXY(ByVal Index As Integer) As String
        Return (Int(Index / 9) + 1) & "-" & (Index Mod 9 + 1) & " Num:" & -_Num(Index)
    End Function

返回指定Index的坐标和已填的数，用于在文本对象中

    Public Function CalculationString() As String
        Return _S.ToString
    End Function

对外公开的方法，返回文本对象，也就是之前记录的求解过程，共日后研究参考

主求解函数——算法的核心

下面的3个函数是算法的核心

    Private Function FindMinCell() As Integer
        Dim I As Integer, C As Integer
        Dim tP As Integer = -1, tMin As Integer = 20

        I = 0

        Do
            If _Num(I) > 0 Then
                C = Get1Count(_Num(I))
                If C = 1 Then
                    If SetNumPri(I, _Num(I)) = False Then Return -2

                    AppendString("SetNum " & IndexToXY(I))

                    If I = tP Then
                        tP = -1
                        tMin = 20
                    End If

                    I = -1
                Else
                    If C < tMin Then
                        tP = I
                        tMin = C
                    End If
                End If
            End If
            I += 1
        Loop Until I > 80

        Return tP
    End Function

该函数是获得最少可能数的单元格（可填数大于2的空白单元格）

该函数返回值有3个可能性

返回值：-1，没有找到这样的单元格，函数从某个唯一数单元格开始填数，依次填下去，并且把所有的空白单元格都填满。这说明，求解结束。

返回值：-2，没有找到这样的单元格，函数从某个唯一数单元格开始填数，依次填下去，产生了无解单元格。说明之前的求解过程有错误或者说该数独无解

返回值：0-80，找到这样的单元格，并且当前的数独数组中不再存在唯一数单元格（函数直接会在唯一数单元格上填数）

    Public Function Calculate() As Integer()
        Dim I As Integer
        Dim K As Integer
        Dim Q As New Stack(Of List(Of Integer))
        Dim L As List(Of Integer)

        _S = New System.Text.StringBuilder
        AppendString("Init Matrix")

        K = FindMinCell()

        Do While K <> -1
            If K = -2 Then
                If Q.Count = 0 Then
                    AppendString("Error!!!!!", False)
                    Return Nothing
                End If


                L = Q.Pop

                K = L(82)
                L.RemoveAt(82)

                I = L(81) + 1
                L.RemoveAt(81)

                AppendString("Stack Pop " & Q.Count + 1, False)

                RestoreNum(L)

                K = FindNextK(Q, L, K, I)

            Else
                L = New List(Of Integer)
                L.AddRange(_Num)

                K = FindNextK(Q, L, K, 1)

            End If

        Loop

        AppendString("Calculating Complete!!!!")

        Dim V(80) As Integer
        For I = 0 To 80
            V(I) = -_Num(I)
        Next
        Return V
    End Function

对外公开的主求解函数，返回最终结果的整形数组

首先解释一下栈对象Q，由于栈Q每次压栈的时候只能压一个对象，而当出现无唯一数单元格的情况的时候，需要将当前的数据缓存起来。需要缓存的内容有三个部分，分别是数独数组、找到的最少可能数的单元格的下标、最少可能数的单元格的选择填的第几个数。故用一个List（of Integer）对象将之前的三个内容缓存起来。L（0）—L（80）表示是数独数组，L（81）是最少可能数的单元格的下标，L（82）是最少可能数的单元格的选择填的第几个数。

该函数的主要是判断K的值，如上个函数所述，K的值主要有3种

K=-1，说明没有空白单元格，数独已经完美的求解完成，直接返回结果

K=-2，说明有无解单元格，那么判断栈Q中的数据，如果栈Q中没有数据，说明该数独无解；如果栈Q中有数据，那么把数据提出来，把数独的状态恢复到之前的情况。并从上次缓存的最少可能数单元格中，提取下一个可填数去继续进行尝试。

举例说明，缓存了0，1。说明上次尝试的是第1个单元格（下标从0开始）的第1个可填数。由于出现了无解单元格，说明第1个可填数是不正确的，那么继续尝试第2个可填数。调用的方法：FindNextK(Q, L, K, I)，之前I已经加过1了。

K=0-80，得到最少可能数的单元格的下标。从该单元格的第1个可填数开始尝试。调用的方法：FindNextK(Q, L, K, 1)

尝试可能数的函数是FindNextK，返回值也是分为3种，-1、-2、0-80。意义和上面一样

    Private Function FindNextK(ByVal Q As Stack(Of List(Of Integer)), ByVal L As List(Of Integer), ByVal K As Integer, ByVal Index As Integer) As Integer

        Dim J As Integer = GetIndexOfNum(_Num(K), Index)

        Do While J <> -1
            If SetNumPri(K, _V(J - 1)) = True Then
                AppendString("Stack Push " & Q.Count + 1, False)
                AppendString("SetNum MayBe " & IndexToXY(K))

                L.Add(Index)
                L.Add(K)
                Q.Push(L)

                K = FindMinCell()

                Exit Do
            End If

            RestoreNum(L)
            Index += 1
            J = GetIndexOfNum(_Num(K), Index)
        Loop
        If J = -1 Then K = -2
        Return K
    End Function

辅助函数，获得尝试可能数的结果

首先，通过GetIndexOfNum获得当前可填数。如果返回值-1的话，说明当前已经没有可填数，出现无解单元格，直接返回值为-2

然后尝试在当前单元格填数，调用SetNumPri(K, _V(J - 1))，返回True表示该数能填，那么把当前的状态缓存到栈Q中，并通过FindMinCell函数获得下一个可能的K值，并返回；返回False表示该数不能填，恢复数据到数独数组，继续尝试下一个数。

至此该算法类的代码都说明完整了

在该算法中仅仅用了最基本的解法——摒除法。遇见唯一数单元格，就直接填数，如果遇见无唯一数单元格，则缓存数据，并对该单元格的所有可填数做尝试，直到求解出该数独为止。

会有人疑问，利用栈Q缓存数据，会不会极大的占用系统资源，导致无法解题的情况。以目前的情况来看，我用该算法求解了“程序员们都是不被世人所理解的真正天才吗?-请大家看这个数独的解法”中的号称最难的数独，并把求解的结果保存到文件后打开分析了一下，发现栈Q的缓存不超过20步，以20步为例，每步83*4字节，则一共20*83*4=6640字节<7K字节。远小于系统的承受能力。因此，不必担心系统的承受能力

如果，谁有好的数独的算法，欢迎交流，不吝赐教。

让我们实战看看成果，用该算法求解本文开头的数独，代码如下：

Dim tS As New clsSudoku

tS.SetLine(1, 0, 6, 0, 5, 9, 3, 0, 0, 0)
tS.SetLine(2, 9, 0, 1, 0, 0, 0, 5, 0, 0)
tS.SetLine(3, 0, 3, 0, 4, 0, 0, 0, 9, 0)
tS.SetLine(4, 1, 0, 8, 0, 2, 0, 0, 0, 4)
tS.SetLine(5, 4, 0, 0, 3, 0, 9, 0, 0, 1)
tS.SetLine(6, 2, 0, 0, 0, 1, 0, 6, 0, 9)
tS.SetLine(7, 0, 8, 0, 0, 0, 6, 0, 2, 0)
tS.SetLine(8, 0, 0, 4, 0, 0, 0, 8, 0, 7)
tS.SetLine(9, 0, 0, 0, 7, 8, 5, 0, 1, 0)

tS.Calculate()

My.Computer.FileSystem.WriteAllText("1.txt", tS.CalculationString, False)

该数独还是比较简单的，一路唯一数单元格到底

结果如下：

Calculating Complete!!!!

#7        #6        #2        #5        #9        #3        #1        #4        #8        
#9        #4        #1        #2        #7        #8        #5        #3        #6        
#8        #3        #5        #4        #6        #1        #7        #9        #2        
#1        #9        #8        #6        #2        #7        #3        #5        #4        
#4        #7        #6        #3        #5        #9        #2        #8        #1        
#2        #5        #3        #8        #1        #4        #6        #7        #9        
#3        #8        #7        #1        #4        #6        #9        #2        #5        
#5        #1        #4        #9        #3        #2        #8        #6        #7        
#6        #2        #9        #7        #8        #5        #4        #1        #3      

下面是该算法类的完整代码

Public Class clsSudoku
    Private _Num(80) As Integer
    Private _V(9) As Integer
    Private _S As System.Text.StringBuilder
    Private _HasString As Boolean

    Public Sub New(Optional ByVal HasString As Boolean = True)
        Dim I As Integer
        _V(0) = 1
        For I = 1 To 8
            _V(I) = _V(I - 1) * 2
        Next
        _V(9) = 511

        For I = 0 To 80
            _Num(I) = _V(9)
        Next

        _S = New System.Text.StringBuilder
        _HasString = HasString
    End Sub

    Private Function Get1Count(ByVal Value As Integer) As Integer
        Dim C As Integer = 0
        Do While Value > 0
            Value = Value And (Value - 1)
            C += 1
        Loop
        Return C
    End Function

    Private Function RemoveNum(ByVal Row As Integer, ByVal Col As Integer, ByVal Num2 As Integer) As Integer
        Dim Index As Integer = Row * 9 + Col
        If _Num(Index) > 0 Then _Num(Index) = _Num(Index) And Num2
        Return _Num(Index)
    End Function

    Public Function SetNum(ByVal Row As Integer, ByVal Col As Integer, ByVal Num As Integer) As Boolean
        Return SetNumPri(Row - 1, Col - 1, Num - 1)
    End Function

    Public Function SetLine(ByVal Row As Integer, ByVal ParamArray Num() As Integer) As Boolean
        If Num.Length = 0 Then Return True

        Dim I As Integer

        For I = 0 To IIf(Num.Length - 1 > 8, 8, Num.Length - 1)
            If Num(I) > 0 AndAlso SetNumPri(Row - 1, I, Num(I) - 1) = False Then Return False
        Next

        Return True

    End Function

    Private Function SetNumPri(ByVal Row As Integer, ByVal Col As Integer, ByVal Num As Integer) As Boolean
        If (_V(Num) And _Num(Row * 9 + Col)) = 0 Then Return False
        _Num(Row * 9 + Col) = -(Num + 1)
        Num = _V(9) - _V(Num)

        Dim I As Integer, J As Integer

        For I = 0 To 8
            If RemoveNum(I, Col, Num) = 0 Then Return False
            If RemoveNum(Row, I, Num) = 0 Then Return False
        Next

        Dim R1 As Integer = Int(Row / 3) * 3
        Dim C1 As Integer = Int(Col / 3) * 3

        For I = R1 To R1 + 2
            For J = C1 To C1 + 2
                If RemoveNum(I, J, Num) = 0 Then Return False
            Next
        Next

        Return True
    End Function

    Private Function SetNumPri(ByVal Index As Integer, ByVal Num2 As Integer) As Boolean
        Dim Row As Integer = Int(Index / 9)
        Dim Col As Integer = Index Mod 9
        Dim I As Integer
        For I = 0 To 8
            If _V(I) = Num2 Then Exit For
        Next
        Return SetNumPri(Row, Col, I)
    End Function

    Private Function FindMinCell() As Integer
        Dim I As Integer, C As Integer
        Dim tP As Integer = -1, tMin As Integer = 20

        I = 0

        Do
            If _Num(I) > 0 Then
                C = Get1Count(_Num(I))
                If C = 1 Then
                    If SetNumPri(I, _Num(I)) = False Then Return -2

                    AppendString("SetNum " & IndexToXY(I))

                    If I = tP Then
                        tP = -1
                        tMin = 20
                    End If

                    I = -1
                Else
                    If C < tMin Then
                        tP = I
                        tMin = C
                    End If
                End If
            End If
            I += 1
        Loop Until I > 80

        Return tP
    End Function

    Public Function Calculate() As Integer()
        Dim I As Integer
        Dim K As Integer
        Dim Q As New Stack(Of List(Of Integer))
        Dim L As List(Of Integer)

        _S = New System.Text.StringBuilder
        AppendString("Init Matrix")

        K = FindMinCell()

        Do While K <> -1
            If K = -2 Then
                If Q.Count = 0 Then
                    AppendString("Error!!!!!", False)
                    Return Nothing
                End If


                L = Q.Pop

                K = L(82)
                L.RemoveAt(82)

                I = L(81) + 1
                L.RemoveAt(81)

                AppendString("Stack Pop " & Q.Count + 1, False)

                RestoreNum(L)

                K = FindNextK(Q, L, K, I)

            Else
                L = New List(Of Integer)
                L.AddRange(_Num)

                K = FindNextK(Q, L, K, 1)

            End If

        Loop

        AppendString("Calculating Complete!!!!")

        Dim V(80) As Integer
        For I = 0 To 80
            V(I) = -_Num(I)
        Next
        Return V
    End Function

    Private Sub RestoreNum(ByVal L As List(Of Integer))
        Dim I As Integer
        For I = 0 To 80
            _Num(I) = L.Item(I)
        Next

        AppendString("Restore Matrix")
    End Sub

    Private Function GetIndexOfNum(ByVal Num As Integer, ByVal Index As Integer) As Integer
        Dim I As Integer, K As Integer = 0
        For I = 0 To 8
            If (_V(I) And Num) <> 0 Then
                K += 1
                If K = Index Then Return I + 1
            End If
        Next
        Return -1
    End Function

    Private Function FindNextK(ByVal Q As Stack(Of List(Of Integer)), ByVal L As List(Of Integer), ByVal K As Integer, ByVal Index As Integer) As Integer

        Dim J As Integer = GetIndexOfNum(_Num(K), Index)

        Do While J <> -1
            If SetNumPri(K, _V(J - 1)) = True Then
                AppendString("Stack Push " & Q.Count + 1, False)
                AppendString("SetNum MayBe " & IndexToXY(K))

                L.Add(Index)
                L.Add(K)
                Q.Push(L)

                K = FindMinCell()

                Exit Do
            End If

            RestoreNum(L)
            Index += 1
            J = GetIndexOfNum(_Num(K), Index)
        Loop
        If J = -1 Then K = -2
        Return K
    End Function

    Private Function ReturnNumString(ByVal Num As Integer) As String
        If Num < 0 Then Return "#" & (-Num) & " "
        Dim I As Integer, S As String = ""
        For I = 0 To 8
            If (_V(I) And Num) <> 0 Then S &= (I + 1)
        Next
        Return S.PadRight(10)
    End Function

    Private Function ReturnMatrix() As String
        Dim I As Integer, J As Integer, S As String = ""
        For I = 0 To 8
            For J = 0 To 8
                S &= ReturnNumString(_Num(I * 9 + J))
            Next
            S &= vbNewLine
        Next
        Return S
    End Function

    Private Sub AppendString(ByVal Text As String, Optional ByVal AppendMatrix As Boolean = True)
        If _HasString = False Then Exit Sub
        _S.AppendLine(Text)
        _S.AppendLine()
        If AppendMatrix = True Then
            _S.AppendLine(ReturnMatrix)
            _S.AppendLine()
        End If
    End Sub

    Private Function IndexToXY(ByVal Index As Integer) As String
        Return (Int(Index / 9) + 1) & "-" & (Index Mod 9 + 1) & " Num:" & -_Num(Index)
    End Function

    Public Function CalculationString() As String
        Return _S.ToString
    End Function
End Class

HJJ

#include<iostream>
using namespace std;
int sd[10][10];
bool x[10][10];
bool y[10][10];
bool cube[10][10];
int MAP[10][10]={0,0,0,0,0,0,0,0,0,0,
                 0,1,1,1,2,2,2,3,3,3,
                 0,1,1,1,2,2,2,3,3,3,
                 0,1,1,1,2,2,2,3,3,3,
                 0,4,4,4,5,5,5,6,6,6,
                 0,4,4,4,5,5,5,6,6,6,
                 0,4,4,4,5,5,5,6,6,6,
                 0,7,7,7,8,8,8,9,9,9,
                 0,7,7,7,8,8,8,9,9,9,
                 0,7,7,7,8,8,8,9,9,9};
bool exist[10][10];

void print()
{
    for(int i=1;i<=9;i++)
    {
        for(int j=1;j<=9;j++)
            cout<<sd[i][j]<<' ';
            cout<<endl;
    }

}

void mysearch(int i,int j)
{
    if(i==10 && j==1) {print();return;}
    else if(exist[i][j])
    {
       if(j==9) mysearch(i+1,1);
       else mysearch(i,j+1);
    }
    else
    {
        for(int k=1;k<=9;k++)
        {
            if(!x[i][k] && !y[j][k] && !cube[MAP[i][j]][k])
            {
                x[i][k]=true;
                y[j][k]=true;
                cube[MAP[i][j]][k]=true;
                sd[i][j]=k;
                if(j==9) mysearch(i+1,1);
                else mysearch(i,j+1);
                x[i][k]=false;
                y[j][k]=false;
                cube[MAP[i][j]][k]=false;
                sd[i][j]=0;
            }
        }
    }
}

int main()
{
    ///以下是输入，以及数据是否被使用
    for(int i=1;i<=9;i++)
        for(int j=1;j<=9;j++)
        {
            cin>>sd[i][j];
            if(sd[i][j])
            {
                exist[i][j]=true;
                x[i][sd[i][j]]=true;
                y[j][sd[i][j]]=true;
                cube[MAP[i][j]][sd[i][j]]=true;
            }
        }
    ///以下是搜索
    mysearch(1,1);
    return 0;
}

南望山

///LG1784
//sudoku
#include<iostream>
#include<cstdio>
using namespace std;
const int mn=11;
int a[mn][mn];
bool bb[mn][mn];///有没有数
bool b[3][mn][mn];
bool finish=0;
///9行,9列,9个3*3
///0   1   2
void read()
{
    for(int i=0; i<=8; i++)
        for(int j=0; j<=8; j++)
        {
            cin>>a[i][j];
            if(a[i][j])
                bb[i][j]=1;
            else
                bb[i][j]=0;
        }


}
void init()///initialise, 初始化
{
    for(int i=0; i<=2; i++)
        for(int j=0; j<=mn-1; j++)
            for(int k=0; k<=mn-1; k++)
                b[i][j][k]=1;
    for(int i=0; i<=8; i++)
        for(int j=0; j<=8; j++)
        {
            if(!bb[i][j])//没东西，跳
                continue;
            else//有东西
            {
                int block;
                block=(i/3)*3+j/3;
                int aa=a[i][j];
                b[0][i][aa]=0;
                b[1][j][aa]=0;
                b[2][block][aa]=0;
            }
        }
}
void pp()
{
    for(int i=0; i<=8; i++)
    {
        for(int j=0; j<=8; j++)
            cout<<a[i][j]<<" ";
        cout<<endl;
    }
    finish=1;
}
void _fill(int p)
{
    if(finish)
        return;
    if(p>=81)
        pp();
    int tr=p/9;
    int tc=p%9;
    ///cout<<"tr="<<tr<<endl;
    ///cout<<"tc="<<tc<<endl;
    if(bb[tr][tc])//有东西
        _fill(p+1);
    else
    {
        int block;
        block=(tr/3)*3+tc/3;
        for(int i=1; i<=9; i++)//试
        {
            if(b[0][tr][i]&&b[1][tc][i]&&b[2][block][i])
            {
                b[0][tr][i]=0;///用过了
                b[1][tc][i]=0;
                b[2][block][i]=0;
                a[tr][tc]=i;
                bb[tr][tc]=1;
                _fill(p+1);
                ///回溯
                b[0][tr][i]=1;
                b[1][tc][i]=1;
                b[2][block][i]=1;
                bb[tr][tc]=0;
            }
        }
    }
}
int main()
{
    read();
    init();
    /*cout<<endl;
    for(int i=0; i<=8; i++)
    {
        for(int j=0; j<=8; j++)
            cout<<bb[i][j]<<" ";
        cout<<endl;
    }
    cout<<endl;
    for(int i=1; i<=9; i++)
        cout<<b[0][1][i]<<" ";
    cout<<endl;
    */
    _fill(0);
    ///cout<<finish<<endl;
    return 0;
}
/*
0        0        0        0        9        0        0        0        0
0        8        6        2        0        1        0        0        0
0        1        9        3        4        0        0        7        5
5        0        4        0        8        3        0        2        1
9        3        0        0        0        7        0        4        0
6        2        8        4        0        0        0        0        7
8        5        3        9        7        2        4        0        6
1        0        0        8        6        0        2        5        0
0        6        2        1        3        5        7        8        9

*/

lyc

1. #include<iostream>
   
2. using namespace std;
   
3. int sudoku[10][10];
   
4. int group[10][10]= {0,0,0,0,0,0,0,0,0,0,
   
5.                     0,1,1,1,2,2,2,3,3,3,
   
6.                     0,1,1,1,2,2,2,3,3,3,
   
7.                     0,1,1,1,2,2,2,3,3,3,
   
8.                     0,4,4,4,5,5,5,6,6,6,
   
9.                     0,4,4,4,5,5,5,6,6,6,
   
10.                     0,4,4,4,5,5,5,6,6,6,
    
11.                     0,7,7,7,8,8,8,9,9,9,
    
12.                     0,7,7,7,8,8,8,9,9,9,
    
13.                     0,7,7,7,8,8,8,9,9,9
    
14.                    };
    
15. bool r[10][10], l[10][10], g[10][10];
    
16. bool check(int x, int y, int a)
    
17. {
    
18.     if(l[y][a] || r[x][a] || g[group[x][y]][a])
    
19.         return false;
    
20.     return true;
    
21. }
    
22. void bj(int x, int y, int a)
    
23. {
    
24.     l[y][a] = r[x][a] = g[group[x][y]][a] = 1;
    
25. }
    
26. void hs(int x, int y, int a)
    
27. {
    
28.     l[y][a] = r[x][a] = g[group[x][y]][a] = 0;
    
29. }
    
30. void dfs(int x, int y)
    
31. {
    
32.     if(x == 10)
    
33.     {
    
34.         for(int i=1; i<=9; i++)
    
35.         {
    
36.             for(int j=1; j<=9; j++)
    
37.                 cout<<sudoku[i][j]<<" ";
    
38.             cout<<endl;
    
39.         }
    
40.         return ;
    
41.     }
    
42.     int nx = x;
    
43.     int ny = y+1;
    
44.     if(y == 9){
    
45.         nx += 1;
    
46.         ny = 1;
    
47.     }
    
48.     if(sudoku[x][y]){
    
49.         dfs(nx, ny);
    
50.     }
    
51.     else
    
52.     for(int i=1; i<=9; i++){
    
53.         if(check(x, y, i)){
    
54.             sudoku[x][y] = i;
    
55.             bj(x, y, i);
    
56.             dfs(nx, ny);
    
57.             sudoku[x][y] = 0;
    
58.             hs(x, y, i);
    
59.         }
    
60.     }
    
61. }
    
62. int main()
    
63. {
    
64.     for(int i=1; i<=9; i++)
    
65.         for(int j=1; j<=9; j++)
    
66.         {
    
67.             int a;
    
68.             cin>>a;
    
69.             if(a)
    
70.             {
    
71.                 bj(i, j, a);
    
72.                 sudoku[i][j] = a;
    
73.             }
    
74.         }
    
75.     dfs(1, 1);
    
76.     return 0;
    
77. }

复制代码

点评：LYC这个做法比较好，行、列、块的判断很有技巧，只是好像还可以更优化，你们忘记了% / 这些东西吗？

admin

数独就要DLX，不然不乐意。

    数独的DLX构造：9*9个点每个点有9种选择，这构成了DLX的729行，每行、列、阵有限制，均为9行（/列/阵），然后每行（/列/阵）都有九种数的情况，于是就有了3*9*9列，但是因为一个位置只能选一个，所以又有9*9列，每列连接一个点的九种选数情况。

    最终有4*9*9=324列，9*9*9=729行。

    处理：

    有些点已经有数了，但是这并不重要，我们只需要给这个点加上一个行，为它已经选的数，而不要把9种情况都加上，这样在有精确覆盖的情况下（即有解），第四部分的某列在纵向就只连接一个节点，显然这个节点是必选的，所以不会出错（当然你要是依然给这个有值节点在DLX中加9行的话，那我也没招，不要问我为什么错，好吧你不会这么傻吧？）。

    而其它没有初始值的数独点，自然就加旧行了没疑问吧？

    说一个跟空间复杂度相关的事，就是一行有且仅有4个节点，分别在行、列、阵、位置这四部分的列中，那么总节点数（不算辅助节点）就应该最多是729*4，而实际上标准数独都是有唯一解的，所以需要的节点将远远小于这个数。

    再说说时间复杂度：因为我们可以为DLX加一个优化，就是每次选一个列中节点最少的列继续DLX的过程，所以我们虽然保留了已经有值的节点，但是实际上最开始就选择了它们，而若数独有解，这也是必定选择的，所以并不会出现因为层数过多而导致回溯过度而TLE的情况，也就是说它还是很快的。

1. #include <cstdio>  
   
2. #include <cstring>  
   
3. #include <iostream>  
   
4. #include <algorithm>  
   
5. #define N 800  
   
6. #define M 400  
   
7. #define NN 5000  
   
8. #define inf 0x3f3f3f3f  
   
9.   
   
10. #define Li_Sdk 3  
    
11. #define Gi_Sdk 9  
    
12. #define Su_Sdk 81  
    
13. using namespace std;  
    
14. char TS[N];  
    
15. struct DLX  
    
16. {  
    
17.     int elist,eline;  
    
18.     int id[Gi_Sdk+1][Gi_Sdk+1][Gi_Sdk+1];  
    
19.     int eid[4][Gi_Sdk][Gi_Sdk];  
    
20.     bool map[M][N];  
    
21.   
    
22.     int U[NN],D[NN],L[NN],R[NN],C[NN],V[NN];  
    
23.     int H[N],T[M],cnt;  
    
24.     int ans[NN];  
    
25.     bool visit[M],vist[M];  
    
26.   
    
27.     inline void init()  
    
28.     {  
    
29.         int i,j,k,_i,_j;  
    
30.         for(i=1;i<=Gi_Sdk;i++)  
    
31.             for(j=1;j<=Gi_Sdk;j++)  
    
32.                 for(k=1;k<=Gi_Sdk;k++)  
    
33.                     id[i][j][k]=++eline;  
    
34.         for(i=1;i<=Gi_Sdk;i++)/*行*/  
    
35.         {  
    
36.             for(j=1;j<=Gi_Sdk;j++)/*数*/  
    
37.             {  
    
38.                 int A=eid[0][i][j]=++elist;  
    
39.                 for(k=1;k<=Gi_Sdk;k++)/*列*/  
    
40.                 {  
    
41.                     int B=id[i][k][j];  
    
42.                     map[A][B]=1;  
    
43.                 }  
    
44.             }  
    
45.         }  
    
46.         for(i=1;i<=Gi_Sdk;i++)/*列*/  
    
47.         {  
    
48.             for(j=1;j<=Gi_Sdk;j++)/*数*/  
    
49.             {  
    
50.                 int A=eid[1][i][j]=++elist;  
    
51.                 for(k=1;k<=Gi_Sdk;k++)/*行*/  
    
52.                 {  
    
53.                     int B=id[k][i][j];  
    
54.                     map[A][B]=1;  
    
55.                 }  
    
56.             }  
    
57.         }  
    
58.         for(i=0;i<Li_Sdk;i++)for(j=0;j<Li_Sdk;j++)/*九宫格*/  
    
59.         {  
    
60.             for(k=1;k<=Gi_Sdk;k++)/*数*/  
    
61.             {  
    
62.                 int A=eid[2][i*Li_Sdk+j+1][k]=++elist;  
    
63.                 for(_i=1;_i<=Li_Sdk;_i++)for(_j=1;_j<=Li_Sdk;_j++)/*格内点*/  
    
64.                 {  
    
65.                     int B=id[i*Li_Sdk+_i][j*Li_Sdk+_j][k];  
    
66.                     map[A][B]=1;  
    
67.                 }  
    
68.             }  
    
69.         }  
    
70.         for(i=1;i<=Gi_Sdk;i++)for(j=1;j<=Gi_Sdk;j++)/*点的位置*/  
    
71.         {  
    
72.             int A=eid[3][i][j]=++elist;  
    
73.             for(k=1;k<=Gi_Sdk;k++)/*点的9个数*/  
    
74.             {  
    
75.                 int B=id[i][j][k];  
    
76.                 map[A][B]=1;  
    
77.             }  
    
78.         }  
    
79. /*      for(j=1;j<=eline;j++)
    
80.         {
    
81.             for(i=1;i<=elist;i++)
    
82.             {
    
83.                 printf("%d",map[i][j]);
    
84.             }
    
85.             puts("");
    
86.         }
    
87. */      /*本题的数独是正常数独，所以有以下固定信息。*/  
    
88.         /*合计eline即DLX的行有9*9*9=729行，即每个位置的九种数字选择。*/  
    
89.         /*合计elist即DLX的列有4*9*9=324列，即行、列、九宫格、位置的4种精确覆盖*/  
    
90.     }  
    
91.     inline void clear()  
    
92.     {  
    
93.         cnt=0;  
    
94.         memset(U,0,sizeof(U));  
    
95.         memset(D,0,sizeof(D));  
    
96.         memset(L,0,sizeof(L));  
    
97.         memset(R,0,sizeof(R));  
    
98.         memset(C,0,sizeof(C));  
    
99.         memset(H,0,sizeof(H));  
    
100.         memset(T,0,sizeof(T));  
     
101.         memset(ans,0,sizeof(ans));  
     
102.         memset(vist,0,sizeof(vist));  
     
103.         memset(visit,0,sizeof(visit));  
     
104.     }  
     
105.     inline void newnode(int x,int y)  
     
106.     {  
     
107.         C[++cnt]=y;V[cnt]=x;T[y]++;  
     
108.   
     
109.         if(!H[x])H[x]=L[cnt]=R[cnt]=cnt;  
     
110.         else L[cnt]=H[x],R[cnt]=R[H[x]];  
     
111.         R[H[x]]=L[R[H[x]]]=cnt,H[x]=cnt;  
     
112.   
     
113.         U[cnt]=U[y],D[cnt]=y;  
     
114.         U[y]=D[U[y]]=cnt;  
     
115.     }  
     
116.     inline void remove(int x)  
     
117.     {  
     
118.         for(int i=D[x];i!=x;i=D[i])  
     
119.         {  
     
120.             for(int j=R[i];j!=i;j=R[j])  
     
121.             {  
     
122.                 U[D[j]]=U[j];  
     
123.                 D[U[j]]=D[j];  
     
124.                 T[C[j]]--;  
     
125.             }  
     
126.         }  
     
127.         L[R[x]]=L[x];  
     
128.         R[L[x]]=R[x];  
     
129.     }  
     
130.     inline void resume(int x)  
     
131.     {  
     
132.         for(int i=U[x];i!=x;i=U[i])  
     
133.         {  
     
134.             for(int j=L[i];j!=i;j=L[j])  
     
135.             {  
     
136.                 U[D[j]]=j;  
     
137.                 D[U[j]]=j;  
     
138.                 T[C[j]]++;  
     
139.             }  
     
140.         }  
     
141.         L[R[x]]=x;  
     
142.         R[L[x]]=x;  
     
143.     }  
     
144.     inline void build()  
     
145.     {  
     
146.         clear();  
     
147.         int i,j,k;  
     
148.         cnt=4*Su_Sdk;  
     
149.         for(i=1;i<=cnt;i++)  
     
150.         {  
     
151.             U[i]=D[i]=i;  
     
152.             L[i]=L[0],R[i]=0;  
     
153.             L[0]=R[L[0]]=i;  
     
154.         }  
     
155.         for(i=0;i<Gi_Sdk;i++)for(j=0;j<Gi_Sdk;j++)  
     
156.         {  
     
157.             int get=i*Gi_Sdk+j;  
     
158.             int alp=TS[get]-'.';  
     
159.             if(!alp)  
     
160.             {  
     
161.                 for(k=get*Gi_Sdk+1;k<=get*Gi_Sdk+Gi_Sdk;k++)  
     
162.                     for(int temp=1;temp<=elist;temp++)  
     
163.                         if(map[temp][k])newnode(k,temp);  
     
164.             }  
     
165.             else  
     
166.             {  
     
167.                 k=get*Gi_Sdk+TS[get]-'0';  
     
168.                 for(int temp=1;temp<=elist;temp++)  
     
169.                     if(map[temp][k])newnode(k,temp);  
     
170.             }  
     
171.         }  
     
172.     }  
     
173.     inline bool dfs()  
     
174.     {  
     
175.         if(!R[0])return true;  
     
176.         int S=R[0],W=T[S],i,j;  
     
177.         for(i=R[S];i;i=R[i])if(T[i]<W)  
     
178.         {  
     
179.             W=T[i];  
     
180.             S=i;  
     
181.         }  
     
182.         remove(S);  
     
183.         for(i=D[S];i!=S;i=D[i])  
     
184.         {  
     
185.             ans[(V[i]-1)/9]=(V[i]-1)%9+1;  
     
186.             for(j=R[i];j!=i;j=R[j])remove(C[j]);  
     
187.             if(dfs())return true;  
     
188.             for(j=L[i];j!=i;j=L[j])resume(C[j]);  
     
189.         }  
     
190.         resume(S);  
     
191.         return false;  
     
192.     }  
     
193.     inline void ret(){for(int i=0;i<Su_Sdk;i++)printf("%d",ans[i]);}  
     
194. }dlx;  
     
195. int main()  
     
196. {  
     
197. //  freopen("test.in","r",stdin);  
     
198. //  freopen("my.out","w",stdout);  
     
199.     int n,m;  
     
200.     dlx.init();  
     
201.     while(scanf("%s",TS),TS[0]!='e')  
     
202.     {  
     
203.         dlx.build();  
     
204.         dlx.dfs();  
     
205.         dlx.ret();  
     
206.         puts("");  
     
207.     }  
     
208. //  fclose(stdin);  
     
209. //  fclose(stdout);  
     
210.     return 0;  
     
211. }  

复制代码

张笑宇

1. #include<iostream>
   
2. #include<algorithm>
   
3. using namespace std;
   
4. int a[10][10];///a储存原数组
   
5. int r[10][10],c[10][10],group[10][10];///r,c,group三个判断数组
   
6. int i,j;///b判断是否有数字
   
7. void pp()
   
8. {
   
9.     for (i=1; i<=9; i++)
   
10.     {
    
11.         for (j=1; j<=9; j++)
    
12.         {
    
13.             cout<<a[i][j]<<" ";
    
14.         }
    
15.         cout<<endl;
    
16.     }
    
17.     exit(0);
    
18. }
    
19. void dfs(int x,int y)
    
20. {
    
21.     ///cout<<x<<" "<<y<<endl;
    
22.     if (a[x][y]!=0)
    
23.     {
    
24.         if (x==9 && y==9) pp();
    
25.         if (y==9) dfs(x+1,1);
    
26.         else dfs(x,y+1);
    
27.     }
    
28.     if (a[x][y]==0)///没有数字
    
29.     {
    
30.         int k;
    
31.         for (k=1; k<=9; k++) ///填入k
    
32.         {///(x,y)
    
33.             if (r[x][k]&&c[y][k]&&group[(x-1)/3*3+(y-1)/3+1][k])///可以填入
    
34.             {
    
35.                 a[x][y]=k;
    
36.                 r[x][k]=false;
    
37.                 c[y][k]=false;
    
38.                 group[(x-1)/3*3+(y-1)/3+1][k]=false;
    
39.                 if (x==9 && y==9) pp();///如果搜索完了,直接输出
    
40.                 if (y==9) dfs(x+1,1);///搜索下一个
    
41.                 else dfs(x,y+1);
    
42.                 a[x][y]=0;
    
43.                 r[x][k]=true;
    
44.                 c[y][k]=true;
    
45.                 group[(x-1)/3*3+(y-1)/3+1][k]=true;
    
46.             }
    
47.         }
    
48.     }
    
49. }
    
50. int main()
    
51. {
    
52.     for (i=1; i<=9; i++)
    
53.         for (j=1; j<=9; j++) r[i][j]=c[i][j]=group[i][j]=true;
    
54.     for (i=1; i<=9; i++)
    
55.         for (j=1; j<=9; j++)
    
56.         {
    
57.             cin>>a[i][j];
    
58.             if (a[i][j]!=0)
    
59.             {
    
60.                 r[i][a[i][j]]=false;
    
61.                 c[j][a[i][j]]=false;
    
62.                 group[(i-1)/3*3+(j-1)/3+1][a[i][j]]=false;
    
63.             }
    
64.         }
    
65.     dfs(1,1);
    
66.     return 0;
    
67. }

复制代码

张笑宇

附上一组数据：
4 6 0 0 0 1 0 0 0
0 0 2 0 9 6 0 0 0
0 3 0 0 0 0 0 6 8
0 0 0 0 0 0 0 3 7
0 0 0 6 0 7 0 0 0
5 1 7 0 0 0 0 0 0
8 4 0 0 0 0 0 5 0
0 0 0 7 1 0 9 0 0
0 0 0 3 0 0 0 2 4



4 6 5 8 3 1 2 7 9
7 8 2 4 9 6 3 1 5
1 3 9 5 7 2 4 6 8
6 9 4 1 2 5 8 3 7
3 2 8 6 4 7 5 9 1
5 1 7 9 8 3 6 4 2
8 4 1 2 6 9 7 5 3
2 5 3 7 1 4 9 8 6
9 7 6 3 5 8 1 2 4