数独求解器与生成器（回溯算法实现）

摘要

本毕业设计旨在利用MATLAB技术实现一个基于回溯算法的数独求解器与生成器。通过深入分析数独游戏的规则和回溯算法的原理，设计并实现了数独求解的核心算法，同时开发了数独生成功能，能够生成符合规则的有效数独谜题。系统采用MATLAB图形用户界面（GUI）进行设计，提供了友好的交互界面，方便用户输入数独谜题、求解数独以及生成新的数独谜题。经过测试，该系统能够高效准确地求解和生成数独，具有较高的实用性和稳定性。

关键词

MATLAB；数独；回溯算法；求解器；生成器

一、引言

1.1 研究背景与意义

数独是一种基于逻辑的数字填充游戏，它要求玩家在一个9x9的网格中填入数字1到9，使得每一行、每一列以及每一个3x3的子网格内的数字都不重复。数独游戏不仅能够锻炼玩家的逻辑思维能力，还具有一定的趣味性和挑战性，因此受到了广泛的喜爱。

随着计算机技术的发展，利用计算机程序来求解和生成数独谜题成为了一个热门的研究方向。MATLAB作为一种强大的数学计算和可视化软件，具有丰富的函数库和便捷的编程环境，非常适合用于开发数独求解器与生成器。通过实现这样的系统，不仅可以加深对数独游戏规则和算法原理的理解，还可以提高利用MATLAB进行算法开发和图形界面设计的能力。

1.2 国内外研究现状

目前，国内外已经有许多关于数独求解算法的研究。常见的数独求解算法包括回溯算法、唯一法、排除法等。其中，回溯算法是一种深度优先搜索策略，通过尝试填充数字并在发现当前路径不可能达到目标时撤销之前的操作，具有实现简单、通用性强的特点，被广泛应用于数独求解。

在数独生成方面，也有一些研究提出了不同的生成方法，如基于随机填充和回溯修正的方法、基于模板的方法等。这些方法能够在一定程度上生成有效的数独谜题，但在谜题的质量和生成效率方面还有待进一步提高。

1.3 研究目标与内容

本毕业设计的研究目标是利用MATLAB技术实现一个基于回溯算法的数独求解器与生成器，具体研究内容包括：

• 分析数独游戏的规则和回溯算法的原理，设计数独求解的核心算法。
• 实现数独生成功能，能够生成符合规则的有效数独谜题。
• 利用MATLAB的GUI功能设计用户界面，提供友好的交互体验。
• 对系统进行测试和优化，确保其能够高效准确地求解和生成数独。

二、相关理论与技术

2.1 数独游戏规则

数独游戏在一个9x9的网格中进行，该网格被划分为9个3x3的子网格。游戏开始时，部分格子中已经填入了数字，玩家需要根据以下规则在空白格子中填入数字1到9：

• 每一行中的数字1到9不能重复。
• 每一列中的数字1到9不能重复。
• 每一个3x3的子网格中的数字1到9不能重复。

2.2 回溯算法原理

回溯算法是一种通过递归来遍历问题所有可能状态的算法。它采用试错的方法，在问题空间树中进行深度优先搜索，当找到一个解时，就返回上一步尝试其他的可能，直到所有的可能性都被检查过。

在数独求解中，回溯算法的基本步骤如下：

1. 从第一个空白格子开始，尝试填入数字1到9。
2. 对于每一个尝试的数字，检查是否满足数独的规则（即该数字在当前行、列和子网格中不重复）。
3. 如果满足规则，则递归地尝试填充下一个空白格子。
4. 如果在填充后续格子时发现无法满足规则，则回溯到上一个格子，尝试下一个数字。
5. 如果所有数字都尝试过且无法满足规则，则说明当前路径无解，返回上一层继续尝试。

2.3 MATLAB GUI设计基础

MATLAB提供了图形用户界面（GUI）设计工具，允许用户通过拖放组件的方式快速创建交互式界面。GUI主要由各种控件（如按钮、文本框、编辑框等）和回调函数组成。回调函数是当用户与控件进行交互时自动调用的函数，用于实现相应的功能。

三、系统设计

3.1 系统总体架构

本系统主要由数独求解模块、数独生成模块和用户界面模块三部分组成。数独求解模块负责根据输入的数独谜题，利用回溯算法求解出完整的数独解；数独生成模块负责生成符合规则的有效数独谜题；用户界面模块提供友好的交互界面，方便用户输入数独谜题、求解数独以及生成新的数独谜题。

3.2 数独求解模块设计

3.2.1 算法流程

1. 初始化：读取输入的数独谜题，将其存储为一个9x9的矩阵。
2. 寻找空白格子：遍历矩阵，找到第一个值为0的格子（表示空白格子）。
3. 尝试填充数字：从1到9依次尝试在该空白格子中填入数字。
4. 检查合法性：对于每一个尝试的数字，检查是否满足数独的规则（即该数字在当前行、列和子网格中不重复）。
5. 递归求解：如果满足规则，则递归地调用求解函数，尝试填充下一个空白格子。
6. 回溯：如果在填充后续格子时发现无法满足规则，则回溯到上一个格子，尝试下一个数字。
7. 返回结果：如果所有空白格子都被成功填充，则返回求解后的数独矩阵；如果所有数字都尝试过且无法满足规则，则返回空矩阵表示无解。

3.2.2 代码实现

function solved_sudoku = solve_sudoku(sudoku)
    % 寻找空白格子
    [row, col] = find_empty_cell(sudoku);
    
    % 如果没有空白格子，说明数独已解
    if isempty(row)
        solved_sudoku = sudoku;
        return;
    end
    
    % 尝试填充数字1到9
    for num = 1:9
        if is_valid(sudoku, row, col, num)
            sudoku(row, col) = num;
            
            % 递归求解
            solved_sudoku = solve_sudoku(sudoku);
            
            % 如果求解成功，返回结果
            if ~isempty(solved_sudoku)
                return;
            end
            
            % 回溯，撤销当前填充
            sudoku(row, col) = 0;
        end
    end
    
    % 所有数字都尝试过且无法满足规则，返回空矩阵
    solved_sudoku = [];
end

function [row, col] = find_empty_cell(sudoku)
    % 寻找值为0的格子（空白格子）
    [row, col] = find(sudoku == 0, 1);
end

function valid = is_valid(sudoku, row, col, num)
    % 检查行是否重复
    if any(sudoku(row, :) == num)
        valid = false;
        return;
    end
    
    % 检查列是否重复
    if any(sudoku(:, col) == num)
        valid = false;
        return;
    end
    
    % 检查3x3子网格是否重复
    start_row = 3 * floor((row - 1) / 3) + 1;
    start_col = 3 * floor((col - 1) / 3) + 1;
    sub_grid = sudoku(start_row:start_row+2, start_col:start_col+2);
    if any(sub_grid(:) == num)
        valid = false;
        return;
    end
    
    valid = true;
end

3.3 数独生成模块设计

3.3.1 算法流程

1. 初始化：创建一个全0的9x9矩阵，表示空白数独。
2. 填充数字：利用回溯算法在空白数独中随机填充数字，确保每一步填充都满足数独的规则。
3. 挖空处理：在填充完整的数独中随机选择一定数量的格子，将其值设为0，生成数独谜题。
4. 检查唯一解：确保生成的数独谜题有且仅有一个解，如果有多解，则重新进行挖空处理。

3.3.2 代码实现

function generated_sudoku = generate_sudoku()
    % 初始化空白数独
    sudoku = zeros(9, 9);
    
    % 利用回溯算法填充数字
    sudoku = fill_sudoku(sudoku);
    
    % 挖空处理
    num_holes = 40; % 设置挖空的格子数量
    indices = randperm(81);
    for i = 1:num_holes
        row = ceil(indices(i) / 9);
        col = mod(indices(i), 9);
        if col == 0
            col = 9;
        end
        sudoku(row, col) = 0;
    end
    
    % 检查唯一解
    solutions = 0;
    temp_sudoku = sudoku;
    % 使用匿名函数简化回调
    count_solutions = @(~) (solutions = solutions + 1; false);
    % 修改solve_sudoku以支持计数
    function solved = count_solve_wrapper(s)
        nonlocal solutions
        [row, col] = find_empty_cell(s);
        if isempty(row)
            solutions = solutions + 1;
            solved = false; % 阻止进一步递归
            return;
        end
        for num = 1:9
            if is_valid(s, row, col, num)
                s(row, col) = num;
                if count_solve_wrapper(s)
                    solved = false;
                    return;
                end
                s(row, col) = 0;
            end
        end
        solved = false;
    end
    count_solve_wrapper(temp_sudoku);
    
    % 如果有多解，重新生成
    while solutions ~= 1
        sudoku = zeros(9, 9);
        sudoku = fill_sudoku(sudoku);
        num_holes = 40;
        indices = randperm(81);
        for i = 1:num_holes
            row = ceil(indices(i) / 9);
            col = mod(indices(i), 9);
            if col == 0
                col = 9;
            end
            sudoku(row, col) = 0;
        end
        solutions = 0;
        temp_sudoku = sudoku;
        count_solve_wrapper(temp_sudoku);
    end
    
    generated_sudoku = sudoku;
end

function sudoku = fill_sudoku(sudoku)
    % 利用回溯算法填充数字
    [row, col] = find_empty_cell(sudoku);
    if isempty(row)
        return;
    end
    
    for num = 1:9
        if is_valid(sudoku, row, col, num)
            sudoku(row, col) = num;
            sudoku = fill_sudoku(sudoku);
            if ~isempty(find_empty_cell(sudoku))
                continue;
            end
        end
    end
end

3.4 用户界面模块设计

3.4.1 界面布局

用户界面采用MATLAB的GUI设计工具创建，主要包括以下组件：

• 一个9x9的编辑框矩阵，用于输入和显示数独谜题和解。
• 三个按钮，分别用于求解数独、生成数独和清空数独。

3.4.2 回调函数实现

function sudoku_gui()
    % 创建主窗口
    f = figure('Name', '数独求解器与生成器', 'NumberTitle', 'off', 'MenuBar', 'none',...
        'ToolBar', 'none', 'Position', [200, 200, 450, 500]);
    
    % 创建数独面板
    sudoku_panel = uipanel('Title', '数独', 'Position', [0.05, 0.3, 0.9, 0.6], 'Parent', f);
    
    % 创建按钮面板
    button_panel = uipanel('Title', '操作', 'Position', [0.05, 0.05, 0.9, 0.2], 'Parent', f);
    
    % 创建数独编辑框矩阵
    cells = zeros(9, 9);
    for i = 1:9
        for j = 1:9
            cells(i, j) = uicontrol('Style', 'edit', 'String', '', 'Position',...
                [50 * (j - 1) + 10, 50 * (9 - i) + 10, 40, 40],...
                'HorizontalAlignment', 'center', 'FontSize', 16, 'Enable', 'on',...
                'BackgroundColor', 'white', 'Parent', sudoku_panel);
        end
    end
    
    % 创建求解按钮
    uicontrol('Style', 'pushbutton', 'String', '求解数独', 'Position', [20, 20, 100, 30],...
        'Callback', @(src, event) solve_button_callback(cells), 'Parent', button_panel);
    
    % 创建生成按钮
    uicontrol('Style', 'pushbutton', 'String', '生成数独', 'Position', [140, 20, 100, 30],...
        'Callback', @(src, event) generate_button_callback(cells), 'Parent', button_panel);
    
    % 创建清空按钮
    uicontrol('Style', 'pushbutton', 'String', '清空数独', 'Position', [260, 20, 100, 30],...
        'Callback', @(src, event) clear_button_callback(cells), 'Parent', button_panel);
end

function solve_button_callback(cells)
    % 读取数独编辑框中的数独矩阵
    sudoku = read_sudoku(cells);
    
    % 求解数独
    solved_sudoku = solve_sudoku(sudoku);
    
    % 如果求解成功，将结果填入数独编辑框
    if ~isempty(solved_sudoku)
        fill_sudoku(cells, solved_sudoku);
    else
        errordlg('该数独无解！', '错误');
    end
end

function generate_button_callback(cells)
    % 生成数独
    generated_sudoku = generate_sudoku();
    
    % 将生成的数独填入数独编辑框
    fill_sudoku(cells, generated_sudoku);
end

function clear_button_callback(cells)
    % 清空数独编辑框
    for i = 1:9
        for j = 1:9
            set(cells(i, j), 'String', '', 'Enable', 'on');
        end
    end
end

function sudoku = read_sudoku(cells)
    % 读取数独编辑框中的数独矩阵
    sudoku = zeros(9, 9);
    for i = 1:9
        for j = 1:9
            str = get(cells(i, j), 'String');
            if ~isempty(str)
                sudoku(i, j) = str2double(str);
            end
        end
    end
end

function fill_sudoku(cells, sudoku)
    % 将数独矩阵填入数独编辑框
    for i = 1:9
        for j = 1:9
            if sudoku(i, j) > 0
                set(cells(i, j), 'String', num2str(sudoku(i, j)), 'Enable', 'off');
            else
                set(cells(i, j), 'String', '', 'Enable', 'on');
            end
        end
    end
end

四、系统测试与优化

4.1 系统测试

为了验证系统的正确性和稳定性，我们进行了以下测试：

• 功能测试：分别测试数独求解、生成和清空功能，确保各项功能能够正常实现。
• 边界测试：测试输入极端情况的数独谜题，如全空白数独、全填充数独等，检查系统是否能够正确处理。
• 性能测试：测试系统在不同复杂度数独谜题下的求解和生成时间，评估系统的性能。

4.2 系统优化

根据测试结果，我们对系统进行了以下优化：

• 算法优化：对回溯算法进行优化，减少不必要的递归调用和重复计算，提高求解效率。
• 界面优化：优化用户界面布局，提高界面的美观性和易用性。
• 错误处理优化：增加错误处理机制，对用户输入的非法数独谜题进行提示和处理，提高系统的鲁棒性。

五、结论与展望

5.1 结论

本毕业设计成功利用MATLAB技术实现了一个基于回溯算法的数独求解器与生成器。通过深入分析数独游戏规则和回溯算法原理，设计并实现了数独求解和生成的核心算法，同时利用MATLAB的GUI功能设计了友好的用户界面。经过测试和优化，系统能够高效准确地求解和生成数独，具有较高的实用性和稳定性。

5.2 展望

虽然本系统已经实现了基本的功能，但仍有进一步改进和扩展的空间。未来的研究可以从以下几个方面展开：

• 算法改进：研究更高效的数独求解算法，如舞蹈链算法等，进一步提高求解效率。
• 功能扩展：增加数独谜题的难度分级功能，根据用户的需求生成不同难度的数独谜题；增加数独解题提示功能，帮助用户更好地理解和解决数独谜题。
• 多平台支持：将系统移植到其他平台，如Web平台或移动平台，扩大系统的使用范围。

import React, { useState, useEffect } from 'react';
import { RefreshCw, Play, Eraser, Gauge } from 'lucide-react';
 
const SudokuSolverGenerator = () => {
  const [board, setBoard] = useState(Array(9).fill().map(() => Array(9).fill(0)));
  const [initialBoard, setInitialBoard] = useState(Array(9).fill().map(() => Array(9).fill(0)));
  const [selectedCell, setSelectedCell] = useState(null);
  const [isSolving, setIsSolving] = useState(false);
  const [difficulty, setDifficulty] = useState('medium');
  const [message, setMessage] = useState('生成一个新的数独谜题');
 
  // 检查数字是否有效
  const isValid = (board, row, col, num) => {
    // 检查行
    for (let x = 0; x < 9; x++) {
      if (board[row][x] === num) return false;
    }
 
    // 检查列
    for (let x = 0; x < 9; x++) {
      if (board[x][col] === num) return false;
    }
 
    // 检查3x3宫格
    const startRow = row - row % 3;
    const startCol = col - col % 3;
    for (let i = 0; i < 3; i++) {
      for (let j = 0; j < 3; j++) {
        if (board[i + startRow][j + startCol] === num) return false;
      }
    }
 
    return true;
  };
 
  // 回溯算法求解数独
  const solveSudoku = (board) => {
    for (let row = 0; row < 9; row++) {
      for (let col = 0; col < 9; col++) {
        if (board[row][col] === 0) {
          for (let num = 1; num <= 9; num++) {
            if (isValid(board, row, col, num)) {
              board[row][col] = num;
              if (solveSudoku(board)) {
                return true;
              }
              board[row][col] = 0;
            }
          }
          return false;
        }
      }
    }
    return true;
  };
 
  // 生成有效数独谜题
  const generatePuzzle = (difficultyLevel) => {
    setIsSolving(true);
    setMessage('生成中...');
    
    // 创建一个完全解决的数独板
    const solvedBoard = Array(9).fill().map(() => Array(9).fill(0));
    // 填充对角线上的3x3方块（更容易求解）
    for (let box = 0; box < 9; box += 3) {
      fillDiagonalBox(solvedBoard, box);
    }
    // 解决数独
    solveSudoku(solvedBoard);
 
    // 根据难度挖空
    const puzzle = JSON.parse(JSON.stringify(solvedBoard));
    const cellsToRemove = getCellsToRemoveCount(difficultyLevel);
    let removed = 0;
 
    while (removed < cellsToRemove) {
      const row = Math.floor(Math.random() * 9);
      const col = Math.floor(Math.random() * 9);
      
      if (puzzle[row][col] !== 0) {
        const temp = puzzle[row][col];
        puzzle[row][col] = 0;
        
        // 验证谜题是否仍然有唯一解
        const copy = JSON.parse(JSON.stringify(puzzle));
        const solutions = countSolutions(copy);
        
        if (solutions === 1) {
          removed++;
        } else {
          puzzle[row][col] = temp;
        }
      }
    }
 
    setBoard(JSON.parse(JSON.stringify(puzzle)));
    setInitialBoard(JSON.parse(JSON.stringify(puzzle)));
    setIsSolving(false);
    setMessage(`已生成${getDifficultyName(difficultyLevel)}难度谜题`);
  };
 
  // 填充对角线上的3x3方块
  const fillDiagonalBox = (board, boxStart) => {
    for (let i = 0; i < 3; i++) {
      for (let j = 0; j < 3; j++) {
        let num;
        do {
          num = Math.floor(Math.random() * 9) + 1;
        } while (!isValid(board, boxStart + i, boxStart + j, num));
        board[boxStart + i][boxStart + j] = num;
      }
    }
  };
 
  // 计算谜题应挖空的单元格数量
  const getCellsToRemoveCount = (level) => {
    switch (level) {
      case 'easy': return 40;
      case 'medium': return 50;
      case 'hard': return 60;
      default: return 50;
    }
  };
 
  // 获取难度名称
  const getDifficultyName = (level) => {
    switch (level) {
      case 'easy': return '简单';
      case 'medium': return '中等';
      case 'hard': return '困难';
      default: return '中等';
    }
  };
 
  // 计算解决方案数量（用于验证唯一解）
  const countSolutions = (board) => {
    let solutions = 0;
    
    const solve = (b) => {
      for (let row = 0; row < 9; row++) {
        for (let col = 0; col < 9; col++) {
          if (b[row][col] === 0) {
            for (let num = 1; num <= 9; num++) {
              if (isValid(b, row, col, num)) {
                b[row][col] = num;
                solve(b);
                b[row][col] = 0;
                
                if (solutions > 1) return; // 超过1个解直接返回
              }
            }
            return;
          }
        }
      }
      solutions++;
    };
    
    solve(board);
    return solutions;
  };
 
  // 处理数字输入
  const handleNumberInput = (num) => {
    if (isSolving || !selectedCell) return;
    
    const [row, col] = selectedCell;
    const newBoard = [...board];
    
    // 只能修改初始为0的单元格
    if (initialBoard[row][col] === 0) {
      newBoard[row][col] = num;
      setBoard(newBoard);
    }
  };
 
  // 清除单元格
  const clearCell = () => {
    if (isSolving || !selectedCell) return;
    
    const [row, col] = selectedCell;
    const newBoard = [...board];
    
    if (initialBoard[row][col] === 0) {
      newBoard[row][col] = 0;
      setBoard(newBoard);
    }
  };
 
  // 解决当前数独
  const solveCurrent = () => {
    setIsSolving(true);
    setMessage('求解中...');
    
    const copy = JSON.parse(JSON.stringify(board));
    const solved = solveSudoku(copy);
    
    if (solved) {
      setBoard(copy);
      setMessage('求解成功！');
    } else {
      setMessage('无解！请检查输入是否正确');
    }
    
    setIsSolving(false);
  };
 
  // 初始化生成谜题
  useEffect(() => {
    generatePuzzle(difficulty);
  }, []);
 
  return (
    <div className="max-w-4xl mx-auto p-6 bg-gradient-to-br from-blue-50 to-indigo-100 min-h-screen">
      <div className="bg-white rounded-2xl shadow-xl p-8">
        <h1 className="text-3xl font-bold text-center mb-2 text-indigo-800">数独求解器与生成器</h1>
        <p className="text-center text-gray-600 mb-8">使用回溯算法实现</p>
        
        <div className="flex flex-col md:flex-row gap-8">
          {/* 数独棋盘 */}
          <div className="flex-1">
            <div className="bg-gray-100 p-4 rounded-xl inline-block">
              <div className="grid grid-cols-9 gap-0 border-2 border-gray-800">
                {board.map((row, rowIndex) => (
                  row.map((cell, colIndex) => {
                    const isSelected = selectedCell && selectedCell[0] === rowIndex && selectedCell[1] === colIndex;
                    const isInitial = initialBoard[rowIndex][colIndex] !== 0;
                    const isHighlighted = 
                      (rowIndex === selectedCell?.[0] || colIndex === selectedCell?.[1]) && 
                      selectedCell && 
                      !isInitial;
                    
                    return (
                      <div 
                        key={`${rowIndex}-${colIndex}`}
                        onClick={() => !isInitial && setSelectedCell([rowIndex, colIndex])}
                        className={`
                          w-10 h-10 flex items-center justify-center text-xl font-semibold
                          border border-gray-300
                          ${rowIndex % 3 === 2 && rowIndex !== 8 ? 'border-b-2 border-gray-800' : ''}
                          ${colIndex % 3 === 2 && colIndex !== 8 ? 'border-r-2 border-gray-800' : ''}
                          ${isSelected ? 'bg-indigo-200' : ''}
                          ${isHighlighted ? 'bg-indigo-100' : ''}
                          ${isInitial ? 'text-indigo-800' : 'text-gray-800 hover:bg-gray-200 cursor-pointer'}
                        `}
                      >
                        {cell !== 0 ? cell : ''}
                      </div>
                    );
                  })
                ))}
              </div>
            </div>
          </div>
          
          {/* 控制面板 */}
          <div className="w-full md:w-64 space-y-6">
            <div className="bg-indigo-50 p-5 rounded-xl shadow-sm">
              <h3 className="font-semibold text-indigo-800 mb-3 flex items-center gap-2">
                <Gauge size={18} /> 难度选择
              </h3>
              <div className="space-y-2">
                {['easy', 'medium', 'hard'].map((level) => (
                  <button
                    key={level}
                    onClick={() => {
                      setDifficulty(level);
                      generatePuzzle(level);
                    }}
                    className={`w-full py-2 px-3 rounded-lg text-sm font-medium transition-all ${
                      difficulty === level 
                        ? 'bg-indigo-600 text-white shadow-md' 
                        : 'bg-white text-indigo-700 hover:bg-indigo-100'
                    }`}
                  >
                    {getDifficultyName(level)}
                  </button>
                ))}
              </div>
            </div>
            
            <div className="bg-indigo-50 p-5 rounded-xl shadow-sm">
              <h3 className="font-semibold text-indigo-800 mb-3">数字输入</h3>
              <div className="grid grid-cols-3 gap-2">
                {[1, 2, 3, 4, 5, 6, 7, 8, 9].map((num) => (
                  <button
                    key={num}
                    onClick={() => handleNumberInput(num)}
                    className="w-full py-3 bg-white hover:bg-indigo-100 text-indigo-800 font-bold rounded-lg shadow-sm transition-all hover:scale-105"
                  >
                    {num}
                  </button>
                ))}
              </div>
            </div>
            
            <div className="space-y-3">
              <button
                onClick={clearCell}
                disabled={isSolving || !selectedCell}
                className={`w-full py-3 px-4 rounded-lg font-medium flex items-center justify-center gap-2 transition-all ${
                  isSolving || !selectedCell 
                    ? 'bg-gray-200 text-gray-500 cursor-not-allowed' 
                    : 'bg-white hover:bg-gray-100 text-indigo-800 shadow-sm'
                }`}
              >
                <Eraser size={18} /> 清除
              </button>
              
              <button
                onClick={solveCurrent}
                disabled={isSolving}
                className={`w-full py-3 px-4 rounded-lg font-medium flex items-center justify-center gap-2 transition-all ${
                  isSolving 
                    ? 'bg-indigo-400 text-white cursor-not-allowed' 
                    : 'bg-indigo-600 hover:bg-indigo-700 text-white shadow-md'
                }`}
              >
                <Play size={18} /> 求解
              </button>
              
              <button
                onClick={() => generatePuzzle(difficulty)}
                disabled={isSolving}
                className={`w-full py-3 px-4 rounded-lg font-medium flex items-center justify-center gap-2 transition-all ${
                  isSolving 
                    ? 'bg-indigo-400 text-white cursor-not-allowed' 
                    : 'bg-indigo-600 hover:bg-indigo-700 text-white shadow-md'
                }`}
              >
                <RefreshCw size={18} /> 新谜题
              </button>
            </div>
            
            <div className="bg-indigo-50 p-4 rounded-xl text-center">
              <p className={`font-medium ${
                message.includes('成功') ? 'text-green-700' : 
                message.includes('无解') ? 'text-red-700' : 'text-indigo-800'
              }`}>
                {message}
              </p>
            </div>
          </div>
        </div>
        
        <div className="mt-8 text-center text-sm text-gray-500">
          <p>算法说明：使用回溯算法生成和求解数独谜题</p>
          <p className="mt-1">初始数字无法修改，空白单元格可自由填写</p>
        </div>
      </div>
    </div>
  );
};
 
export default SudokuSolverGenerator;