游戏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函数来打印解决后