python – 解决数独的算法

我想在python中编写一个代码来解决数独谜题.你们对这个目的的好算法有什么想法吗？我在网上读了一个关于算法的地方,通过用所有可能的数字填充整个框来解决它,然后将已知值插入相应的框中.从已知值的行和列中删除已知值.如果你们知道更好的话算法比这个请帮我写一个.另外,我很困惑,我应该如何读取用户的已知值.通过控制台逐个输入值非常困难.除了使用gui之外,还有什么简单的方法吗？

解决方法:

这是我在Python中的数独求解器.它使用简单的回溯算法来解决难题.
为简单起见,不进行输入验证或花哨输出.这是解决问题的最低限度代码.

算法

>查找给定单元格的所有合法值
>对于每个合法值,Go递归并尝试解决网格问题

解

它需要9X9网格部分填充数字.值为0的单元格表示未填充.

码

def findNextCellToFill(grid, i, j):
        for x in range(i,9):
                for y in range(j,9):
                        if grid[x][y] == 0:
                                return x,y
        for x in range(0,9):
                for y in range(0,9):
                        if grid[x][y] == 0:
                                return x,y
        return -1,-1

def isValid(grid, i, j, e):
        rowOk = all([e != grid[i][x] for x in range(9)])
        if rowOk:
                columnOk = all([e != grid[x][j] for x in range(9)])
                if columnOk:
                        # finding the top left x,y co-ordinates of the section containing the i,j cell
                        secTopX, secTopY = 3 *(i//3), 3 *(j//3) #floored quotient should be used here. 
                        for x in range(secTopX, secTopX+3):
                                for y in range(secTopY, secTopY+3):
                                        if grid[x][y] == e:
                                                return False
                        return True
        return False

def solveSudoku(grid, i=0, j=0):
        i,j = findNextCellToFill(grid, i, j)
        if i == -1:
                return True
        for e in range(1,10):
                if isValid(grid,i,j,e):
                        grid[i][j] = e
                        if solveSudoku(grid, i, j):
                                return True
                        # Undo the current cell for backtracking
                        grid[i][j] = 0
        return False

测试代码

>>> input = [[5,1,7,6,0,0,0,3,4],[2,8,9,0,0,4,0,0,0],[3,4,6,2,0,5,0,9,0],[6,0,2,0,0,0,0,1,0],[0,3,8,0,0,6,0,4,7],[0,0,0,0,0,0,0,0,0],[0,9,0,0,0,0,0,7,8],[7,0,3,4,0,0,5,6,0],[0,0,0,0,0,0,0,0,0]]
>>> solveSudoku(input)
True
>>> input
[[5, 1, 7, 6, 9, 8, 2, 3, 4], [2, 8, 9, 1, 3, 4, 7, 5, 6], [3, 4, 6, 2, 7, 5, 8, 9, 1], [6, 7, 2, 8, 4, 9, 3, 1, 5], [1, 3, 8, 5, 2, 6, 9, 4, 7], [9, 5, 4, 7, 1, 3, 6, 8, 2], [4, 9, 5, 3, 6, 2, 1, 7, 8], [7, 2, 3, 4, 8, 1, 5, 6, 9], [8, 6, 1, 9, 5, 7, 4, 2, 3]]

以上是非常基本的回溯算法,在很多地方都有解释.但是我遇到的最有趣和自然的数独解决策略是从here开始的this one

标签：sudoku,python,algorithm
来源： https://codeday.me/bug/20190928/1826651.html