Question

我对Python比较陌生，我一直在解决checkio.com上的问题，其中一些我觉得非常有趣。

我正在研究的当前问题是数独求解器（如果有人需要我写出数独的规则，我很乐意帮忙）。

我决定尝试使用回溯和递归函数来解决问题。该函数采用2d数组形式的初始数据网格输入，零表示空单元格。

这是我的代码的核心部分：

def checkio(grid,depth=0):
    # Return the solution of the sudoku
    # or False if the current grid has no solution
    # uses backtracking
    # depth is for debugging

    for p in range(9):
        for q in range(9):
            if grid[p][q]==0:
                candidates=cand(p,q,grid)

                for x in candidates:
                    #try each candidate in turn
                    grid[p][q]=x

                    #print out information for debugging
                    print("working on cell (%s,%s) --> depth %s, candidate is %s" % (p,q,depth,x))
                    print_sudoku(grid)

                    h=checkio(grid,depth+1)
                    #h is False unless we have found a full grid
                    if h:      
                        return h

                #return false if no candidate works
                return False

    #if the grid is already full, just return it
    #if the initial input was valid, this algorithm shouldn't produce an invalid grid

    return grid

以下是我正在使用的子程序，它们似乎正常工作：

def print_sudoku(grid):
    # prints out the grid in a way that's easier to parse visually
    for x in grid:
        print(x)


def cand(i,j,grid):
    # returns a list of candidate numbers for the square (i,j)
    rowdata=[]
    for n in range(9):
        if grid[i][n]!=0:
            rowdata.append(grid[i][n])

    coldata=[]
    for n in range(9):
        if grid[n][j]!=0:
            coldata.append(grid[n][j])

    boxdata=[]
    for p in range(9):
        for q in range(9):
            if samebox(p,q,i,j) and grid[p][q]!=0:
                boxdata.append(grid[p][q])

    fulllist=range(1,10)
    cand=list(set(fulllist) - set(rowdata + coldata + boxdata))

    return cand

def samebox(ax,ay,bx,by):
    #returns true if (ax,ay) and (bx,by) are in the same box   
    return ax // 3 == bx // 3 and ay // 3 == by // 3

这是一个带有输入网格的示例函数调用，该输入网格已知（唯一）可解决：

checkio([[0,7,1,6,8,4,0,0,0],[0,4,9,7,0,0,0,0,0],[5,0,0,0,0,0,0,0,0],[0,8,0,0,0,0,5,0,4],[0,0,0,3,0,7,0,0,0],[2,0,3,0,0,0,0,9,0],[0,0,0,0,0,0,0,0,9],[0,0,0,0,0,3,7,2,0],[0,0,0,4,9,8,6,1,0]])

现在，我希望这段代码能够正常运行。但是，如果您运行测试示例，则会失败。通过查看中间网格，我们可以看到一个问题：一旦算法尝试了一个给定的轨道并被卡住（即到达没有候选者的空方块），该函数的后续实例的网格（在较低深度下操作）正在使用的函数填充了函数的先前实例留下的（可能不正确的）值（在更高的深度操作）。

我不明白为什么会这样。我认为在每次函数调用时，都会创建一个新的局部作用域，这样函数的每个实例都可以使用自己的网格，而不会影响其他实例的网格。

我是否误解了变量范围，或者我是否犯了其他错误？谢谢你的时间。

Answer 1

您认为grid变量是每个递归调用范围的本地变量是正确的，但变量只是对对象的引用。

问题是每个范围中的grid变量都引用了同一个对象，即您在开始时传递的list。

在一个范围内修改grid引用的对象时，您将在所有范围内修改它，因为每个范围中的grid变量引用同一个对象。

您要做的是修改传入的网格副本，保持原始网格不变。

您可以复制深度嵌套的数据结构，就像您使用deepcopy()函数一样：

from copy import deepcopy

def checkio(grid,depth=0):
    grid = deepcopy(grid)
    ...

这样当你找到一个无效的解决方案，并在回溯的每一步开始回溯时，网格会保持在你离开那个特定的＆＃34;盲道＆＃34;之前的状态。

Answer 2

您正在传递可变对象。本地名称不会被共享，但它们会引用同一个对象，直到您为它们分配不同的对象为止。

在引用一个可变对象时，通过对它的所有引用（例如，调用堆栈中的所有本地名称）都可以看到对象本身的更改。

在更改网格之前创建副本：

grid = [row[:] for row in grid]

这会将新的列表对象绑定到本地名称grid，其中一个堆栈中的其他本地不绑定。因为外部列表中包含更多可变列表，所以需要复制这些列表（使用整个切片语法）。

递归函数中的变量范围问题[Python]

2 个答案: