扫雷实现详解【递归展开+首次必展开+标记雷+取消标记雷】

2024-05-04 21:28
文章标签 标记 实现 详解 递归 取消 展开 扫雷 首次

本文主要是介绍扫雷实现详解【递归展开+首次必展开+标记雷+取消标记雷】，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

扫雷

  • 一.扫雷设计思路
  • 二.扫雷代码逐步实现
    • 1.创建游戏菜单
    • 2.初始化棋盘
    • 3.打印棋盘
    • 4.随机布置雷
    • 5.统计周围雷的个数
    • 6.递归展开棋盘
    • 7.标记雷
    • 8.删除雷的标记
    • 9.保证第一次排雷的安全性+棋盘必定展开
    • 10.排查雷
    • 11.判断输赢
  • 三.扫雷总代码
  • 四.截图

一.扫雷设计思路

 1.创建游戏菜单。
 2.初始化棋盘。
 3.打印棋盘。
 4.随机布置雷。
 5.选择：排查雷，标记雷，或取消标记雷。
 7.循环，直到游戏结束。
 8.当然其中的细节处还有很多，带着你一步一步实现。

二.扫雷代码逐步实现

1.创建游戏菜单

void Menu()
{printf("-------------------------------------\n");printf("|              扫雷游戏！           |\n");printf("|        0.exit        1.play       |\n");printf("-------------------------------------\n");
}

当然可以美化一下，发挥你天马行空的想象力!

2.初始化棋盘

  • 扫雷的过程中，布置的雷的信息和排查出的周围雷的信息（周围雷的个数）都需要存储，所以我们需要⼀定的数据结构来存储这些信息。不妨用9 x 9的棋盘上布置的雷的信息和排查出的周围雷的信息（周围雷的个数），我们首先想到的就是创建⼀个9 x 9的数组来存放这些信息。1代表雷，0代表不是雷。

如图：
在这里插入图片描述
由于我们还要统计某个坐标周围雷的个数，所以要访问周围数组元素。

  • 假设我们排查(2,5)这个坐标时，我们访问周围的⼀圈8个黄色位置，统计周围雷的个数是1。
  • 假设我们排查(8,6)这个坐标时，我们访问周围的⼀圈8个黄色位置，统计周围雷的个数时，最下面的三个坐标就会越界。
  • 为了防止越界，我们在设计的时候，给数组扩大一圈，雷还是布置在中间的9 x 9的坐标上，周围一圈不去布置雷就⾏，这样就解决了越界的问题。所以我们将存放数据的数组创建成11 x 11是比较合适。

如图：
在这里插入图片描述

  • 再继续分析，我们在棋盘上布置了雷，棋盘上雷的信息（1）和非雷的信息（0），假设我们排查了某⼀个位置后，这个坐标处不是雷，这个坐标的周围有1个雷，那我们需要将排查出的雷的数量信息记录存储，并打印出来，作为排雷的重要参考信息。那这个雷的个数信息存放在哪里呢？如果存放在布置雷的数组中，这样雷的信息和雷的个数信息就可能或产生混淆和打印上的困难。

  • 我们肯定有办法解决，比如：雷和非雷的信息不要使用数字，使用某些字符就行，这样就避免冲突了，但是这样做棋盘上有雷和非雷的信息，还有排查出的雷的个数信息，就比较混杂，不够方便。

  • 我们采用另外⼀种方案，设置两个棋盘，我们专门给⼀个棋盘（对应⼀个数组mine）存放布置好的雷的信息，再给另外⼀个棋盘（对应另外⼀个数组show）存放排查出的雷的信息。这样就互不干扰了，把雷布置到mine数组，在mine数组中排查雷，排查出的数据存放在show数组，并且打印show数组的信息给后期排查参考。

  • 为了保持神秘，show数组开始时初始化为字符 * ，为了保持两个数组的类型⼀致，可以使用同⼀套函数处理，mine数组最开始也初始化为字符’0’，布置雷改成’1’。

如图：
在这里插入图片描述

给出伪代码参考：

#define ROW 9//扫雷的行数
#define COL 9//扫雷的列数
#define ROWS ROW + 2//创建二维数组的行数
#define COLS COL + 2//创建二维数组的列数
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{int i = 0;for (i = 0;i < rows;i++){int j = 0;for (j = 0;j < cols;j++){board[i][j] = set;}}
}
//创建两个字符二维数组
char mine[ROWS][COLS];//存放该点是不是雷    （0代表不是雷，1代表是雷）
char show[ROWS][COLS];//存放该点周围有多少雷（数字代表周围有多少雷，*代表未知）

3.打印棋盘

代码1：

//定义打印棋盘的函数
void PrintBoard(char board[ROWS][COLS], int row, int col)
{int i = 0;//辅助观察棋盘for (i = 0;i <= row;i++){printf("%d ", i);}printf("\n");//打印棋盘for (i = 1;i <= row;i++){printf("%d ", i);//辅助观察棋盘int j = 0;for (j = 1;j <= col;j++){printf("\033[36m%c \033[0m", board[i][j]);//打印蓝色字符}printf("\n");}printf("--------扫雷--------\n");//辅助观察棋盘
}

为了使棋盘看起来更舒服，我们可以美化一下棋盘。
代码2：

//定义打印棋盘的函数
void PrintBoard(char board[ROWS][COLS], int row, int col)
{printf("\033[34m-----------------扫雷-----------------\033[0m\n");//辅助观察棋盘int i = 0;//辅助观察棋盘printf("0 |");for (i = 1;i <= row;i++){printf(" %-2d", i);if (i < row){printf("|");}}printf("\n");printf("--|");for (i = 1; i <= col; i++){printf("---");if (i < row){printf("|");}}printf("\n");//打印棋盘for (i = 1;i <= row;i++){printf("%-2d|", i);//辅助观察棋盘int j = 0;for (j = 1;j <= col;j++){if (board[i][j] == '1' || board[i][j] == '5'){printf("\033[36m %c \033[0m", board[i][j]);//打印蓝色}else if (board[i][j] == '2' || board[i][j] == '6'){printf("\033[32m %c \033[0m", board[i][j]);//打印绿色}else if (board[i][j] == '3' || board[i][j] == '7'){printf("\033[31m %c \033[0m", board[i][j]);//打印红色}else if (board[i][j] == '4' || board[i][j] == '8'){printf("\033[35m %c \033[0m", board[i][j]);//打印紫色}else if (board[i][j] == '!'){printf("\033[31m %c \033[0m", board[i][j]);//打印红色}else{printf(" %c ", board[i][j]);//打印白色}if (j < col){printf("|");}}//辅助观察棋盘printf("\n");if (i < row){printf("--|");}for (j = 1; j <= col; j++){if (i < row){printf("---");if (j < col){printf("|");}}}printf("\n");}
}

效果如下：
在这里插入图片描述

4.随机布置雷

  • 这里用到了随机数，不知道的小伙伴，可以去我写的猜字小游戏看看
  • 点击即可前往猜字小游戏
//定义布置雷的函数
void SetMine(char mine[ROWS][COLS], int row, int col)
{int count = MINE_NUMBER;//雷的个数while (count){int x = rand() % row + 1;int y = rand() % col + 1;if (mine[x][y] != '1'){mine[x][y] = '1';//如果该坐标不是雷，则布置雷count--;}}
}

5.统计周围雷的个数

代码1：暴力取遍

//统计周围雷的个数的函数1.0
int AroundMineCount(char mine[ROWS][COLS], int x, int y)
{return mine[x - 1][y] + mine[x - 1][y - 1] +mine[x][y - 1] + mine[x + 1][y - 1] +mine[x + 1][y] + mine[x + 1][y + 1] +mine[x][y + 1] + mine[x - 1][y + 1] - 8 * '0';
}

代码2：循环取遍

//统计周围雷的个数的函数
int AroundMineCount(char mine[ROWS][COLS], int x, int y)
{int i = 0;int count = 0;for (i = x - 1;i <= x + 1;i++){int j = 0;for (j = y - 1;j <= y + 1;j++){count += mine[i][j] - '0';}}return count;
}

6.递归展开棋盘

  • 已知该坐标不是雷，若周围没有雷，该坐标赋为空，再向外扩展（达到展开一片的效果），否则只显示该坐标周围雷的个数。
//已知该坐标不是雷，若周围没有雷,该坐标赋为空，再向外扩展（达到展开一片的效果），否则只显示该坐标周围雷的个数
void ExpandAround(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//限制在棋盘内展开，防止下标越界{int count = AroundMineCount(mine, x, y);//获取雷数if (count == 0)//周围没雷，递归展开{show[x][y] = ' ';//周围没雷，赋值为空格int i = 0;for (i = x - 1;i <= x + 1;i++){int j = 0;for (j = y - 1;j <= y + 1;j++){if (show[i][j] == '*')//只对位排查的坐标进行展开，防止死循环{ExpandAround(mine, show, i, j);}}}}else{show[x][y] = count + '0';//周围有雷，显示雷数}}
}

7.标记雷

//定义标记雷的函数（用！标记）
void MarkMine(char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;while (1){printf("请输入你要标记雷的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '!'){if (show[x][y] == '*'){show[x][y] = '!';system("cls");PrintBoard(show, ROW, COL);break;}else{printf("该坐标已经被排查过，无法标记，请重新输入\n");}}else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '!'){printf("该坐标已经被标记过了，无法二次标记，请重新输入\n");}else{printf("该坐标越界，请重新输入\n");}}
}

8.删除雷的标记

//定义删除雷的标记的函数
void DelectMarkMine(char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;while (1){printf("请输入你要删除雷的标记的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '!'){show[x][y] = '*';system("cls");PrintBoard(show, ROW, COL);break;}else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '!'){printf("该坐标未被标记过，无法删除标记，请重新输入\n");}else{printf("该坐标越界，请重新输入\n");}}
}

9.保证第一次排雷的安全性+棋盘必定展开

//定义第一次排雷是安全的，不是雷并且可以达到展开一片的效果，增加了可玩性
void FirstIsSafe(char mine[ROWS][COLS], char show[ROWS][COLS],int x, int y)
{//若该点不是雷且周围无雷，直接展开if (mine[x][y] != '1' && AroundMineCount(mine, x, y) == 0){ExpandAround(mine, show, x, y);}//否则分情况else{//先判断该点是不是雷if (mine[x][y] == '1')//该点为雷，将其移走{mine[x][y] = '0';while (1){int x1 = rand() % ROW + 1;int y1 = rand() % COL + 1;if (mine[x1][y1] != '1' && x1 != x && y1 != y){mine[x1][y1] = '1';break;}}}//以及将雷移走了，在判断周围是否有雷if (AroundMineCount(mine, x, y) != 0)//该点周围有雷，将它们移走{int count = AroundMineCount(mine, x, y);//计算周围雷的数量int i = 0;for (i = x - 1;i <= x + 1; i++){int j = 0;for (j = y - 1; j <= y + 1; j++){mine[i][j] = '0';//将周围的雷变为无雷的状态}}while (count){int x1 = rand() % ROW + 1;int y1 = rand() % COL + 1;if ((x1 != x - 1 && y1 != y - 1)&&(x1 != x - 1 && y1 != y)&&(x1 != x - 1 && y1 != y + 1)&&(x1 != x && y1 != y - 1)&&(x1 != x && y1 != y)&&(x1 != x && y1 != y + 1)&&(x1 != x + 1 && y1 != y - 1)&&(x1 != x + 1 && y1 != y)&&(x1 != x + 1 && y1 != y + 1))//不能将雷移回来{if (mine[x1][y1] != '1'){mine[x1][y1] = '1';//如果该坐标不是雷，则布置雷count--;}}}}ExpandAround(mine, show, x, y);}
}

10.排查雷

  • 代码1：不能实现展开一片的效果
//定义排查雷的函数1.0：不能实现展开一片的效果
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;int ret1 = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '*')//判断输入的坐标是否合法且未被排查过{if (mine[x][y] == '1')//该坐标是雷{system("cls");//清空屏幕——头文件windows.hprintf("很遗憾，你被雷炸死了，游戏失败！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, ROW, COL);ret1 = 1;break;}else//该坐标不是雷{system("cls");//清空屏幕——头文件windows.hint count = AroundMineCount(mine, x, y);show[x][y] = count + '0';//该坐标要存放雷的个数int ret2 = IsWin(show, row, col);if (ret2 == 1){printf("恭喜你！找到了所有的雷，游戏胜利！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, row, col);}else{PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷}break;}}else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '*')//该坐标已经被排查过{printf("该坐标已经被排查过，请重新输入坐标\n");}else//越界{printf("输入的坐标错误，请重新输入\n");}}return ret1;
}
  • 代码2：可以实现展开一片的效果
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;int ret1 = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col)//判断输入的坐标是否合法且未被排查过{if (show[x][y] == '*' || show[x][y] == '!'){if (show[x][y] == '*'){again:if (mine[x][y] == '1')//该坐标是雷{system("cls");//清空屏幕——头文件windows.hprintf("很遗憾，你被雷炸死了，游戏失败！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, ROW, COL);ret1 = 1;break;}else//该坐标不是雷{ExpandAround(mine, show, x, y);//直接展开system("cls");//清空屏幕——头文件windows.hint ret2 = IsWin(show, row, col);if (ret2 == 1){printf("恭喜你！找到了所有的雷，游戏胜利！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, row, col);}else{PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷}break;}}else{int select = 0;printf("确定要排查标记过的坐标吗？ 0.取消排查 1.坚持排查\n");while (1){printf("请输入（0/1）:>");scanf("%d", &select);if (select == 0){return 0;}else if (select == 1){goto again;}else{printf("输入错误，请重新输入\n");}}}}else{printf("该坐标已经被排查过，请重新输入\n");}}else//越界{printf("该坐标越界，请重新输入\n");}}return ret1;
}
  • 代码3：结合FirstIsSafe函数，第一次排查确保该点不是雷以及周围没有雷，达到网页版扫雷的效果，由于是随机排雷，不能保证该点以及周围有无雷，可以将雷，神不知鬼不觉地换掉。
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{//第一次排查确保该点不是雷以及周围没有雷，达到网页版扫雷的效果//由于是随机排雷，不能保证该点以及周围有无雷，可以将雷，神不知鬼不觉地换掉static int FindMineCount = 1;if (FindMineCount == 1){int x = 0;int y = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col){FirstIsSafe(mine, show, x, y);FindMineCount++;system("cls");//PrintBoard(mine, ROW, COL);PrintBoard(show, ROW, COL);return 0;}else{printf("输入的坐标越界，请重新输入\n");}}}//以后雷的位置就固定下来了else{int x = 0;int y = 0;int ret1 = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col)//判断输入的坐标是否合法且未被排查过{if (show[x][y] == '*' || show[x][y] == '!'){if (show[x][y] == '*'){again:if (mine[x][y] == '1')//该坐标是雷{system("cls");//清空屏幕——头文件windows.hprintf("很遗憾，你被雷炸死了，游戏失败！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, ROW, COL);ret1 = 1;break;}else//该坐标不是雷{ExpandAround(mine, show, x, y);//直接展开system("cls");//清空屏幕——头文件windows.hint ret2 = IsWin(show, row, col);if (ret2 == 1){printf("恭喜你！找到了所有的雷，游戏胜利！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, row, col);}else{PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷}break;}}else{int select = 0;printf("确定要排查标记过的坐标吗？ 0.取消排查 1.坚持排查\n");while (1){printf("请输入（0/1）:>");scanf("%d", &select);if (select == 0){return 0;}else if (select == 1){goto again;}else{printf("输入错误，请重新输入\n");}}}}else{printf("该坐标已经被排查过，请重新输入\n");}}else//越界{printf("该坐标越界，请重新输入\n");}}FindMineCount++;return ret1;}
}

11.判断输赢

  • 利用剩余的*数目等于雷的数目，返回1，代表游戏胜利，否则返回0，代表游戏继续。
//定义游戏胜利的函数
int IsWin(char show[ROWS][COLS], int row, int col)
{int count = 0;int i = 0;for (i = 1; i <= row; i++){int j = 0;for (j = 1; j <= col; j++){if (show[i][j] == '*')//统计show中*的个数{count++;}}}if (count == MINE_NUMBER)//若剩余的*数目等于雷的数目，返回1，代表游戏胜利{return 1;}return 0;//否则返回0，代表游戏继续
}

三.扫雷总代码

  • game.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<windows.h>#define ROW 9//扫雷的行数
#define COL 9//扫雷的列数#define ROWS ROW + 2//创建二维数组的行数
#define COLS COL + 2//创建二维数组的列数#define MINE_NUMBER 10//设置雷的个数//声明初始化棋盘的函数
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);//声明打印棋盘的函数
void PrintBoard(char board[ROWS][COLS], int row, int col);//声明布置雷的函数
void SetMine(char mine[ROWS][COLS], int row, int col);//声明标记雷的函数
void MarkMine(char show[ROWS][COLS], int row, int col);//声明删除雷的标记的函数
void DelectMarkMine(char show[ROWS][COLS], int row, int col);//声明第一次排雷是安全的，不是雷并且可以达到展开一片的效果，增加了可玩性
void FirstIsSafe(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y);//声明排查雷的函数
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);//声明游戏胜利的函数
int IsWin(char show[ROWS][COLS], int row, int col);

game.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"//printf("\033[36m%c \033[0m", board[i][j]);//打印蓝色
//printf("\033[31m%c \033[0m", board[i][j]);//打印红色//定义初始化棋盘的函数
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{int i = 0;for (i = 0;i < rows;i++){int j = 0;for (j = 0;j < cols;j++){board[i][j] = set;}}
}//定义打印棋盘的函数
//void PrintBoard(char board[ROWS][COLS], int row, int col)
//{
//	int i = 0;
//	//辅助观察棋盘
//	for (i = 0;i <= row;i++)
//	{
//		printf("%d ", i);
//	}
//	printf("\n");
//	//打印棋盘
//	for (i = 1;i <= row;i++)
//	{
//		printf("%d ", i);//辅助观察棋盘
//		int j = 0;
//		for (j = 1;j <= col;j++)
//		{
//			printf("\033[36m%c \033[0m", board[i][j]);//打印蓝色
//		}
//		printf("\n");
//	}
//	printf("--------扫雷--------\n");//辅助观察棋盘
//}//定义打印棋盘的函数
void PrintBoard(char board[ROWS][COLS], int row, int col)
{printf("\033[34m-----------------扫雷-----------------\033[0m\n");//辅助观察棋盘int i = 0;//辅助观察棋盘printf("0 |");for (i = 1;i <= row;i++){printf(" %-2d", i);if (i < row){printf("|");}}printf("\n");printf("--|");for (i = 1; i <= col; i++){printf("---");if (i < row){printf("|");}}printf("\n");//打印棋盘for (i = 1;i <= row;i++){printf("%-2d|", i);//辅助观察棋盘int j = 0;for (j = 1;j <= col;j++){if (board[i][j] == '1' || board[i][j] == '5'){printf("\033[36m %c \033[0m", board[i][j]);//打印蓝色}else if (board[i][j] == '2' || board[i][j] == '6'){printf("\033[32m %c \033[0m", board[i][j]);//打印绿色}else if (board[i][j] == '3' || board[i][j] == '7'){printf("\033[31m %c \033[0m", board[i][j]);//打印红色}else if (board[i][j] == '4' || board[i][j] == '8'){printf("\033[35m %c \033[0m", board[i][j]);//打印紫色}else if (board[i][j] == '!'){printf("\033[31m %c \033[0m", board[i][j]);//打印红色}else{printf(" %c ", board[i][j]);//打印白色}if (j < col){printf("|");}}//辅助观察棋盘printf("\n");if (i < row){printf("--|");}for (j = 1; j <= col; j++){if (i < row){printf("---");if (j < col){printf("|");}}}printf("\n");}
}//定义布置雷的函数
void SetMine(char mine[ROWS][COLS], int row, int col)
{int count = MINE_NUMBER;//雷的个数while (count){int x = rand() % row + 1;int y = rand() % col + 1;if (mine[x][y] != '1'){mine[x][y] = '1';//如果该坐标不是雷，则布置雷count--;}}
}//统计周围雷的个数的函数1.0
//int AroundMineCount(char mine[ROWS][COLS], int x, int y)
//{
//	return mine[x - 1][y] + mine[x - 1][y - 1] +
//		mine[x][y - 1] + mine[x + 1][y - 1] +
//		mine[x + 1][y] + mine[x + 1][y + 1] +
//		mine[x][y + 1] + mine[x - 1][y + 1] - 8 * '0';
//}//统计周围雷的个数的函数2.0
int AroundMineCount(char mine[ROWS][COLS], int x, int y)
{int i = 0;int count = 0;for (i = x - 1;i <= x + 1;i++){int j = 0;for (j = y - 1;j <= y + 1;j++){count += mine[i][j] - '0';}}return count;
}//已知该坐标不是雷，若周围没有雷,该坐标赋为空，再向外扩展（达到展开一片的效果），否则只显示该坐标周围雷的个数
void ExpandAround(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//限制在棋盘内展开，防止下标越界{int count = AroundMineCount(mine, x, y);//获取雷数if (count == 0)//周围没雷，递归展开{show[x][y] = ' ';//周围没雷，赋值为空格int i = 0;for (i = x - 1;i <= x + 1;i++){int j = 0;for (j = y - 1;j <= y + 1;j++){if (show[i][j] == '*')//只对位排查的坐标进行展开，防止死循环{ExpandAround(mine, show, i, j);}}}}else{show[x][y] = count + '0';//周围有雷，显示雷数}}
}//定义标记雷的函数
void MarkMine(char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;while (1){printf("请输入你要标记雷的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '!'){if (show[x][y] == '*'){show[x][y] = '!';system("cls");PrintBoard(show, ROW, COL);break;}else{printf("该坐标已经被排查过，无法标记，请重新输入\n");}}else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '!'){printf("该坐标已经被标记过了，无法二次标记，请重新输入\n");}else{printf("该坐标越界，请重新输入\n");}}
}//定义删除雷的标记的函数
void DelectMarkMine(char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;while (1){printf("请输入你要删除雷的标记的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '!'){show[x][y] = '*';system("cls");PrintBoard(show, ROW, COL);break;}else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '!'){printf("该坐标未被标记过，无法删除标记，请重新输入\n");}else{printf("该坐标越界，请重新输入\n");}}
}//定义游戏胜利的函数
int IsWin(char show[ROWS][COLS], int row, int col)
{int count = 0;int i = 0;for (i = 1; i <= row; i++){int j = 0;for (j = 1; j <= col; j++){if (show[i][j] == '*')//统计show中*的个数{count++;}}}if (count == MINE_NUMBER)//若剩余的*数目等于雷的数目，返回1，代表游戏胜利{return 1;}return 0;//否则返回0，代表游戏继续
}//定义排查雷的函数1.0：不能实现展开一片的效果
//int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
//{
//	int x = 0;
//	int y = 0;
//	int ret1 = 0;
//	while (1)
//	{
//		printf("请输入你要排查的坐标:>");
//		scanf("%d %d", &x, &y);
//		if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '*')//判断输入的坐标是否合法且未被排查过
//		{
//			if (mine[x][y] == '1')//该坐标是雷
//			{
//				system("cls");//清空屏幕——头文件windows.h
//				printf("很遗憾，你被雷炸死了，游戏失败！\n");
//				printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");
//				PrintBoard(mine, ROW, COL);
//				ret1 = 1;
//				break;
//			}
//			else//该坐标不是雷
//			{
//				system("cls");//清空屏幕——头文件windows.h
//				int count = AroundMineCount(mine, x, y);
//				show[x][y] = count + '0';//该坐标要存放雷的个数
//				int ret2 = IsWin(show, row, col);
//				if (ret2 == 1)
//				{
//					printf("恭喜你！找到了所有的雷，游戏胜利！\n");
//					printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");
//					PrintBoard(mine, row, col);
//				}
//				else
//				{
//					PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷
//				}
//				break;
//			}
//		}
//		else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '*')//该坐标已经被排查过
//		{
//			printf("该坐标已经被排查过，请重新输入坐标\n");
//		}
//		else//越界
//		{
//			printf("输入的坐标错误，请重新输入\n");
//		}
//	}
//	return ret1;
//}//定义排查雷的函数2.0：可以实现展开一片的效果
//int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
//{
//	int x = 0;
//	int y = 0;
//	int ret1 = 0;
//	while (1)
//	{
//		printf("请输入你要排查的坐标:>");
//		scanf("%d %d", &x, &y);
//		if (x >= 1 && x <= row && y >= 1 && y <= col)//判断输入的坐标是否合法且未被排查过
//		{
//			if (show[x][y] == '*' || show[x][y] == '!')
//			{
//				if (show[x][y] == '*')
//				{
//				again:
//					if (mine[x][y] == '1')//该坐标是雷
//					{
//						system("cls");//清空屏幕——头文件windows.h
//						printf("很遗憾，你被雷炸死了，游戏失败！\n");
//						printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");
//						PrintBoard(mine, ROW, COL);
//						ret1 = 1;
//						break;
//					}
//					else//该坐标不是雷
//					{
//						ExpandAround(mine, show, x, y);//直接展开
//						system("cls");//清空屏幕——头文件windows.h
//						int ret2 = IsWin(show, row, col);
//						if (ret2 == 1)
//						{
//							printf("恭喜你！找到了所有的雷，游戏胜利！\n");
//							printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");
//							PrintBoard(mine, row, col);
//						}
//						else
//						{
//							PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷
//						}
//						break;
//					}
//				}
//				else
//				{
//					int select = 0;
//					printf("确定要排查标记过的坐标吗？ 0.取消排查 1.坚持排查\n");
//					while (1)
//					{
//						printf("请输入（0/1）:>");
//						scanf("%d", &select);
//						if (select == 0)
//						{
//							return 0;
//						}
//						else if (select == 1)
//						{
//							goto again;
//						}
//						else
//						{
//							printf("输入错误，请重新输入\n");
//						}
//					}
//				}
//			}
//			else
//			{
//				printf("该坐标已经被排查过，请重新输入\n");
//			}
//		}
//		else//越界
//		{
//			printf("该坐标越界，请重新输入\n");
//		}
//	}
//	return ret1;
//}//定义排查雷的函数3.0：可以实现展开一片的效果
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{//第一次排查确保该点不是雷以及周围没有雷，达到网页版扫雷的效果//由于是随机排雷，不能保证该点以及周围有无雷，可以将雷，神不知鬼不觉地换掉static int FindMineCount = 1;if (FindMineCount == 1){int x = 0;int y = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col){FirstIsSafe(mine, show, x, y);FindMineCount++;system("cls");//PrintBoard(mine, ROW, COL);PrintBoard(show, ROW, COL);return 0;}else{printf("输入的坐标越界，请重新输入\n");}}}//以后雷的位置就固定下来了else{int x = 0;int y = 0;int ret1 = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col)//判断输入的坐标是否合法且未被排查过{if (show[x][y] == '*' || show[x][y] == '!'){if (show[x][y] == '*'){again:if (mine[x][y] == '1')//该坐标是雷{system("cls");//清空屏幕——头文件windows.hprintf("很遗憾，你被雷炸死了，游戏失败！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, ROW, COL);ret1 = 1;break;}else//该坐标不是雷{ExpandAround(mine, show, x, y);//直接展开system("cls");//清空屏幕——头文件windows.hint ret2 = IsWin(show, row, col);if (ret2 == 1){printf("恭喜你！找到了所有的雷，游戏胜利！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, row, col);}else{PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷}break;}}else{int select = 0;printf("确定要排查标记过的坐标吗？ 0.取消排查 1.坚持排查\n");while (1){printf("请输入（0/1）:>");scanf("%d", &select);if (select == 0){return 0;}else if (select == 1){goto again;}else{printf("输入错误，请重新输入\n");}}}}else{printf("该坐标已经被排查过，请重新输入\n");}}else//越界{printf("该坐标越界，请重新输入\n");}}FindMineCount++;return ret1;}
}//定义第一次排雷是安全的，不是雷并且可以达到展开一片的效果，增加了可玩性
void FirstIsSafe(char mine[ROWS][COLS], char show[ROWS][COLS],int x, int y)
{//若该点不是雷且周围无雷，直接展开if (mine[x][y] != '1' && AroundMineCount(mine, x, y) == 0){ExpandAround(mine, show, x, y);}//否则分情况else{//先判断该点是不是雷if (mine[x][y] == '1')//该点为雷，将其移走{mine[x][y] = '0';while (1){int x1 = rand() % ROW + 1;int y1 = rand() % COL + 1;if (mine[x1][y1] != '1' && x1 != x && y1 != y){mine[x1][y1] = '1';break;}}}//以及将雷移走了，在判断周围是否有雷if (AroundMineCount(mine, x, y) != 0)//该点周围有雷，将它们移走{int count = AroundMineCount(mine, x, y);//计算周围雷的数量int i = 0;for (i = x - 1;i <= x + 1; i++){int j = 0;for (j = y - 1; j <= y + 1; j++){mine[i][j] = '0';//将周围的雷变为无雷的状态}}while (count){int x1 = rand() % ROW + 1;int y1 = rand() % COL + 1;if ((x1 != x - 1 && y1 != y - 1)&&(x1 != x - 1 && y1 != y)&&(x1 != x - 1 && y1 != y + 1)&&(x1 != x && y1 != y - 1)&&(x1 != x && y1 != y)&&(x1 != x && y1 != y + 1)&&(x1 != x + 1 && y1 != y - 1)&&(x1 != x + 1 && y1 != y)&&(x1 != x + 1 && y1 != y + 1))//不能将雷移回来{if (mine[x1][y1] != '1'){mine[x1][y1] = '1';//如果该坐标不是雷，则布置雷count--;}}}}ExpandAround(mine, show, x, y);}
}
  • test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"//菜单
void Menu()
{printf("-------------------------------------\n");printf("|              扫雷游戏！           |\n");printf("|        0.exit        1.play       |\n");printf("-------------------------------------\n");
}
void Game()
{//创建两个二维数组char mine[ROWS][COLS];//存放该点是不是雷    （0代表不是雷，1代表是雷）char show[ROWS][COLS];//存放该点周围有多少雷（数字代表周围有多少雷，*代表未知）//初始化棋盘InitBoard(mine, ROWS, COLS, '0');InitBoard(show, ROWS, COLS, '*');//打印棋盘//PrintBoard(mine, ROW, COL);//PrintBoard(show, ROW, COL);//布置雷SetMine(mine, ROW, COL);//PrintBoard(mine, ROW, COL);PrintBoard(show, ROW, COL);int select = 0;int ret1 = 0;int ret2 = 0;while (ret1 != 1 && ret2 != 1){printf("1.排查雷  2.标记雷  3.删除雷的标记\n");printf("请选择:>");scanf("%d", &select);switch (select){case 1:ret1 = FindMine(mine, show, ROW, COL);ret2 = IsWin(show, ROW, COL);break;case 2:MarkMine(show, ROW, COL);break;case 3:DelectMarkMine(show, ROW, COL);break;default:printf("输入的值错误，请重新输入\n");break;}}
}
int main()
{int input = 0;srand((unsigned int)time(NULL));//设置随机种子do{Menu();printf("请输入(0/1):>");scanf("%d", &input);switch (input){case 1:Game();break;case 0:printf("退出游戏\n");break;default:printf("输入错误，请重新输入\n");break;}} while (input);return 0;
}

四.截图

  • 最后附上其中一张截图。

请添加图片描述

  • 感兴趣的可以去玩一下哈，最后到这文章也就结束了，日后还会更新更多的小游戏，例如贪吃蛇等等，喜欢的话可以三连下下哦，以防找不到了。

这篇关于扫雷实现详解【递归展开+首次必展开+标记雷+取消标记雷】的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/960120。

相关文章

Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

利用康拓展开将一个排列映射成一个自然数，然后就变成了普通的广搜题。 #include<iostream>#include<algorithm>#include<string>#include<stack>#include<queue>#include<map>#include<stdio.h>#include<stdlib.h>#include<ctype.h>#inclu
阅读更多...
OpenHarmony鸿蒙开发（ Beta5.0）无感配网详解

OpenHarmony鸿蒙开发（ Beta5.0）无感配网详解

1、简介 无感配网是指在设备联网过程中无需输入热点相关账号信息，即可快速实现设备配网，是一种兼顾高效性、可靠性和安全性的配网方式。 2、配网原理 2.1 通信原理 手机和智能设备之间的信息传递，利用特有的NAN协议实现。利用手机和智能设备之间的WiFi 感知订阅、发布能力，实现了数字管家应用和设备之间的发现。在完成设备间的认证和响应后，即可发送相关配网数据。同时还支持与常规Sof
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
【Prometheus】PromQL向量匹配实现不同标签的向量数据进行运算

【Prometheus】PromQL向量匹配实现不同标签的向量数据进行运算

✨✨ 欢迎大家来到景天科技苑✨✨ 🎈🎈 养成好习惯，先赞后看哦~🎈🎈 🏆 作者简介：景天科技苑 🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。 🏆《博客》：Python全栈，前后端开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi
阅读更多...
让树莓派智能语音助手实现定时提醒功能

让树莓派智能语音助手实现定时提醒功能

最初的时候是想直接在rasa 的chatbot上实现，因为rasa本身是带有remindschedule模块的。不过经过一番折腾后，忽然发现，chatbot上实现的定时，语音助手不一定会有响应。因为，我目前语音助手的代码设置了长时间无应答会结束对话，这样一来，chatbot定时提醒的触发就不会被语音助手获悉。那怎么让语音助手也具有定时提醒功能呢？ 我最后选择的方法是用threading.Time
阅读更多...
Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

客户有些需求需要设置默认壁纸和锁屏壁纸  在默认情况下 这两个壁纸是相同的  如果需要默认的锁屏壁纸和桌面壁纸不一样 需要额外修改 Android13实现 替换默认桌面壁纸： 将图片文件替换frameworks/base/core/res/res/drawable-nodpi/default_wallpaper.*  （注意不能是bmp格式） 替换默认锁屏壁纸： 将图片资源放入vendo
阅读更多...
C#实战|大乐透选号器[6]：实现实时显示已选择的红蓝球数量

C#实战|大乐透选号器[6]：实现实时显示已选择的红蓝球数量

哈喽，你好啊，我是雷工。 关于大乐透选号器在前面已经记录了5篇笔记，这是第6篇； 接下来实现实时显示当前选中红球数量，蓝球数量； 以下为练习笔记。 01 效果演示 当选择和取消选择红球或蓝球时，在对应的位置显示实时已选择的红球、蓝球的数量； 02 标签名称 分别设置Label标签名称为：lblRedCount、lblBlueCount
阅读更多...
Kubernetes PodSecurityPolicy：PSP能实现的5种主要安全策略

Kubernetes PodSecurityPolicy：PSP能实现的5种主要安全策略

Kubernetes PodSecurityPolicy：PSP能实现的5种主要安全策略 1. 特权模式限制2. 宿主机资源隔离3. 用户和组管理4. 权限提升控制5. SELinux配置 💖The Begin💖点点关注，收藏不迷路💖 Kubernetes的PodSecurityPolicy（PSP）是一个关键的安全特性，它在Pod创建之前实施安全策略，确保P
阅读更多...
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

上篇：6.1.数据结构-c/c++模拟实现堆上篇（向下，上调整算法，建堆，增删数据）-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小)： 2.2 C语言代码（手写堆） 2.3 C++代码（使用优先级队列 priority_queue）
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2