Python数独求解器优化：解决RecursionError与提升效率的策略

def solve(d, b):
    for i in range(len(bo)):
        for j in range(len(bo[0])):
            if isempty(i, j):
                while not passt(b, i, j): # 尝试找到一个合法的b
                    b += 1
                if b > 9: # 如果所有数字都尝试过且不合法，需要回溯
                    b = back()
                else: # 找到合法数字，前进
                    forward(b, i, j)
                    b = 1 # 重置b为1，准备下一次尝试
                solve(d+1, b) # 递归调用

import sys

# 初始数独盘面 (0 表示空单元格)
board = [[0,2,1,0,0,3,0,4,0],
         [0,0,0,0,1,0,3,0,0],
         [0,0,3,4,0,5,0,0,0],
         [0,0,0,1,0,0,0,3,8],
         [0,8,9,0,0,0,4,7,0],
         [0,6,0,8,7,0,2,0,0],
         [9,0,0,0,0,0,0,0,4],
         [2,0,0,0,0,0,1,0,0],
         [0,0,0,5,8,2,0,0,0]]

def print_board(board):
    """打印数独盘面"""
    for i in range(len(board)):
        if i % 3 == 0 and i != 0:
            print("- - - - - - - - - - - - ") # 分隔3x3宫格的横线

        for j in range(len(board[0])):
            if j % 3 == 0 and j != 0:
                print(" | ", end="") # 分隔3x3宫格的竖线

            if j == 8:
                print(board[i][j])
            else:
                print(str(board[i][j]) + " ", end="")

def find_empty(board):
    """查找下一个空的单元格 (用0表示)"""
    for r in range(len(board)):
        for c in range(len(board[0])):
            if board[r][c] == 0:
                return (r, c) # 返回行, 列
    return None # 如果没有空单元格，表示数独已填满

def is_valid(board, num, pos):
    """
    检查在给定位置 (pos) 放置数字 (num) 是否合法。
    pos 是 (行, 列) 元组。
    """
    row, col = pos

    # 检查行
    for c in range(len(board[0])):
        if board[row][c] == num and col != c:
            return False

    # 检查列
    for r in range(len(board)):
        if board[r][col] == num and row != r:
            return False

    # 检查3x3宫格
    box_start_row = (row // 3) * 3
    box_start_col = (col // 3) * 3

    for r in range(box_start_row, box_start_row + 3):
        for c in range(box_start_col, box_start_col + 3):
            if board[r][c] == num and (r, c) != pos:
                return False

    return True

def solve_sudoku(board):
    """
    使用回溯算法解决数独。
    如果找到解，返回True；否则返回False。
    """
    find = find_empty(board)
    if not find:
        return True # 没有空单元格，数独已解决

    row, col = find

    for num in range(1, 10): # 尝试数字1到9
        if is_valid(board, num, (row, col)):
            board[row][col] = num # 放置数字

            if solve_sudoku(board): # 递归调用，尝试解决剩余部分
                return True # 如果子问题解决，则当前路径有效

            board[row][col] = 0 # 回溯：如果子问题未解决，撤销当前数字，尝试下一个

    return False # 所有数字都尝试失败，当前路径无解

# 运行求解器
print("原始数独盘面:")
print_board(board)
print("\n开始求解...\n")

if solve_sudoku(board):
    print("数独已解决:")
    print_board(board)
else:
    print("无法解决此数独。")

import sys

sys.setrecursionlimit(1500) # 将递归深度限制设置为1500