简单数独游戏

游戏1 完整代码

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>

using namespace std;

class Sudoku {
private:
    vector<vector<int>> board; // 数独游戏的矩阵
    vector<vector<bool>> fixed; // 是否为固定数字的标记
    const int N = 9; // 矩阵的大小
public:
    Sudoku() {
        // 构造函数，生成数独游戏的矩阵
        srand(time(NULL));
        board.resize(N, vector<int>(N, 0));
        fixed.resize(N, vector<bool>(N, false));
        generateBoard();
    }

    void generateBoard() {
        // 生成数独游戏的矩阵
        int cnt = 0;
        while (cnt < 30) {
            int x = rand() % N;
            int y = rand() % N;
            if (board[x][y] == 0) {
                int num = rand() % N + 1;
                if (isValid(x, y, num)) {
                    board[x][y] = num;
                    fixed[x][y] = true;
                    cnt++;
                }
            }
        }
    }

    bool isValid(int x, int y, int num) {
        // 判断填入数字是否满足数独游戏的规则
        for (int i = 0; i < N; i++) {
            if (board[x][i] == num || board[i][y] == num) {
                return false;
            }
        }
        int sx = (x / 3) * 3, sy = (y / 3) * 3;
        for (int i = sx; i < sx + 3; i++) {
            for (int j = sy; j < sy + 3; j++) {
                if (board[i][j] == num) {
                    return false;
                }
            }
        }
        return true;
    }

    void printBoard() {
        // 打印数独游戏的矩阵
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (fixed[i][j]) {
                    cout << board[i][j] << " ";
                }
                else {
                    cout << "  ";
                }
            }
            cout << endl;
        }
    }

    bool isComplete() {
        // 判断数独游戏是否已完成
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (board[i][j] == 0 || !isValid(i, j, board[i][j])) {
                    return false;
                }
            }
        }
        return true;
    }

    bool solve(int x, int y) {
        // 递归算法解决数独游戏的矩阵
        if (x == N) return true;
        int nx = x, ny = y + 1;
        if (ny == N) {
            nx++;
            ny = 0;
        }
        if (fixed[x][y]) {
            return solve(nx, ny);
        }
        for (int i = 1; i <= N; i++) {
            if (isValid(x, y, i)) {
                board[x][y] = i;
                if (solve(nx, ny)) {
                    return true;
                }
                board[x][y] = 0;
            }
        }
        return false;
    }
};

int main() {
    Sudoku sudoku;
    cout << "Welcome to Sudoku!" << endl;
    cout << "Please enter row, column and number to fill in, separated by spaces." << endl;
    cout << "For example, \"1 2 3\" means fill in number 3 in row 1, column 2." << endl;
    sudoku.printBoard();
    while (!sudoku.isComplete()) {
        int x, y, num;
        cin >> x >> y >> num;
        if (x < 1 || x > 9 || y < 1 || y > 9 || num < 1 || num > 9) {
            cout << "Invalid input!" << endl;
            continue;
        }
        if (sudoku.isValid(x - 1, y - 1, num)) {
            sudoku.board[x - 1][y - 1] = num;
            sudoku.printBoard();
        }
        else {
            cout << "Invalid move!" << endl;
        }
    }
    cout << "Congratulations, you win!" << endl;
    return 0;
}

上述代码中，Sudoku类封装了数独游戏的矩阵、是否为固定数字的标记和相关的操作函数。在构造函数中，先使用time函数来生成随机数种子，然后调用generateBoard函数来生成数独游戏的矩阵。在generateBoard函数中，使用随机数来填充矩阵的一些位置，并使用isValid函数来判断填入数字是否满足数独游戏的规则。

在主函数中，首先创建一个Sudoku对象sudoku，并调用printBoard函数来打印数独游戏的矩阵。然后使用循环来不断读入玩家的输入，直到数独游戏已完成为止。每次读入玩家的输入后，先使用isValid函数来判断填入数字是否满足数独游戏的规则，如果满足则将数字填入矩阵，并调用printBoard函数来打印数独游戏的矩阵。如果不满足，则提示玩家输入无效。最后使用isComplete函数来判断数独游戏是否已完成，如果已完成则输出祝贺信息。

游戏2

以下是一个简单的C++代码实现一个小型数独游戏的示例，包括生成数独游戏和解决数独游戏两个部分：

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

const int N = 9;

class Sudoku {
private:
    int board[N][N];
    bool used[N][N];
    int cnt;

public:
    Sudoku() : cnt(0) {
        srand(time(NULL));
        initBoard();
    }

    void initBoard() {
        // 初始化数独游戏的矩阵
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                board[i][j] = 0;
                used[i][j] = false;
            }
        }
        // 生成数独游戏的矩阵
        generateBoard(0, 0);
        // 随机挖去一些数字
        int k = 30;
        while (k > 0) {
            int x = rand() % N;
            int y = rand() % N;
            if (board[x][y] != 0) {
                board[x][y] = 0;
                k--;
            }
        }
    }

    void generateBoard(int x, int y) {
        // 回溯算法生成数独游戏的矩阵
        if (x == N) {
            cnt++;
            return;
        }
        int nx = x, ny = y + 1;
        if (ny == N) {
            nx++;
            ny = 0;
        }
        if (board[x][y] != 0) {
            generateBoard(nx, ny);
            return;
        }
        for (int i = 1; i <= N; i++) {
            if (!used[x][i - 1] && !used[i - 1][y] && !used[(x / 3) * 3 + i / 3 - 1][(y / 3) * 3 + i % 3 - 1]) {
                board[x][y] = i;
                used[x][i - 1] = true;
                used[i - 1][y] = true;
                used[(x / 3) * 3 + i / 3 - 1][(y / 3) * 3 + i % 3 - 1] = true;
                generateBoard(nx, ny);
                if (cnt > 1) return;
                board[x][y] = 0;
                used[x][i - 1] = false;
                used[i - 1][y] = false;
                used[(x / 3) * 3 + i / 3 - 1][(y / 3) * 3 + i % 3 - 1] = false;
            }
        }
    }

    bool solveBoard(int x, int y) {
        // 递归算法解决数独游戏的矩阵
        if (x == N) return true;
        int nx = x, ny = y + 1;
        if (ny == N) {
            nx++;
            ny = 0;
        }
        if (board[x][y] != 0) {
            return solveBoard(nx, ny);
        }
        for (int i = 1; i <= N; i++) {
            if (!used[x][i - 1] && !used[i - 1][y] && !used[(x / 3) * 3 + i / 3 - 1][(y / 3) * 3 + i % 3 - 1]) {
                board[x][y] = i;
                used[x][i - 1] = true;
                used[i - 1][y] = true;
                used[(x / 3) * 3 + i / 3 - 1][(y / 3) * 3 + i % 3 - 1] = true;
                if (solveBoard(nx, ny)) {
                    return true;
                }
                board[x][y] = 0;
                used[x][i - 1] = false;
                used[i - 1][y] = false;
                used[(x / 3) * 3 + i / 3 - 1][(y / 3) * 3 + i % 3 - 1] = false;
            }
        }
        return false;
    }

    void printBoard() {
        // 打印数独游戏的矩阵
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cout << board[i][j] << " ";
            }
            cout << endl;
        }
    }
};

int main() {
    Sudoku sudoku;
    sudoku.printBoard();
    cout << endl;
    if (sudoku.solveBoard(0, 0)) {
        sudoku.printBoard();
    }
    else {
        cout << "No solution!" << endl;
    }
    return 0;
}

上述代码中，Sudoku类封装了数独游戏的矩阵、已使用数字的标记、计数器和相关的操作函数。在构造函数中，首先使用time函数来生成随机数种子，然后调用initBoard函数来初始化数独游戏的矩阵并生成数独游戏。在initBoard函数中，先将矩阵的所有元素和标记都初始化为0或false，然后调用generateBoard函数来生成数独游戏的矩阵，并随机挖去一些数字。在generateBoard函数中，使用回溯算法来依次填充矩阵的每个位置，并使用标记来判断是否满足数独游戏的规则。如果成功生成一个数独游戏，计数器cnt加1，直到生成两个不同的数独游戏为止。

在主函数中，首先创建一个Sudoku对象sudoku，并调用printBoard函数来打印生成的数独游戏的矩阵。然后调用solveBoard函数来解决数独游戏的矩阵，并调用printBoard函数来打印解决后