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

import sys

# 获取当前的递归限制
# print(sys.getrecursionlimit())

# 设置新的递归限制，例如1500或更高
# 请根据实际需求和系统资源谨慎调整
sys.setrecursionlimit(1500) 

import sys

# 默认数独棋盘
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(bo):
    """
    打印数独棋盘，带分隔线。
    """
    for i in range(len(bo)):
        if i % 3 == 0 and i != 0:
            print("- - - - - - - - - - - - ")

        for j in range(len(bo[0])):
            if j % 3 == 0 and j != 0:
                print(" | ", end="")

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

def find_empty(bo):
    """
    查找棋盘上第一个空的（值为0）单元格。
    返回 (行, 列) 或 None 如果没有空单元格。
    """
    for r in range(len(bo)):
        for c in range(len(bo[0])):
            if bo[r][c] == 0:
                return (r, c) # (row, col)
    return None

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

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

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

    # 检查3x3宫格
    box_r_start = (row // 3) * 3
    box_c_start = (col // 3) * 3

    for r in range(box_r_start, box_r_start + 3):
        for c in range(box_c_start, box_c_start + 3):
            if bo[r][c] == num and (r, c) != pos:
                return False

    return True

def solve_sudoku(bo):
    """
    使用回溯算法递归求解数独。
    如果数独有解，则修改棋盘并返回 True；否则返回 False。
    """
    find = find_empty(bo)
    if not find:
        return True # 没有空单元格，表示数独已解决

    row, col = find

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

            if solve_sudoku(bo): # 递归求解下一个空单元格
                return True # 如果后续求解成功，则当前路径有效

            bo[row][col] = 0 # 如果后续求解失败，回溯：撤销当前数字，尝试下一个

    return False # 尝试了所有数字都无法解决，返回False

# ------------------- 运行求解器 -------------------
if __name__ == "__main__":
    print("原始数独棋盘:")
    print_board(board)
    print("\n" + "="*25 + "\n")

    # 可以选择性地增加递归限制，但通常推荐优化算法本身
    # sys.setrecursionlimit(2000) 

    if solve_sudoku(board):
        print("已解决的数独棋盘:")
        print_board(board)
    else:
        print("数独无解。")