如何基于已解数独棋盘随机挖空生成新的数独谜题

核心逻辑是随机选取位置替换为0，同时保证挖空后的棋盘仅存在唯一解，避免出现多解导致题目无效，具体实现步骤如下：

实现步骤 #

• 准备已验证的数独终局棋盘，也就是你已经求解完成的完整棋盘，示例的4阶终局如下：

board = [[2, 1, 3, 4], 
         [3, 4, 1, 2], 
         [1, 2, 4, 3],  
         [4, 3, 2, 1]]

• 根据预期难度确定挖空数量：4阶数独新手难度可以挖3-4个空，进阶难度挖5-6个；9阶数独入门难度挖25-30个，中等难度挖35-40个，高难度可挖45-50个。
• 随机打乱所有棋盘位置的顺序，依次尝试挖空：每挖空一个位置后，校验当前剩余棋盘的解的数量，如果仅存在1个解则保留本次挖空，否则把数值填回，换其他位置尝试，直到挖够预设的空位数。

完整Python实现代码 #

import random
import copy

# 校验填入的数值是否符合数独规则
def is_valid(board, row, col, num, size=4, box_size=2):
    # 校验行
    for i in range(size):
        if board[row][i] == num:
            return False
    # 校验列
    for i in range(size):
        if board[i][col] == num:
            return False
    # 校验小宫格
    box_row_start = (row // box_size) * box_size
    box_col_start = (col // box_size) * box_size
    for i in range(box_size):
        for j in range(box_size):
            if board[box_row_start + i][box_col_start + j] == num:
                return False
    return True

# 统计当前棋盘的解数量，超过1个就提前终止计算提升效率
def count_solutions(board, size=4, box_size=2):
    for row in range(size):
        for col in range(size):
            if board[row][col] == 0:
                total = 0
                for num in range(1, size + 1):
                    if is_valid(board, row, col, num, size, box_size):
                        board[row][col] = num
                        total += count_solutions(board, size, box_size)
                        board[row][col] = 0
                        if total > 1:
                            return total
                return total
    return 1

# 挖空生成谜题函数
def generate_puzzle(original_board, dig_num=5, size=4, box_size=2):
    puzzle = copy.deepcopy(original_board)
    # 生成所有棋盘坐标并打乱顺序
    all_positions = [(i, j) for i in range(size) for j in range(size)]
    random.shuffle(all_positions)
    dug_count = 0
    for (row, col) in all_positions:
        if dug_count >= dig_num:
            break
        temp_val = puzzle[row][col]
        puzzle[row][col] = 0
        # 校验解的唯一性
        if count_solutions(copy.deepcopy(puzzle), size, box_size) != 1:
            puzzle[row][col] = temp_val
        else:
            dug_count += 1
    return puzzle

# 测试运行
if __name__ == "__main__":
    # 你的原始4阶数独终局
    final_board = [[2, 1, 3, 4], 
                   [3, 4, 1, 2], 
                   [1, 2, 4, 3],  
                   [4, 3, 2, 1]]
    # 生成挖5个空的4阶数独谜题
    new_puzzle = generate_puzzle(final_board, dig_num=5)
    # 打印生成的谜题
    for row in new_puzzle:
        print(row)

扩展说明 #

• 如果需要生成9阶数独，只需要调用generate_puzzle时传入参数size=9、box_size=3即可，其余逻辑无需修改。
• 如果是做休闲向的简易数独，不需要严格保证唯一解，可以直接移除唯一性校验的逻辑，直接随机挖空即可，运行效率会高很多。
• 可以按需调整挖空逻辑，比如挖对称位置的空，让生成的谜题更美观。

内容的提问来源于stack exchange，提问作者haz23