python解数独谜题思路和代码分享

数独简介

         数独（shù dú）是源自18世纪瑞士的一种数学游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫（3*3）内的数字均含1-9，不重复。

数独基础规则1

        数独的每个单元格内容要满足每一行、每一列、每一个粗线宫（3*3）内的数字均含1-9，不重复。根据这条规则，我们能很容易得出以下判断方法：

 # 基础校验规则，检验num是否符合行列九宫格三项
    def base_rule(row, col, num):
        # 检查行
        for i in range(n):
            if board[row][i] == num:
                return False
        # 检查列
        for i in range(n):
            if board[i][col] == num:
                return False
        # 检查 3x3 方格内是否存在相同数字
        start_row = 3 * (row // 3)
        start_col = 3 * (col // 3)
        for i in range(3):
            for j in range(3):
                if board[start_row + i][start_col + j] == num:
                    return False
        return True

 如果我们填入了一个值，他满足行，列，九宫格都未出现过，那么他便是这个单元格中的一个“可能值“

 可能值规则

        什么是可能值？对于一个数独的空位置来说，没有到达一定的深度之前，我们这个空位使用规则一能满足的值便是可能值，一个空位置里，有一个或多个可能值的存在

[[5], [3], [1, 2, 4], [2, 4], [7], [4, 8], [1, 4, 9], [2, 8], [1, 2, 4]]
[[6], [2, 4, 7], [2, 4, 7], [1], [9], [5], [3, 4, 7], [2, 3, 7, 8], [2, 3, 4]]
[[1, 2, 4], [9], [8], [2, 4], [2], [3, 4], [1, 3, 4, 5, 7], [6], [1, 2, 3, 4, 5]]
[[8], [2], [1, 2, 5], [1, 4, 5, 7, 9], [6], [1, 4, 5, 9], [4, 5, 7, 9], [2, 7], [3]]
[[4], [2], [2, 5], [8], [5, 7, 9], [3], [5, 7, 9], [2, 7], [1]]
[[7], [3], [1, 3, 5], [1, 4, 5, 9], [2], [1, 4, 5, 9], [4, 5, 9], [8], [6]]
[[1, 4, 9], [6], [1, 3, 4, 5, 7], [5, 7], [5, 7], [3, 5], [2], [8], [1, 3, 4]]
[[2, 8], [2, 3, 7, 8], [2, 3, 7], [4], [1], [9], [3], [3, 6], [5]]
[[1, 2, 4], [2, 3, 4], [1, 2, 3, 4, 5], [2, 5], [8], [3, 5], [1, 3, 4], [7], [9]]

图1、一个数独内可能值举例

这样看可能会比较抽象，但是我们结合原始数独来分析：

5 3 0 | 0 7 0 | 0 0 0   

6 0 0 | 1 9 5 | 0 0 0

0 9 8 | 0 0 0 | 0 6 0

---------------------

8 0 0 | 0 6 0 | 0 0 3

4 0 0 | 8 0 3 | 0 0 1

7 0 0 | 0 2 0 | 0 0 6

---------------------

0 6 0 | 0 0 0 | 2 8 0

0 0 0 | 4 1 9 | 0 0 5

0 0 0 | 0 8 0 | 0 7 9

比如我们看第一行的第三个，[1,2,4]是该空位的三个可能值，因为其他数字在行列九宫格出现过，所以这一空我们只能在这三个中选择其中之一，那么该如何得出可能值呢？

 # 消除规则一，经过base_rule筛选后的可能值
    def rule_1():
        list_3d = [[[] for _ in range(9)] for _ in range(9)]
        for row in range(9):
            for col in range(9):
                if board[row][col] != 0:
                    list_3d[row][col].append(board[row][col])
                else:
                    for i in range(1, 10):
                        if base_rule(row, col, i):
                            list_3d[row][col].append(i)
        # print("规则一之后")
        # for row in range(9):
        #     print(list_3d[row])
        #     print()
        return list_3d

board是我们的原始数组，我创建的list_3d类是一个二维列表，这个二维列表的每个元素又是一个列表，从图1我们便可以看出。使用if判断不为零的直接放入，而为0的（空位置）则需要用base_rule循环判断，打印列表，你也能得到类似图一的效果。

消除规则二

        原理：如果可能某个值在行、列、九宫格里只出现过一次，那么我们便可以判定这个空位置的值就是这个只出现过一次的值。

这个原理也可以反向理解，如果一个可能值只在这个位置出现了，而行列九宫格中的其他地方没有，是不是表示这个值就只能待在这个空，否则他无处可去了呢？

通过这项规则，我们似乎又可以确定一些空位置该填什么了：

 # 基础消除规则2，如果可能值满足在行列九宫只出现1次，则可以确定为该值
    def base_rule2(row, col, num, current_board):
        flag1 = True
        flag2 = True
        flag3 = True
        for i in range(n):
            if i != col and num in current_board[row][i]:
                flag1 = False
                break
            # 检查列
        for i in range(n):
            if i != row and num in current_board[i][col]:
                flag2 = False
                break
            # 检查 3x3 方格内是否存在相同数字
        start_row = 3 * (row // 3)
        start_col = 3 * (col // 3)
        for i in range(start_row, start_row + 3):
            if not flag3:
                break
            for j in range(start_col, start_col + 3):
                if num in current_board[i][j] and (i != row or j != col):
                    flag3 = False
                    break
        # if flag1 or flag2 or flag3:
        # print("检查到唯一值" + str(row) + "," + str(col) + "," + str(num) + str(flag1) + ",
        # " + str(flag2) + "," + str(flag3))

        return flag1 or flag2 or flag3

并且，我们还能通过确认这个值，再次消除一些可能值，假如[1,2,4]这三个里，我确认了1是唯一的，那么除了他所在的那个单元格，与他同行，同列，同九宫格的所有的1都可以被消除：

 # 通过规则二检测到可能值后，清除行，列，九宫格内所有可能值，被间接消除的只剩一个是会继续调用
    def clear_row(row, col, num, current_board):
        for i in range(9):
            if i != col and num in current_board[row][i]:
                current_board[row][i].remove(num)
                if len(current_board[row][i]) == 1:
                    clear_col(row, i, current_board[row][i][0], current_board)
                    clear_cell(row, i, current_board[row][i][0], current_board)
                    # print("得到值，继续消除列和九宫" + str(current_board[row][i][0]))

    def clear_col(row, col, num, current_board):
        for i in range(9):
            if i != row and num in current_board[i][col]:
                current_board[i][col].remove(num)
                if len(current_board[i][col]) == 1:
                    clear_row(i, col, current_board[i][col][0], current_board)
                    clear_cell(i, col, current_board[i][col][0], current_board)
                    # print("得到值，继续消除行和九宫" + str(current_board[i][col][0]))

    def clear_cell(row, col, num, current_board):
        start_row = 3 * (row // 3)
        start_col = 3 * (col // 3)
        for i in range(start_row, start_row + 3):
            for j in range(start_col, start_col + 3):
                if num in current_board[i][j] and (i != row or j != col):
                    current_board[i][j].remove(num)
                    if len(current_board[i][j]) == 1:
                        clear_row(i, j, current_board[i][j][0], current_board)
                        clear_col(i, j, current_board[i][j][0], current_board)
                        # print("得到值，继续消除行和列" + str(current_board[i][j][0]))

注意，我为什么说间接消除的要多执行一次消除？比如 [1,5]......[2,5]在同一行，当遍历到[2,5]时，确认可能值只有5，那么[1,5]中会被消除的只剩[1]，相当于又确认了一个值，所以我们要移到[1,5]所在的行列继续进行消除

搜索+回溯

        经过一次消除规则1和消除规则2的处理，我们数独空位里的可能值也少了很多，这个时候我们可以选择直接遍历+回溯带入可能值来进行最终的解数独，也可以使用搜索+回溯来解，这里我选择的是搜索+回溯，每次搜索可能值最少的那个位置开始试

  def search(result):
        current_len = 9999
        current_row = 9999
        current_col = 9999
        for row in range(9):
            for col in range(9):
                if current_len >= len(result[row][col]) > 1:
                    current_len = len(result[row][col])
                    current_row = row
                    current_col = col
        return current_row, current_col

    # 经过一二消除后，开始递归可能值解数独
    def recursion(result):
        if isOver(result):
            return True
        row, col = search(result)

        for i in result[row][col]:
            if board[row][col] == 0 and base_rule(row, col, i):
                temp = copy.deepcopy(result[row][col])
                result[row][col] = [i]
                board[row][col] = i
                if recursion(result):
                    return True
                    # 撤销选择，将之前移除的候选数字添加回去并重置为0
                result[row][col] = temp
                board[row][col] = 0
        return False

到这里解数独大部分程序都完成了，最后根据自己需要，选择输入值，判断数独结束方法等

最终执行效果：

 解50个大约14s,简单数独平均0.01s一个，但是这50个里有两个解的很慢，一个2s，一个8s,这点笔者也还没研究出是为什么

 

经过分析后发现是搜索方法的问题，注释掉搜索方法，重新编写回溯执行，只需要2s