九宫重排（深度优先遍历）

def dfs(board, step, max_depth, path):
    """
    board: 当前的状态
    step: 当前的步数
    max_depth: 最大深度
    path: 当前的路径
    """
    if step == max_depth:
        # 达到目标状态
        return path
    
    # 搜索当前状态的所有可能性
    for i in range(3):
        for j in range(3):
            if board[i][j] == 0:
                # 空格子
                for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
                    # 四个方向
                    x, y = i + dx, j + dy
                    if 0 <= x < 3 and 0 <= y < 3:
                        # 不越界
                        new_board = [row[:] for row in board]
                        new_board[i][j], new_board[x][y] = new_board[x][y], new_board[i][j]
                        if tuple(map(tuple, new_board)) not in visited:
                            visited.add(tuple(map(tuple, new_board)))
                            res = dfs(new_board, step + 1, max_depth, path + [(i, j)])
                            if res:
                                return res
    return None


def solve(board):
    """
    解决九宫重排问题
    """
    global visited
    visited = set()
    visited.add(tuple(map(tuple, board)))
    for depth in range(1, 32):
        # 最大深度
        res = dfs(board, 0, depth, [])
        if res:
            return res
    return None


if __name__ == '__main__':
    board = [[1, 2, 3], [4, 0, 5], [6, 7, 8]]
    res = solve(board)
    print(res)

  board 表示当前状态，step 表示当前步数，max_depth 表示最大深度，path 表示当前路径。

在 dfs 函数中，首先判断当前状态是否达到目标状态，如果是，返回当前路径，否则，搜索当前状态的所有可能性。如果当前状态可以移动到一个新的状态，且这个状态没有被访问过，就将这个新状态加入到 visited 集合中，并递归调用 dfs 函数来搜索这个新状态。如果找到一个解，就返回这个解的路径；否则，返回 None。

在 solve 函数中，首先初始化 visited 集合，将当前状态加入集合中。然后，从深度 1 开始，不断调用 dfs 函数来搜索，直到找到一个解或者达到最大深度。如果找到一个解，就返回这个解的路径；否则，返回 None。