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

news2024/11/20 7:04:07

扫雷

  • 一.扫雷设计思路
  • 二.扫雷代码逐步实现
    • 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.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：可以实现展开一片的效果
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：结合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.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");
			}
		}
		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.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");
			}
		}
		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.coloradmin.cn/o/1641944.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Javascript基础（三）

Javascript基础（三）

Javascript基础&#xff08;一&#xff09; Javascript基础&#xff08;二&#xff09; 引用数据类型 在之前的文章中&#xff0c;我们提及了与基本数据类型并列的引用数据类型&#xff0c;当时提到引用数据类型大致分为三类&#xff1a;数组Array&#xff0c;函数Function&a…
阅读更多...
13.1 QQ邮箱

13.1 QQ邮箱

1. 邮箱发送 2. 准备工作 3. 整合SpringBoot 3.1 配置 依赖引入 <!-- 邮件服务--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-mail</artifactId></dependency>application.…
阅读更多...
浅析扩散模型与图像生成【应用篇】(二十)——TiNO-Edit

浅析扩散模型与图像生成【应用篇】(二十)——TiNO-Edit

20. TiNO-Edit: Timestep and Noise Optimization for Robust Diffusion-Based Image Editing 该文通过对扩散模型中添加噪声的时刻 t k t_k tk​和噪声 N N N进行优化&#xff0c;提升SD等文生图模型的图像编辑效果。作者指出现有的方法为了提升文生图模型的图像编辑质量&…
阅读更多...
VISO流程图之子流程的使用

VISO流程图之子流程的使用

子流程的作用 整个流程图的框图多而且大&#xff0c;进行分块&#xff1b;让流程图简洁对于重复使用的流程&#xff0c;可以归结为一个子流程图&#xff0c;方便使用&#xff0c;避免大量的重复性工作&#xff1b; 新建子流程 方法1&#xff1a; 随便布局 框选3 和4 &#…
阅读更多...
基于YOLOv8的水稻虫害识别系统，加入BiLevelRoutingAttention注意力进行创新优化

基于YOLOv8的水稻虫害识别系统，加入BiLevelRoutingAttention注意力进行创新优化

&#x1f4a1;&#x1f4a1;&#x1f4a1;本文摘要&#xff1a;基于YOLOv8的水稻虫害识别&#xff0c;阐述了整个数据制作和训练可视化过程&#xff0c;并加入BiLevelRoutingAttention注意力进行优化&#xff0c;最终mAP从原始的 0.697提升至0.732 博主简介 AI小怪兽&#xff…
阅读更多...
MATLAB - 自定义惯性矩阵

MATLAB - 自定义惯性矩阵

系列文章目录 前言 一、关键惯性约定 Simscape 多体软件在惯性定义中采用了一系列约定。请注意这些约定&#xff0c;因为如果手动进行惯性计算&#xff0c;这些约定可能会影响计算结果。如果您的惯性数据来自 CAD 应用程序或其他第三方软件&#xff0c;这些约定还可能影响到您需…
阅读更多...
【计算机毕设】在线商城系统设计与开发 - 免费源码（私信领取）

【计算机毕设】在线商城系统设计与开发 - 免费源码（私信领取）

免费领取源码 &#xff5c; 项目完整可运行 &#xff5c; v&#xff1a;chengn7890 诚招源码校园代理&#xff01; 1. 研究目的 本项目旨在设计并实现一个在线商城系统&#xff0c;提供商品展示、购物车管理、订单管理等功能&#xff0c;为用户提供便捷的购物体验&#xff0c;…
阅读更多...
并发-启动线程的正确姿势

并发-启动线程的正确姿势

目录 启动线程的正确姿势 Start方法原理解读 Run方法原理解读 常见问题 启动线程的正确姿势 start()与run()方法的比较测试结果可以看出&#xff0c;runnable.run()方法是由main线程执行的&#xff0c;而要子线程执行就一定要先调用start()启动新线程去执行run方法并不能成…
阅读更多...
人工智能|推荐系统——工业界的推荐系统之召回

人工智能|推荐系统——工业界的推荐系统之召回

基于物品的协同过滤 ⽤索引，离线计算量⼤，线上计算量⼩ Swing额外考虑重合的⽤户是否来⾃⼀个⼩圈⼦，两个⽤户重合度⼤，则可能来⾃⼀个⼩圈⼦，权重降低。 基于用户的协同过滤 同样是离线计算索引，在线召回的流程 离散特征处理 Embedding 层参数数量=向量维度 类别数量 矩
阅读更多...
知识图谱需求

知识图谱需求

文章目录 公共安全数字经济金融科技资源优化科学研究制造业转型公共健康人文发展 公共安全 公共安全领域信息化以现代通信、网络、数据库技术为基础&#xff0c;将所研究对象各要素汇总至数据库&#xff0c;并针对各个业务领域进行定制化开发&#xff0c;以满足公共安全实战需求…
阅读更多...
网易研发休闲游戏，AI技术助力提升品质

网易研发休闲游戏，AI技术助力提升品质

易采游戏网5月3日消息&#xff0c;在数字化时代&#xff0c;游戏已经成为人们休闲娱乐的重要方式。作为国内领先的互联网科技公司&#xff0c;网易一直在游戏领域深耕细作&#xff0c;不断推出高质量的游戏产品。近期&#xff0c;网易宣布正在研发一系列休闲游戏&#xff0c;并…
阅读更多...
【k8s】利用Kubeadm搭建k8s1.29.x版本+containerd

【k8s】利用Kubeadm搭建k8s1.29.x版本+containerd

文章目录 前言1.准备的三台虚拟机2.安装 kubeadm 前的准备工作3.安装containerd1.解压安装包2.生成默认配置文件3.使用systemd托管containerd4.修改默认配置文件 4.安装runc5.安装 CNI plugins6.安装 kubeadm、kubelet 和 kubectl6.1 配置crictl 7.初始化集群1.打印初始化配置到…
阅读更多...
2024五一杯数学建模B题思路分析 - 未来新城背景下的交通需求规划与可达率问题

2024五一杯数学建模B题思路分析 - 未来新城背景下的交通需求规划与可达率问题

文章目录 1 赛题选题分析 2 解题思路详细的思路过程放在文档中 ! ! &#xff01;&#xff01;&#xff01;&#xff01;&#xff01;3 最新思路更新 1 赛题 B题 未来新城背景下的交通需求规划与可达率问题 随着城市化的持续发展&#xff0c;交通规划在新兴城市建设中显得尤为关…
阅读更多...
Idea 自动生成测试

Idea 自动生成测试

先添加测试依赖&#xff01;&#xff01; <!--Junit单元测试依赖--><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter</artifactId><version>5.9.1</version><scope>test</scope><…
阅读更多...
【Python可视化】pyecharts

【Python可视化】pyecharts

Echarts 是一个由百度开源的数据可视化&#xff0c;凭借着良好的交互性&#xff0c;精巧的图表设计&#xff0c;得到了众多开发者的认可。而 Python 是一门富有表达力的语言&#xff0c;很适合用于数据处理。当数据分析遇上数据可视化时&#xff0c;pyecharts 诞生了。 需要安…
阅读更多...
【idea-sprongboot项目】SSH连接云服务器进行远程开发

【idea-sprongboot项目】SSH连接云服务器进行远程开发

继上一篇博客【阿里云服务器】ubuntu 22.04.1安装docker以及部署java环境-CSDN博客 目录 五、远程开发方式 1&#xff09;SSH进行远程开发 步骤 配置文件同步 window电脑远程操控 正式通过window电脑远程操控 运行在linux服务器上的远程程序 调试在linux服务器上的远程程…
阅读更多...
【无标题】数模数电的教学文章与资料

【无标题】数模数电的教学文章与资料

在电子技术领域&#xff0c;数模&#xff08;Digital-to-Analog, DA&#xff09;和模数&#xff08;Analog-to-Digital, AD&#xff09;转换器是核心组件&#xff0c;它们连接了模拟世界与数字世界&#xff0c;使得电子设备能够处理现实世界中的连续信号与数字信号系统的交互。…
阅读更多...
电话号码的字母组合 【C++】【力扣刷题】

电话号码的字母组合 【C++】【力扣刷题】

解题思路&#xff1a; 以第一个为例,digits “23”&#xff0c;表明从电话号码的按键中选取2和3这两个字符&#xff0c;然后去寻找它们各自所对应的字母&#xff0c;这里每一个数字字符所对应的字母的不同&#xff0c;0对应的是空字符&#xff0c;而1的话题目中讲到是不对应任…
阅读更多...
使用macof发起MAC地址泛洪攻击

使用macof发起MAC地址泛洪攻击

使用macof发起MAC地址泛洪攻击 MAC地址泛洪攻击原理&#xff1a; MAC地址泛洪攻击是一种针对交换机的攻击方式&#xff0c;目的是监听同一局域网中用户的通信数据。交换机的工作核心&#xff1a;端口- MAC地址映射表。这张表记录了交换机每个端口和与之相连的主机MAC地址之间…
阅读更多...
MATLAB实现遗传算法优化第三类生产线平衡问题

MATLAB实现遗传算法优化第三类生产线平衡问题

第三类生产线平衡问题的数学模型 假设&#xff1a; 工作站数量&#xff08;m&#xff09;和生产线节拍&#xff08;CT&#xff09;是预设并固定的。每个任务&#xff08;或作业元素&#xff09;只能分配到一个工作站中。任务的执行顺序是预先确定的&#xff0c;且不可更改。每…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023