用C++写一个数独游戏，并分成三种不同的难度

以下是一个简单的C语言数独游戏示例，其中包括三种不同的难度级别：简单、中等和困难。代码中使用了递归算法来解决数独谜题，也包括了输入和输出游戏的功能。

#include <stdio.h>
#include <stdlib.h>

#define N 9

int puzzle[N][N] = {{0, 0, 3, 0, 2, 0, 6, 0, 0},
                    {9, 0, 0, 3, 0, 5, 0, 0, 1},
                    {0, 0, 1, 8, 0, 6, 4, 0, 0},
                    {0, 0, 8, 1, 0, 2, 9, 0, 0},
                    {7, 0, 0, 0, 0, 0, 0, 0, 8},
                    {0, 0, 6, 7, 0, 8, 2, 0, 0},
                    {0, 0, 2, 6, 0, 9, 5, 0, 0},
                    {8, 0, 0, 2, 0, 3, 0, 0, 9},
                    {0, 0, 5, 0, 1, 0, 3, 0, 0}};

int solution[N][N];

void print_puzzle(int puzzle[N][N]) {
    int i, j;
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            printf("%d ", puzzle[i][j]);
        }
        printf("\n");
    }
}

int is_valid(int puzzle[N][N], int row, int col, int num) {
    int i, j;
    // 检查行和列是否合法
    for (i = 0; i < N; i++) {
        if (puzzle[row][i] == num) return 0;
        if (puzzle[i][col] == num) return 0;
    }
    // 检查3x3方格是否合法
    int row_start = (row / 3) * 3;
    int col_start = (col / 3) * 3;
    for (i = row_start; i < row_start + 3; i++) {
        for (j = col_start; j < col_start + 3; j++) {
            if (puzzle[i][j] == num) return 0;
        }
    }
    return 1;
}

int solve_puzzle(int puzzle[N][N], int row, int col) {
    int num;
    if (row == N - 1 && col == N) {
        // 解决了所有单元格
        return 1;
    }
    if (col == N) {
        // 到达当前行的末尾，转到下一行
        row++;
        col = 0;
    }
    if (puzzle[row][col] > 0) {
        // 这个单元格已经被填充，跳到下一个单元格
        return solve_puzzle(puzzle, row, col + 1);
    }
    for (num = 1; num <= N; num++) {
        if (is_valid(puzzle, row, col, num)) {
            puzzle[row][col] = num;
            if (solve_puzzle(puzzle, row, col + 1)) {
                return 1;
            }
        }
        // 回溯
        puzzle[row][col] = 0;
    }
    return 0;
}

void copy_puzzle(int puzzle[N][N], int solution[N][N]) {
    int i, j;
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            solution[i][j] = puzzle[i][j];
        }
    }
}

void generate_puzzle(int puzzle[N][N], int difficulty) {
    int i, j, count;
    switch (difficulty) {
        case 1:
            count = 30;
            break;
        case 2:
            count = 40;
            break;
        case 3:
            count = 50;
            break;
        default:
            count = 30;
            break;
    }
    // 生成随机的数独谜题
    for (i = 0; i < N && count > 0; i++) {
        for (j = 0; j < N && count > 0; j++) {
            if (puzzle[i][j] > 0) {
                // 只有空单元格才能被删除
                count--;
                puzzle[i][j] = 0;
            }
        }
    }
}

int main() {
    int difficulty, i, j;
    printf("请选择难度级别（1-简单，2-中等，3-困难）：");
    scanf("%d", &difficulty);
    generate_puzzle(puzzle, difficulty);
    copy_puzzle(puzzle, solution);
    solve_puzzle(solution, 0, 0);
    printf("数独游戏：\n");
    print_puzzle(puzzle);
    printf("\n");
    printf("解决方案：\n");
    print_puzzle(solution);
    return 0;
}

在这个示例中，我们定义了一个9x9的数组表示数独谜题和解决方案。`print_puzzle`函数用于打印数独谜题和解决方案。`is_valid`函数用于检查当前单元格是否合法。`solve_puzzle`函数使用递归算法来解决数独谜题。`copy_puzzle`函数用于复制数独谜题，以便我们可以在生成谜题之前备份谜题。`generate_puzzle`函数使用随机算法生成随机的数独谜题。

我们使用`scanf`函数从用户那里获取难度级别，并根据难度级别生成相应难度的数独谜题。然后，我们使用`copy_puzzle`函数备份谜题，以便可以使用备份的谜题来生成数独游戏。最后，我们打印数独游戏和解决方案。