devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

三子棋游戏(利用基础语法实现人工智能)_人工智能三盘棋怎么设计教学活动

作者：Li_阴宅 | 2024-08-22 19:54:37

赞

踩

人工智能三盘棋怎么设计教学活动

通过基础的C语言知识，来实现三子棋的人工智能，让电脑可以实现自由落子、堵棋以及赢棋的功能。整体代码650行左右，适合刚接触编程的同学，在实现程序的同时，增加自己的编程知识，并且锻炼用逻辑思维思考的能力。

目录

整体结构组成

大致框架

游戏部分

生成棋盘

定义数组

初始化

打印棋盘

玩家下棋

电脑下棋（智能下棋）

自由落子

堵棋

赢棋

判断输赢

判定横三连

判断竖三连

判断斜三连（左下右上）

判断斜三连（左下右上）

判断平局

测试

改进

整体代码展示

text.c

game.h

game.c

整体结构组成

游戏代码主要由三部分组成，text.c存放主函数，game.c存放游戏实现部分的函数，game.h声明在game.c中定义的函数。

text.c（菜单、主函数）

game.c（游戏内容）

game.h（声明游戏内容中所包含的函数）

大致框架

为了避免有输入错误的情况，以及玩完一遍游戏还可以玩第二遍，这里整个游戏框架用do while循环，保证整个流程至少可以运行一次。

  1. #include"game.h"
  2.  
  3. void menu()
  4. {
  5. 	printf("******************\n");
  6. 	printf("***** 1.paly *****\n");
  7. 	printf("***** 0.exit *****\n");
  8. 	printf("******************\n");
  9. }
  10.  
  11. int main()
  12. {
  13. 	int input = 0;
  14. 	do
  15. 	{
  16. 		menu();
  17. 		printf("请选择(1/0):>");
  18. 		scanf("%d", &input);
  19. 	} while (input);
  20. 	return 0;
  21. }

随后，针对输入的值不同，来判定是进行游戏还是退出游戏，或是输入错误。这里可以用switch 选择语句完成该部分的判断。

  1. switch (input)
  2. 		{
  3. 		case 0:
  4. 			printf("退出游戏\n");
  5. 			break;
  6. 		case 1:
  7. 			printf("开始游戏\n");
  8. 			game();//游戏
  9. 			Sleep(500);//等500毫秒
  10. 			system("cls");//清空屏幕
  11. 			break;
  12. 		default:
  13. 			printf("输入错误，请重新输入\n");
  14. 		}

当我们完成一次游戏后，为了方便进行下一次玩，用system("cls")将我们的屏幕清空，但cls清空的速度非常快，这里用Sleep(500)让系统休眠500毫秒，方便我们看到游戏的结果。system和Sleep的使用均需要包含头文件<windows.h>。

当完成了这部分的内容，整个游戏的大致框架就完成了，将game()先打上注释，这里测试一下能否正常运行。

游戏部分

游戏的部分整体流程如下：

生成棋盘

  • 定义数组

三子棋的棋盘一共三行三列，共有九个空可以下棋，这用一个三行三列的数组来存放每个空的数据。

为了代码的灵活性，这里不要把行和列的值写死，用define定义的常量来写，方便以后代码的更新。

  1. //game.h
  2.  
  3. #define ROW 3
  4. #define COL 3
  5.  
  6. //text.c
  7.  
  8. #include"game.h"
  9.  
  10. void game()
  11. {
  12. 	char board[ROW][COL] = { 0 };
  13. }

  • 初始化

定义完数组后，为了更加贴合棋盘的样式，我们需要对数组进行初始化，将空格赋给每个元素。这里定义一个初始化棋盘的函数InitBoard，将数组，行和列的参数传给函数，这个函数的部分拿到game.c中完成，并且在game.h中声明一下。

  1. //text.c
  2.  
  3. #include"game2.h"
  4.  
  5. void game()
  6. {
  7. 	char board[ROW][COL] = { 0 };
  8. 	InitBoard(board, ROW, COL);//初始化
  9.  
  10. }
  11.  
  12.  
  13. //game.h
  14.  
  15. //初始化部分
  16. void InitBoard(char board[ROW][COL], int row, int col);
  17.  
  18.  
  19. //game.c
  20.  
  21. void InitBoard(char board[ROW][COL], int row, int col)
  22. {
  23. 	int i = 0;
  24. 	int j = 0;
  25. 	for (i = 0; i < row; i++)
  26. 	{
  27. 		for (j = 0; j < col; j++)
  28. 		{
  29. 			board[i][j] = ' ';//将空格赋给每个元素
  30. 		}
  31. 	}
  32. }

  • 打印棋盘

打印棋盘时注意也不要把棋盘写死，这里我们定义DisPaly_Board函数，用for循环来打印棋盘，打印“   |   |   |   ”时，将“   |”设定为一组，遍历到最后一列时，只打印“   ”；同理，打印“---|---|---”时，将“---|”设定为一组进行打印，遍历到最后一列时，只打印“---”，遍历到最后一行时都不打印。

  1. //text.c
  2.  
  3. void game()
  4. {
  5. 	char board[ROW][COL] = {0};
  6. 	//初始化
  7. 	InitBoard(board, ROW, COL);
  8. 	//打印棋盘
  9. 	DisPaly_Board(board, ROW, COL);
  10. }
  11.  
  12.  
  13. //game.h
  14.  
  15. void DisPaly_Board(char board[ROW][COL], int row, int col);
  16.  
  17.  
  18. //game.c
  19.  
  20. void DisPaly_Board(char board[ROW][COL], int row, int col)
  21. {
  22. 	int i = 0;
  23. 	int j = 0;
  24.  
  25. 	for (i = 0; i < row; i++)
  26. 	{
  27. 		for (j = 0; j < col; j++)
  28. 		{
  29. 			printf(" %c ", board[i][j]);
  30. 			if (j < col - 1)
  31. 				printf("|");
  32. 		}
  33. 		printf("\n");
  34.  
  35. 		if (i < row - 1)
  36. 		{
  37. 			int j = 0;
  38. 			for (j = 0; j < col; j++)
  39. 			{
  40. 				printf("---");
  41. 				if (j < col - 1)
  42. 				{
  43. 					printf("|");
  44. 				}
  45. 			}
  46. 			printf("\n");
  47. 		}
  48. 	}
  49. }

这样写的好处是：当我们改变define定义的常量时，棋盘的大小也会随之改变。

例如将ROW和COL都改成10：

玩家下棋

在玩家下棋这部分中，我们定义玩家通过输入坐标来进行下棋。需要注意的是：数组所定义的下标是从0开始的，而玩家认知的坐标是从1开始的（例如：玩家想输入第一行第一列的坐标是，输入的是（1，1），而不是（0，0）），这里需要将玩家输入的横、纵坐标减1，转换成数组的坐标。

在玩家输入完坐标后，我们还需要判断该坐标是否合法，如果玩家输入的坐标超限，或者该坐标已经下过棋了，那么需要重新输入坐标。

这里玩家下的棋，用 * 表示。定义PlayerMove用来实现玩家下棋的这部分。

  1. //text.c
  2.  
  3. void game()
  4. {
  5. 	int ret = 0;
  6. 	char board[ROW][COL] = {0};
  7. 	//初始化
  8. 	InitBoard(board, ROW, COL);
  9. 	//打印棋盘
  10. 	DisPaly_Board(board, ROW, COL);
  11. 	while (1)
  12. 	{
  13. 		//玩家下棋
  14. 		PlayerMove(board, ROW, COL);
  15. 		//打印棋盘
  16. 		DisPaly_Board(board, ROW, COL);
  17. 	}
  18.  
  19. }
  20.  
  21.  
  22. //game.h
  23.  
  24. void PlayerMove(char board[ROW][COL], int row, int col);
  25.  
  26.  
  27. //game.c
  28.  
  29. void PlayerMove(char board[ROW][COL], int row, int col)
  30. {
  31. 	int x = 0;
  32. 	int y = 0;
  33. 	while (1)
  34. 	{
  35. 		printf("玩家下棋:>\n");
  36. 		scanf("%d%d", &x, &y);
  37. 		if (x > 0 && x <= row && y > 0 && y <= col)
  38. 		{
  39. 			if (board[x - 1][y - 1] == ' ')
  40. 			{
  41. 				board[x - 1][y - 1] = '*';
  42. 				break;
  43. 			}
  44. 		}
  45. 		printf("坐标非法，请重新输入\n");
  46. 	}
  47. }

当玩家下完棋后，我们需要再将棋盘打印一下。并且下棋是一个有来有回的过程，这里用一个循环将整个下棋的过程包含起来，直到分出胜负或平局跳出循环。

电脑下棋（智能下棋）

电脑下棋分为三个部分：赢棋、堵棋、自由落子。

这里的优先级是赢棋>堵棋>自由落子，在写代码的时候要遵循：能赢则赢，不能赢则堵，以上情况都不符合的时候下新棋的原则。（自由落子不等于下废棋，不能彻底随机）

定义三个函数：

赢棋函数：TryWin（如果函数执行并落子，返回0；否则返回1）

堵棋函数：Cut（如果函数执行并落子，返回0；否则返回1）

自由落子函数：ComputerMove（构建整体框架，根据前两个函数的返回值来判断是否落子）

  • 自由落子

需要注意的是，在下新棋的时候，为了不让该棋变成废棋，需要判定电脑落子附近的8个单元格内至少有一个棋子是玩家的落子。

具体方法如下：先让电脑随机生成一个坐标，然后判定该坐标是否同时满足条件1和条件2，如果满足就落子，如果不满足则重新生成新的坐标，所以这里需要用到while循环，根据优先度的排序，while循环的表达式则是Cut函数的返回值。

条件1：该位置是空地。

条件2：（x,y）相邻的8个元素中，至少有一个格子有玩家的落子。（条件2是为了防止电脑随机下棋下到角落里，该棋便成了废棋）

ComputerMove代码如下：

  1. //game.h
  2. //电脑下棋
  3. void ComputerMove(char board[ROW][COL], int row, int col);
  4.  
  5. //电脑尝试三连
  6. int TryWin(char board[ROW][COL], int row, int col);
  7.  
  8. //堵棋
  9. int Cut(char board[ROW][COL], int row, int col);
  10.  
  11.  
  12. //text.c
  13. srand((unsigned int)time(NULL));//使用rand（）需要在主函数中用srand修饰，提供随机标准。
  14.  
  15.  
  16. //game.c
  17. //电脑下棋
  18. void ComputerMove(char board[ROW][COL], int row, int col)
  19. {
  20. 	printf("电脑下棋:>\n");
  21. 	if (TryWin(board, ROW, COL)==1)//先尝试三连
  22. 	{
  23. 		while (Cut(board, ROW, COL))//不能三连尝试堵棋
  24. 		{
  25. 			int x = rand() % row;
  26. 			int y = rand() % col;
  27. 			//控制范围，不要下的太偏了，新棋下的位置要在玩家落子的位置附近，以免变成废棋
  28. 			if (board[x][y] == ' ' && (board[x - 1][y - 1] == '*' || board[x - 1][y] == '*' || board[x - 1][y - 1] == '*' || board[x][y - 1] == '*' || board[x][y + 1] == '*' || board[x + 1][y - 1] == '*' || board[x + 1][y] == '*' || board[x + 1][y + 1] == '*'))
  29. 			{
  30. 				board[x][y] = '#';
  31. 				break;
  32. 			}
  33. 		}
  34. 	}
  35. 	
  36. }

  • 堵棋

堵棋的优先度在下新棋之上，在赢棋的优先度之下。

堵棋共有四种堵法：横着堵、竖着堵、左斜堵、右斜堵。

将堵棋的大致框架写出，并且为了代码的适用性，这里的代码也不要写死，既要适用三行三列的棋盘，也要同样适用于更大的棋盘。（五行五列、十行十列等等）

当棋盘中不需要堵棋时，返回1；而只要当其中一种情况成立，电脑便落子堵棋，返回0。

堵棋框架：

  1. //game.c
  2. //堵棋
  3.  
  4. int Cut(char board[ROW][COL], int row, int col)
  5. {
  6. 	int i = 0;
  7. 	int j = 0;
  8. for (i = 0; i < row; i++)
  9. 	{
  10. 		for (j = 0; j < col; j++)
  11. 		{
  12. 			//堵横着
  13. 	
  14.             //堵竖着的
  15.  
  16. 			//右斜（左上右下）
  17.  
  18. 			//左斜（左下右上）
  19. 				
  20. 		}
  21. 	}
  22. 	return 1;
  23. }

横着堵：

横着堵有四种情况：XXO、OXX，XOX，以及OXXO（在大棋盘中）。

这里采用for循环遍历来寻找棋盘中是否存在以上四种情况，针对不同的情况，坐标的搜索范围也不一致，这里注意数组的访问不要超出限制。

  1. //堵横着
  2.  
  3. if (j < col - 2)//XOX型
  4. {
  5. 	if (board[i][j] == board[i][j + 2] && board[i][j + 1] == ' ' && board[i][j] == '*')
  6. 	{
  7. 		board[i][j + 1] = '#';
  8. 		return 0;
  9. 	}
  10. }
  11. if (j < col - 1)//XXO或OXX型
  12. {
  13. 	if (board[i][j] == board[i][j + 1] && board[i][j] == '*')
  14. 	{
  15. 		if (j < col - 2 && board[i][j + 2] == ' ' && board[i][j - 1] == ' ')//两种情况都符合
  16. 		{
  17. 			int ch = rand() % 2;//两种情况都符合时，随机下
  18. 			switch (ch)
  19. 			{
  20. 			case 0:
  21. 				board[i][j + 2] = '#';
  22. 				return 0;
  23. 			case 1:
  24. 				board[i][j - 1] = '#';
  25. 				return 0;
  26. 			}
  27. 		}
  28. 		//只符合其中一种情况
  29. 		if (j < col - 2 && board[i][j + 2] == ' ')//XXO
  30. 		{
  31. 			board[i][j + 2] = '#';
  32. 			return 0;
  33. 		}
  34. 		if (board[i][j - 1] == ' ')//OXX
  35. 		{
  36. 			board[i][j - 1] = '#';
  37. 			return 0;
  38. 		}
  39. 	}
  40. }

竖着堵：

竖着堵与横着堵的情况一致，也是四种情况，将横纵坐标的要求对调一下即可。

  1. //堵竖着的
  2. 				//X
  3. 				//0
  4. 				//X型
  5. if (i < row - 2)
  6. {
  7. 	if (board[i][j] == board[i + 2][j] && board[i + 1][j] == ' ' && board[i][j] == '#')
  8. 	{
  9. 		board[i + 1][j] = '#';
  10. 		return 0;
  11. 	}
  12. }
  13. //X      O
  14. //X      X
  15. //O型 或 X型
  16. if (i < row - 1)
  17. {
  18. 	if (board[i][j] == board[i + 1][j] && board[i][j] == '#')
  19. 	{
  20. 		if (i < row - 2 && board[i + 2][j] == ' ' && board[i - 1][j] == ' ')//符合两种情况随机堵
  21. 		{
  22. 			int ch = rand() % 2;
  23. 			switch (ch)
  24. 			{
  25. 			case 0:
  26. 				board[i + 2][j] = '#';
  27. 				return 0;
  28.  
  29. 			case 1:
  30. 				board[i - 1][j] = '#';
  31. 				return 0;
  32.  
  33. 			}
  34. 		}
  35. 		if (i < row - 2 && board[i + 2][j] == ' ')//只有下方可以堵
  36. 		{
  37. 			board[i + 2][j] = '#';
  38. 			return 0;
  39. 		}
  40. 		if (board[i - 1][j] == ' ')//只有上方可以堵
  41. 		{
  42. 			board[i - 1][j] = '#';
  43. 			return 0;
  44. 		}
  45. 	}
  46. }

左斜堵：

左斜堵的情况也是四种,但是需要注意的是，这里符合条件的横纵坐标范围与右斜有很大区别。

  1. //堵斜着（左下右上）
  2. 			//    X
  3. 			//  0
  4. 			//X    型
  5. if (i < row - 2 && j > 1)
  6. {
  7. 	if (board[i][j] == board[i + 2][j - 2] && board[i + 1][j - 1] == ' ' && board[i][j] == '#')
  8. 	{
  9. 		board[i + 1][j - 1] = '#';
  10. 		return 0;
  11. 	}
  12. }
  13. //    X                O
  14. //  X                X
  15. //O     型   或    X      型
  16. if (i < row - 1 && j > 0)
  17. {
  18. 	if (board[i][j] == board[i + 1][j - 1] && board[i][j] == '#')
  19. 	{
  20. 		if (i < row - 2 && j > 1 && board[i + 2][j - 2] == ' ' && board[i - 1][j + 1] == ' ')//符合两种情况随机堵
  21. 		{
  22. 			int ch = rand() % 2;
  23. 			switch (ch)
  24. 			{
  25. 			case 0:
  26. 				board[i + 2][j - 2] = '#';
  27. 				return 0;
  28. 			case 1:
  29. 				board[i - 1][j + 1] = '#';
  30. 				return 0;
  31. 			}
  32. 		}
  33. 		if (i < row - 2 && j > 1 && board[i + 2][j - 2] == ' ')//只有下方可以堵
  34. 		{
  35. 			board[i + 2][j - 2] = '#';
  36. 			return 0;
  37. 		}
  38. 		if (board[i - 1][j + 1] == ' ')//只有上方可以堵
  39. 		{
  40. 			board[i - 1][j + 1] = '#';
  41. 			return 0;
  42. 		}
  43. 	}
  44. }

右斜堵：

  1. //堵斜着（左上右下）
  2.  
  3. 			//X
  4. 			// 0
  5. 			//  X型
  6. if (i < row - 2 && j < col - 2)
  7. {
  8. 	if (board[i][j] == board[i + 2][j + 2] && board[i + 1][j + 1] == ' ' && board[i][j] == '#')
  9. 	{
  10. 		board[i + 1][j + 1] = '#';
  11. 		return 0;
  12. 	}
  13. }
  14. // X         O
  15. //  X          X
  16. //   O型   或    X型
  17. if (i < row - 1 && j < col - 1)
  18. {
  19. 	if (board[i][j] == board[i + 1][j + 1] && board[i][j] == '#')
  20. 	{
  21. 		if (i < row - 2 && j < col - 2 && board[i + 2][j + 2] == ' ' && board[i - 1][j - 1] == ' ')//符合两种情况随机堵
  22. 		{
  23. 			int ch = rand() % 2;
  24. 			switch (ch)
  25. 			{
  26. 			case 0:
  27. 				board[i + 2][j + 2] = '#';
  28. 				return 0;
  29. 			case 1:
  30. 				board[i - 1][j - 1] = '#';
  31. 				return 0;
  32. 			}
  33. 		}
  34. 		if (i < row - 2 && j < col - 2 && board[i + 2][j + 2] == ' ')//只有下方可以堵
  35. 		{
  36. 			board[i + 2][j + 2] = '#';
  37. 			return 0;
  38. 		}
  39.  
  40. 		if (board[i - 1][j - 1] == ' ')//只有上方可以堵
  41. 		{
  42. 			board[i - 1][j - 1] = '#';
  43. 			return 0;
  44. 		}
  45. 	}
  46. }

当我们把上述共十六种的情况都罗列出来后，电脑便会逢棋必堵，并且堵棋函数中所运用到的知识和方法都是C语言初阶的内容，并没有很高深的内容。

  • 赢棋

为了让我们的电脑更进一步，可以抓住玩家露出的破绽，我们再赋予电脑一个赢棋的函数。

而赢棋的优先级也是最高的，毕竟如果游戏都赢了，那就没有堵棋和下棋的事儿了。

赢棋的函数其实和堵棋的函数十分类似，可以说是99.9%都是一致的。

想象一下：在判定是否需要堵棋时，我们其实判定的是玩家是否会赢，如果出现玩家赢的可能，那么我们就要执行堵棋。我们只需要改变一下条件，改成判定电脑是否会赢，如果出现电脑赢的可能，那么就执行赢棋。

例如：

  1. //堵棋
  2.  
  3. if (j < col - 2)//XOX型
  4. {
  5. 	if (board[i][j] == board[i][j + 2] && board[i][j + 1] == ' ' && board[i][j] == '*')
  6. 	{
  7. 		board[i][j + 1] = '#';
  8. 		return 0;
  9. 	}
  10. }
  11.  
  12.  
  13. //赢棋
  14. if (j < col - 2)//XOX型
  15. {
  16. 	if (board[i][j] == board[i][j + 2] && board[i][j + 1] == ' ' && board[i][j] == '#')
  17. 	{
  18. 		board[i][j + 1] = '#';
  19. 		return 0;
  20. 	}
  21. }

将堵棋的代码完全拷贝下来，并将表达式中的*改成#即可。

判断输赢

三子棋的输赢判定方式很简单，横、竖、斜三棋相连，为了不把代码写死，这里将分别对横、竖、斜（左下右上）、斜（右下左上）这四种进行分别判定。

将框架写好，随后在for循环的内部加入判定部分即可。

  1. //game.c
  2.  
  3. int Judgment(char board[ROW][COL], int row, int col)
  4. {
  5. 	int i = 0;
  6. 	int j = 0;
  7. 	for (i = 0; i < row; i++)
  8. 	{
  9. 		for (j = 0; j < col; j++)
  10.         {
  11.                 //判定部分
  12.  
  13.         }
  14.     }
  15. }

因为是三子棋，所以靠近边界的两行没有判断的价值，必然不会有第三个棋与之相连。

当判定为三个相连且不是空格时，只需返回其中一个元素即可，当接收函数返回值时，发现返回值是*，是玩家赢；返回值是#，则是电脑赢。

  • 判定横三连

横着三个相等且不等于空格，将第一个元素返回。

  1. if (i < row  && j < col - 2)//三子棋，所以靠边界的两行没必要判断
  2. 			{
  3. 				if (board[i][j] == board[i][j + 1] && board[i][j + 1] == board[i][j + 2] && board[i][j] && board[i][j] != ' ')
  4. 				{
  5. 					return board[i][j];
  6. 				}
  7. 			}

  • 判断竖三连

竖着三个相等且不等于空格，将第一个元素返回。

  1. 	if (i < row - 2 && j < col)
  2. 			{
  3. 				if (board[i][j] == board[i + 1][j] && board[i + 1][j] == board[i + 2][j] && board[i][j] != ' ')
  4. 				{
  5. 					return board[i][j];
  6. 				}
  7. 			}

  • 判断斜三连（左下右上）

斜三连的情况稍微复杂一点，正斜和反斜针对i和j的取值范围不同，并且坐标的变换也不一样。

  1. 	if (i < row-2 && j > 1)  
  2. 			{
  3. 				if (board[i][j] == board[i + 1][j - 1] && board[i + 1][j - 1] == board[i + 2][j - 2] && board[i][j] != ' ')
  4. 				{
  5. 					return board[i][j];
  6. 				}
  7. 			}

  • 判断斜三连（左下右上）

  1. if (i < row-2 && j < col-2 )
  2. 			{
  3. 				if (board[i][j] == board[i + 1][j + 1] && board[i + 1][j + 1] == board[i + 2][j + 2] && board[i][j] != ' ')
  4. 				{
  5. 					return board[i][j];
  6. 				}
  7. 			}

  • 判断平局

除了输赢，还会有平局的情况发生，判断平局的方法很简单，遍历一遍整个数组，当发现没有‘ ’时，即平局了。这里如果平局则返回q，没有平局则返回c，判断平局的部分要放在判断输赢的后面。

  1.  
  2. //判断平局
  3. int IsFull(char board[ROW][COL], int row, int col)
  4. {
  5. 	int i = 0;
  6. 	int j = 0;
  7. 	for (i = 0; i < row; i++)
  8. 	{
  9. 		for (j = 0; j < col; j++)
  10. 		{
  11. 			if (board[i][j] == ' ')
  12. 			{
  13. 				return 0;
  14. 			}
  15. 		}
  16. 	}
  17. 	return 1;
  18. }
  19.  
  20.  
  21. if (IsFull(board, row, col))
  22. 	{
  23. 		return 'q';
  24. 	}
  25. 	return 'c';

测试

当完成了所有代码后，这里我们用5×5的棋盘可以更好的测试一下。

当玩家先手下棋后，电脑在堵截玩家这方面还是咬的很死的，现在电脑有一个三连的机会，我们卖一个破绽，看看电脑能否抓住。

电脑不负众望抓住了机会，踏上了人工智能面向世界的第一步。我们这里设定的是玩家先手，玩家的优势稍微大一点。

如果想要设置电脑先手的话，还需要对电脑下棋部分的代码再加一点东西：即当整个棋盘是空的时候，电脑在中心区域随机下棋。（我们之前的代码一直是电脑负责对玩家的落子进行围追堵截，没有先手的情况）

改进

其实整个代码还是有很大的优化空间的：

1、受到三子棋的限制，在3×3的棋盘太过无趣，但当三子棋在大棋盘中进行游玩时，先手一方必赢。

这里可以将三子棋改成五子棋，本质框架不变，但是需要堵棋的情况会比三子棋要多出一些。

2、电脑在堵棋时，如果是10×10的大棋盘，那么会出现可以两头堵的情况，在最初设定时，我们设置的是两头随机堵，但是现实中这样往往会错失良机。电脑的下棋也是如此，我们只是设置了一个随机坐标，保证在玩家落子的附近，但不能保证该坐标就是最优的选择。那么如何改进呢？

我们可以对整个棋盘设置权重P

当该坐标周围一圈附近8个元素中每多一颗电脑的棋子，P+10；

附近8个元素中每多一颗玩家的棋子，P+5；

该坐标周围第二圈附近16个元素中每多一颗电脑的棋子，P+5;

该坐标周围第二圈附近16个元素中每多一颗玩家的棋子，P+2。

以此类推，离坐标越远权重越低，每次电脑下棋前，遍历一遍棋盘，选择权重最高的方法下，如果有权重相同的情况，再选择周围空位最多的坐标。

除以上两点之外，其实还有更多细节之处可以优化，有兴趣的小伙伴可以自己尝试一下。

整体代码展示

这里为了方便大家的测试与改进，我把全部的代码放在下面。如果有不足之处，还请大家多多指点。

text.c

  1. //三子棋
  2. #include"game.h"
  3.  
  4.  
  5.  
  6. void menu()
  7. {
  8. 	printf("******************\n");
  9. 	printf("***** 1.paly *****\n");
  10. 	printf("***** 0.exit *****\n");
  11. 	printf("******************\n");
  12. }
  13.  
  14. void game()
  15. {
  16. 	int ret = 0;
  17. 	char board[ROW][COL] = {0};
  18. 	//初始化
  19. 	InitBoard(board, ROW, COL);
  20. 	//打印棋盘
  21. 	DisPaly_Board(board, ROW, COL);
  22. 	while (1)
  23. 	{
  24. 		//玩家下棋
  25. 		PlayerMove(board, ROW, COL);
  26. 		//打印棋盘
  27. 		DisPaly_Board(board, ROW, COL);
  28. 		//判断输赢
  29. 		ret = Judgment(board, ROW, COL);
  30. 		if (ret != 'c')
  31. 		{
  32. 			break;
  33. 		}
  34. 		//电脑下棋
  35. 		ComputerMove(board, ROW, COL);
  36. 		//打印棋盘
  37. 		DisPaly_Board(board, ROW, COL);
  38. 		//判断输赢
  39. 		ret = Judgment(board, ROW, COL);
  40. 		if (ret != 'c')
  41. 		{
  42. 			break;
  43. 		}
  44. 	}
  45. 	if (ret == '*')
  46. 	{
  47. 		printf("玩家赢了\n");
  48. 	}
  49. 	else if (ret == '#')
  50. 	{
  51. 		printf("电脑赢了\n");
  52. 	}
  53. 	else
  54. 		printf("平局\n");
  55. }
  56.  
  57.  
  58. int main()
  59. {
  60. 	int input = 0;
  61. 	srand((unsigned int)time(NULL));
  62. 	do
  63. 	{
  64. 		menu();
  65. 		printf("请选择(1/0):>");
  66. 		scanf("%d", &input);
  67. 		switch (input)
  68. 		{
  69. 		case 0:
  70. 			printf("退出游戏\n");
  71. 			break;
  72. 		case 1:
  73. 			printf("开始游戏\n");
  74. 			game();//游戏
  75. 			Sleep(500);
  76. 			system("cls");//清空屏幕
  77. 			break;
  78. 		default:
  79. 			printf("输入错误，请重新输入\n");
  80. 		}
  81. 	} while (input);
  82. 	return 0;
  83. }

game.h

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<time.h>
  4. #include<windows.h>
  5.  
  6.  
  7. #define ROW 5//在测试的时候，建议将行和列设置稍微大一点
  8. #define COL 5
  9.  
  10. //初始化
  11. void InitBoard(char board[ROW][COL], int row,int col);
  12.  
  13. //打印棋盘
  14. void DisPaly_Board(char board[ROW][COL], int row, int col);
  15.  
  16. //玩家下棋
  17. void PlayerMove(char board[ROW][COL], int row, int col);
  18.  
  19. //电脑尝试三连
  20. int TryWin(char board[ROW][COL], int row, int col);
  21.  
  22. //堵棋
  23. int Cut(char board[ROW][COL], int row, int col);
  24.  
  25. //电脑下棋
  26. void ComputerMove(char board[ROW][COL], int row, int col);
  27.  
  28. //判断输赢
  29. int Judgment(char board[ROW][COL], int row, int col);

game.c

  1. #include"game.h"
  2.  
  3.  
  4. //初始化
  5. void InitBoard(char board[ROW][COL], int row, int col)
  6. {
  7. 	int i = 0;
  8. 	int j = 0;
  9. 	for (i = 0; i < row; i++)
  10. 	{
  11. 		for (j = 0; j < col; j++)
  12. 		{
  13. 			board[i][j] = ' ';
  14. 		}
  15. 	}
  16. }
  17.  
  18. //打印棋盘
  19. void DisPaly_Board(char board[ROW][COL], int row, int col)
  20. {
  21. 	int i = 0;
  22. 	int j = 0;
  23.  
  24. 	for (i = 0; i < row; i++)
  25. 	{
  26. 		for (j = 0; j < col; j++)
  27. 		{
  28. 			printf(" %c ", board[i][j]);
  29. 			if (j < col - 1)
  30. 				printf("|");
  31. 		}
  32. 		printf("\n");
  33.  
  34. 		if (i < row - 1)
  35. 		{
  36. 			int j = 0;
  37. 			for (j = 0; j < col; j++)
  38. 			{
  39. 				printf("---");
  40. 				if (j < col - 1)
  41. 				{
  42. 					printf("|");
  43. 				}
  44. 			}
  45. 			printf("\n");
  46. 		}
  47. 	}
  48. }
  49.  
  50. //玩家下棋
  51. void PlayerMove(char board[ROW][COL], int row, int col)
  52. {
  53. 	int x = 0;
  54. 	int y = 0;
  55. 	while (1)
  56. 	{
  57. 		printf("玩家下棋:>\n");
  58. 		scanf("%d%d", &x, &y);
  59. 		if (x > 0 && x <= row && y > 0 && y <= col)
  60. 		{
  61. 			if (board[x - 1][y - 1] == ' ')
  62. 			{
  63. 				board[x - 1][y - 1] = '*';
  64. 				break;
  65. 			}
  66. 		}
  67. 		printf("坐标非法，请重新输入\n");
  68. 	}
  69. }
  70.  
  71.  
  72. //电脑下棋（堵棋）
  73. int Cut(char board[ROW][COL], int row, int col)
  74. {
  75. 	int i = 0;
  76. 	int j = 0;
  77. 	for (i = 0; i < row; i++)
  78. 	{
  79. 		for (j = 0; j < col; j++)
  80. 		{
  81. 			//堵横着
  82. 			if (j < col - 2)//XOX型
  83. 			{
  84. 				if (board[i][j] == board[i][j + 2] && board[i][j + 1] == ' ' && board[i][j] == '*')
  85. 				{
  86. 					board[i][j + 1] = '#';
  87. 					return 0;
  88. 				}
  89. 			}
  90. 			if (j < col - 1)//XXO或OXX型
  91. 			{
  92. 				if (board[i][j] == board[i][j + 1] && board[i][j] == '*')
  93. 				{
  94. 					if (j < col - 2 && board[i][j + 2] == ' ' && board[i][j - 1] == ' ')//两种情况都符合
  95. 					{
  96. 						int ch = rand() % 2;//两种情况都符合时，随机下
  97. 						switch (ch)
  98. 						{
  99. 						case 0:
  100. 							board[i][j + 2] = '#';
  101. 							return 0;
  102. 						case 1:
  103. 							board[i][j - 1] = '#';
  104. 							return 0;
  105. 						}
  106. 					}
  107. 					//只符合其中一种情况
  108. 					if (j < col - 2 && board[i][j + 2] == ' ')//XXO
  109. 					{
  110. 						board[i][j + 2] = '#';
  111. 						return 0;
  112. 					}
  113. 					if (board[i][j - 1] == ' ')//OXX
  114. 					{
  115. 						board[i][j - 1] = '#';
  116. 						return 0;
  117. 					}
  118. 				}
  119. 			}
  120.  
  121. 			//堵竖着的
  122. 				//X
  123. 				//0
  124. 				//X型
  125. 			if (i < row - 2)
  126. 			{
  127. 				if (board[i][j] == board[i + 2][j] && board[i + 1][j] == ' ' && board[i][j] == '*')
  128. 				{
  129. 					board[i + 1][j] = '#';
  130. 					return 0;
  131. 				}
  132. 			}
  133. 			//X      O
  134. 			//X      X
  135. 			//O型 或 X型
  136. 			if (i < row - 1)
  137. 			{
  138. 				if (board[i][j] == board[i + 1][j] && board[i][j] == '*')
  139. 				{
  140. 					if (i < row - 2 && board[i + 2][j] == ' ' && board[i - 1][j] == ' ')//符合两种情况随机堵
  141. 					{
  142. 						int ch = rand() % 2;
  143. 						switch (ch)
  144. 						{
  145. 						case 0:
  146. 							board[i + 2][j] = '#';
  147. 							return 0;
  148.  
  149. 						case 1:
  150. 							board[i - 1][j] = '#';
  151. 							return 0;
  152. 						}
  153. 					}
  154. 					if (i < row - 2 && board[i + 2][j] == ' ')//只有下方可以堵
  155. 					{
  156. 						board[i + 2][j] = '#';
  157. 						return 0;
  158. 					}
  159. 					if (board[i - 1][j] == ' ')//只有上方可以堵
  160. 					{
  161. 						board[i - 1][j] = '#';
  162. 						return 0;
  163. 					}
  164. 				}
  165. 			}
  166. 			//堵斜着（左上右下）
  167. 			//X
  168. 			// 0
  169. 			//  X型
  170. 			if (i < row - 2 && j < col - 2)
  171. 			{
  172. 				if (board[i][j] == board[i + 2][j + 2] && board[i + 1][j + 1] == ' ' && board[i][j] == '*')
  173. 				{
  174. 					board[i + 1][j + 1] = '#';
  175. 					return 0;
  176. 				}
  177. 			}
  178. 			// X         O
  179. 			//  X          X
  180. 			//   O型   或    X型
  181. 			if (i < row - 1 && j < col - 1)
  182. 			{
  183. 				if (board[i][j] == board[i + 1][j + 1] && board[i][j] == '*')
  184. 				{
  185. 					if (i < row - 2 && j < col - 2 && board[i + 2][j + 2] == ' ' && board[i - 1][j - 1] == ' ')//符合两种情况随机堵
  186. 					{
  187. 						int ch = rand() % 2;
  188. 						switch (ch)
  189. 						{
  190. 						case 0:
  191. 							board[i + 2][j + 2] = '#';
  192. 							return 0;
  193. 						case 1:
  194. 							board[i - 1][j - 1] = '#';
  195. 							return 0;
  196. 						}
  197. 					}
  198. 					if (i < row - 2 && j < col - 2 && board[i + 2][j + 2] == ' ')//只有下方可以堵
  199. 					{
  200. 						board[i + 2][j + 2] = '#';
  201. 						return 0;
  202. 					}
  203.  
  204. 					if (board[i - 1][j - 1] == ' ')//只有上方可以堵
  205. 					{
  206. 						board[i - 1][j - 1] = '#';
  207. 						return 0;
  208. 					}
  209. 				}
  210. 			}
  211.  
  212. 			//堵斜着（左下右上）
  213. 			//    X
  214. 			//  0
  215. 			//X    型
  216. 			if (i < row - 2 && j > 1)
  217. 			{
  218. 				if (board[i][j] == board[i + 2][j - 2] && board[i + 1][j - 1] == ' ' && board[i][j] == '*')
  219. 				{
  220. 					board[i + 1][j - 1] = '#';
  221. 					return 0;
  222. 				}
  223. 			}
  224. 			//    X                O
  225. 			//  X                X
  226. 			//O     型   或    X      型
  227. 			if (i < row - 1 && j > 0)
  228. 			{
  229. 				if (board[i][j] == board[i + 1][j - 1] && board[i][j] == '*')
  230. 				{
  231. 					if (i < row - 2 && j > 1 && board[i + 2][j - 2] == ' ' && board[i - 1][j + 1] == ' ')//符合两种情况随机堵
  232. 					{
  233. 						int ch = rand() % 2;
  234. 						switch (ch)
  235. 						{
  236. 						case 0:
  237. 							board[i + 2][j - 2] = '#';
  238. 							return 0;
  239. 						case 1:
  240. 							board[i - 1][j + 1] = '#';
  241. 							return 0;
  242. 						}
  243. 					}
  244. 					if (i < row - 2 && j > 1 && board[i + 2][j - 2] == ' ')//只有下方可以堵
  245. 					{
  246. 						board[i + 2][j - 2] = '#';
  247. 						return 0;
  248. 					}
  249. 					if (board[i - 1][j + 1] == ' ')//只有上方可以堵
  250. 					{
  251. 						board[i - 1][j + 1] = '#';
  252. 						return 0;
  253. 					}
  254.  
  255. 				}
  256. 			}
  257. 		}
  258. 	}
  259. 	return 1;
  260. }
  261.  
  262. //电脑下棋（尝试三连）
  263. int TryWin(char board[ROW][COL], int row, int col)
  264. {
  265. 	int i = 0;
  266. 	int j = 0;
  267. 	for (i = 0; i < row; i++)
  268. 	{
  269. 		for (j = 0; j < col; j++)
  270. 		{
  271. 			//堵横着
  272. 			if (j < col - 2)
  273. 			{
  274. 				if (board[i][j] == board[i][j + 2] && board[i][j + 1] == ' ' && board[i][j] == '#')//XOX型
  275. 				{
  276. 					board[i][j + 1] = '#';
  277. 					return 0;
  278. 				}
  279. 			}
  280. 			if (j < col - 1)//XXO或OXX型
  281. 			{
  282. 				if (board[i][j] == board[i][j + 1] && board[i][j] == '#')
  283. 				{
  284. 					if (j < col - 2 && board[i][j + 2] == ' ' && board[i][j - 1] == ' ')//两种情况都符合
  285. 					{
  286. 						int ch = rand() % 2;
  287. 						switch (ch)
  288. 						{
  289. 						case 0:
  290. 							board[i][j + 2] = '#';
  291. 							return 0;
  292. 						case 1:
  293. 							board[i][j - 1] = '#';
  294. 							return 0;
  295. 						}
  296. 					}
  297. 					if (j < col - 2 && board[i][j + 2] == ' ')
  298. 					{
  299. 						board[i][j + 2] = '#';
  300. 						return 0;
  301. 					}
  302. 					if (board[i][j - 1] == ' ')
  303. 					{
  304. 						board[i][j - 1] = '#';
  305. 						return 0;
  306. 					}
  307. 				}
  308. 			}
  309.  
  310. 			//堵竖着的
  311. 				//X
  312. 				//0
  313. 				//X型
  314. 			if (i < row - 2)
  315. 			{
  316. 				if (board[i][j] == board[i + 2][j] && board[i + 1][j] == ' ' && board[i][j] == '#')
  317. 				{
  318. 					board[i + 1][j] = '#';
  319. 					return 0;
  320. 				}
  321. 			}
  322. 			//X      O
  323. 			//X      X
  324. 			//O型 或 X型
  325. 			if (i < row - 1)
  326. 			{
  327. 				if (board[i][j] == board[i + 1][j] && board[i][j] == '#')
  328. 				{
  329. 					if (i < row - 2 && board[i + 2][j] == ' ' && board[i - 1][j] == ' ')//符合两种情况随机堵
  330. 					{
  331. 						int ch = rand() % 2;
  332. 						switch (ch)
  333. 						{
  334. 						case 0:
  335. 							board[i + 2][j] = '#';
  336. 							return 0;
  337.  
  338. 						case 1:
  339. 							board[i - 1][j] = '#';
  340. 							return 0;
  341.  
  342. 						}
  343. 					}
  344. 					if (i < row - 2 && board[i + 2][j] == ' ')//只有下方可以堵
  345. 					{
  346. 						board[i + 2][j] = '#';
  347. 						return 0;
  348. 					}
  349. 					if (board[i - 1][j] == ' ')//只有上方可以堵
  350. 					{
  351. 						board[i - 1][j] = '#';
  352. 						return 0;
  353. 					}
  354. 				}
  355. 			}
  356. 			//堵斜着（左上右下）
  357. 			//X
  358. 			// 0
  359. 			//  X型
  360. 			if (i < row - 2 && j < col - 2)
  361. 			{
  362. 				if (board[i][j] == board[i + 2][j + 2] && board[i + 1][j + 1] == ' ' && board[i][j] == '#')
  363. 				{
  364. 					board[i + 1][j + 1] = '#';
  365. 					return 0;
  366. 				}
  367. 			}
  368. 			// X         O
  369. 			//  X          X
  370. 			//   O型   或    X型
  371. 			if (i < row - 1 && j < col - 1)
  372. 			{
  373. 				if (board[i][j] == board[i + 1][j + 1] && board[i][j] == '#')
  374. 				{
  375. 					if (i < row - 2 && j < col - 2 && board[i + 2][j + 2] == ' ' && board[i - 1][j - 1] == ' ')//符合两种情况随机堵
  376. 					{
  377. 						int ch = rand() % 2;
  378. 						switch (ch)
  379. 						{
  380. 						case 0:
  381. 							board[i + 2][j + 2] = '#';
  382. 							return 0;
  383. 						case 1:
  384. 							board[i - 1][j - 1] = '#';
  385. 							return 0;
  386. 						}
  387. 					}
  388. 					if (i < row - 2 && j < col - 2 && board[i + 2][j + 2] == ' ')//只有下方可以堵
  389. 					{
  390. 						board[i + 2][j + 2] = '#';
  391. 						return 0;
  392. 					}
  393.  
  394. 					if (board[i - 1][j - 1] == ' ')//只有上方可以堵
  395. 					{
  396. 						board[i - 1][j - 1] = '#';
  397. 						return 0;
  398. 					}
  399. 				}
  400. 			}
  401.  
  402. 			//堵斜着（左下右上）
  403. 			//    X
  404. 			//  0
  405. 			//X    型
  406. 			if (i < row - 2 && j > 1)
  407. 			{
  408. 				if (board[i][j] == board[i + 2][j - 2] && board[i + 1][j - 1] == ' ' && board[i][j] == '#')
  409. 				{
  410. 					board[i + 1][j - 1] = '#';
  411. 					return 0;
  412. 				}
  413. 			}
  414. 			//    X                O
  415. 			//  X                X
  416. 			//O     型   或    X      型
  417. 			if (i < row - 1 && j > 0)
  418. 			{
  419. 				if (board[i][j] == board[i + 1][j - 1] && board[i][j] == '#')
  420. 				{
  421. 					if (i < row - 2 && j > 1 && board[i + 2][j - 2] == ' ' && board[i - 1][j + 1] == ' ')//符合两种情况随机堵
  422. 					{
  423. 						int ch = rand() % 2;
  424. 						switch (ch)
  425. 						{
  426. 						case 0:
  427. 							board[i + 2][j - 2] = '#';
  428. 							return 0;
  429. 						case 1:
  430. 							board[i - 1][j + 1] = '#';
  431. 							return 0;
  432. 						}
  433. 					}
  434. 					if (i < row - 2 && j > 1 && board[i + 2][j - 2] == ' ')//只有下方可以堵
  435. 					{
  436. 						board[i + 2][j - 2] = '#';
  437. 						return 0;
  438. 					}
  439. 					if (board[i - 1][j + 1] == ' ')//只有上方可以堵
  440. 					{
  441. 						board[i - 1][j + 1] = '#';
  442. 						return 0;
  443. 					}
  444. 				}
  445. 			}
  446. 		}
  447. 	}
  448. 	return 1;
  449. }
  450.  
  451.  
  452.  
  453. //电脑下棋
  454. void ComputerMove(char board[ROW][COL], int row, int col)
  455. {
  456. 	printf("电脑下棋:>\n");
  457. 	if (TryWin(board, ROW, COL) == 1)//先尝试三连
  458. 	{
  459. 		while (Cut(board, ROW, COL))//不能三连尝试堵棋
  460. 		{
  461. 			int x = rand() % row;
  462. 			int y = rand() % col;
  463. 			//控制范围，不要下的太偏了
  464. 			if (board[x][y] == ' ' && (board[x - 1][y - 1] == '*' || board[x - 1][y] == '*' || board[x - 1][y - 1] == '*' || board[x][y - 1] == '*' || board[x][y + 1] == '*' || board[x + 1][y - 1] == '*' || board[x + 1][y] == '*' || board[x + 1][y + 1] == '*'))
  465. 			{
  466. 				board[x][y] = '#';
  467. 				break;
  468. 			}
  469.  
  470. 		}
  471. 	}
  472. }
  473.  
  474.  
  475.  
  476.  
  477.  
  478.  
  479.  
  480. //判断平局
  481. int IsFull(char board[ROW][COL], int row, int col)
  482. {
  483. 	int i = 0;
  484. 	int j = 0;
  485. 	for (i = 0; i < row; i++)
  486. 	{
  487. 		for (j = 0; j < col; j++)
  488. 		{
  489. 			if (board[i][j] == ' ')
  490. 			{
  491. 				return 0;
  492. 			}
  493. 		}
  494. 	}
  495. 	return 1;
  496. }
  497.  
  498.  
  499. //判断输赢
  500. int Judgment(char board[ROW][COL], int row, int col)
  501. {
  502. 	int i = 0;
  503. 	int j = 0;
  504. 	for (i = 0; i < row; i++)
  505. 	{
  506. 		for (j = 0; j < col; j++)
  507. 		{
  508. 			//判断横行是否相连
  509. 			if (i < row && j < col - 2)//三子棋，所以靠边界的两行没必要判断
  510. 			{
  511. 				if (board[i][j] == board[i][j + 1] && board[i][j + 1] == board[i][j + 2] && board[i][j] && board[i][j] != ' ')
  512. 				{
  513. 					return board[i][j];
  514. 				}
  515. 			}
  516. 			//判断竖行是否相连
  517. 			if (i < row - 2 && j < col)
  518. 			{
  519. 				if (board[i][j] == board[i + 1][j] && board[i + 1][j] == board[i + 2][j] && board[i][j] != ' ')
  520. 				{
  521. 					return board[i][j];
  522. 				}
  523. 			}
  524. 			//判断斜行是否相连(左下右上)
  525. 			if (i < row - 2 && j > 1)
  526. 			{
  527. 				if (board[i][j] == board[i + 1][j - 1] && board[i + 1][j - 1] == board[i + 2][j - 2] && board[i][j] != ' ')
  528. 				{
  529. 					return board[i][j];
  530. 				}
  531. 			}
  532. 			//判断斜行是否相连(右下左上)
  533. 			if (i < row - 2 && j < col - 2)
  534. 			{
  535. 				if (board[i][j] == board[i + 1][j + 1] && board[i + 1][j + 1] == board[i + 2][j + 2] && board[i][j] != ' ')
  536. 				{
  537. 					return board[i][j];
  538. 				}
  539. 			}
  540. 		}
  541. 	}
  542. 	if (IsFull(board, row, col))//判断平局
  543. 	{
  544. 		return 'q';
  545. 	}
  546. 	return 'c';
  547. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/1017756
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号