一个你永远都赢不了的三子棋

已于 2023-11-21 07:08:11 修改
阅读量150 收藏 2
点赞数 6
分类专栏： C语言 文章标签： 算法
于 2023-11-20 20:30:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78784978/article/details/134513993
版权

这是一个你永远都赢不了的三子棋，先将代码放出来，感兴趣的可以试一下。

为了方便讲解，我将代码放在了三个区域：

game.h头文件

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include <time.h>
#define ROW 3
#define COL 3
void Initboard(char board[ROW][COL], int row, int col);
void Displayboard(char board[ROW][COL], int row, int col);
void Playertime(char board[ROW][COL], int row, int col);
void Computertime(char board[ROW][COL], int row, int col);
char Win(char board[ROW][COL], int row, int col);
int Full(char board[ROW][COL], int row, int col);

test.c源文件：

#include "game.h"
void game()
{
	char ret = 0;
	char board[ROW][COL];
	Initboard(board, ROW, COL);
	Displayboard(board, ROW, COL);
	while(1)
	{
		Playertime(board, ROW, COL);
		ret = Win(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
		Computertime(board, ROW, COL);
		ret = Win(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
	}
	if (ret == '*')
	{
		system("cls");
		printf("你赢了，");
		printf("游戏结果：\n");
		Displayboard(board, ROW, COL);
	}
	else if (ret == '#')
	{
		system("cls");
		printf("电脑赢了，");
		printf("游戏结果：\n");
		Displayboard(board, ROW, COL);
	}
	else
	{
		system("cls");
		printf("平局");
		printf("游戏结果：\n");
		Displayboard(board, ROW, COL);
	}
}
void menu()
{
	printf("********************\n");
	printf("*******1.play*******\n");
	printf("*******0.exit*******\n");
	printf("********************\n");
}
int main()
{
	int input = 0;
	int inputt = 0;
	srand((unsigned int)time(NULL));
	do {
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Sleep(1000);
			system("cls");
			begin:
			game();
			printf("想要再来一盘吗？\n");
			printf("再来一盘请按1\n");
			printf("按其它键结束游戏\n");
			scanf("%d", &inputt);
			if (inputt == 1)
			{
				system("cls");
				goto begin;
			}
			else
			{
				printf("退出游戏中");
				Sleep(1000);
				system("cls");
				printf("退出成功");
				Sleep(1000);
				system("cls");
				goto end;
			}
		case 0:
			printf("退出游戏中");
			Sleep(1000);
			system("cls");
			printf("退出成功");
			Sleep(1000);
			system("cls");
			break;
		default:
			printf("选择错误，请重新选择");
			Sleep(1000);
			system("cls");
			break;
		}
	} while (input);
	end:
	return 0;
}

game.c源文件：

#include "game.h"
void Initboard(char board[ROW][COL], int row, int col)
{
	int i, j;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}
void Displayboard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for(j = 0;j < col-1 ; j++)
		{
			printf(" %c |", board[i][j]);
			if (j == 1)
			{
				printf(" %c", board[i][j+1]);
			}
			if (j == col - 2 && i != row-1)
			{
				printf("\n");
				for (j = 0; j < col; j++)
					if (j < col - 1)
					{
						printf("---|");
					}
					else
					{
						printf("---");
					}
			}
		}
		printf("\n");
	}
}
void Playertime(char board[ROW][COL], int row, int col)
{
	int x = 1;
	int y = 1;
	again:
	printf("请玩家下棋（输入坐标）\n");
	scanf("%d %d", &x, &y);
	while (1)
	{
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (board[x - 1][y - 1] == ' ')
			{
				board[x - 1][y - 1] = '*';
				system("cls");
				Displayboard(board, ROW, COL);
				break;
			}
			else
			{
				printf("此位已被占用，请重新输入\n");
				Sleep(1500);
				system("cls");
				Displayboard(board, ROW, COL);
				goto again;
			}
		}
		else
		{
			printf("输入错误，请重新输入");
			Sleep(1000);
			system("cls");
			Displayboard(board, ROW, COL);
			goto again;
		}
	}
}
void Computertime(char board[ROW][COL], int row, int col)
{
	printf("电脑正在下棋\n");
	int i = 0;
	int j = 0;
	int w = 0, p = 0;
	for (i = 0; i < ROW; i++)
	{
		for (j = 0; j < COL; j++)
		{
			if (board[i][j] == '*')
			{
				w++;
			}
			if (board[i][j] == '#')
			{
				p++;
			}
		}
	}
	Sleep(1000);
	if (board[1][1] == '*')
	{
		for (i = 0; i < row; i++)
		{
			if ((board[i][0] == board[i][1] && board[i][0] == '#') || (board[i][2] == board[i][1] && board[i][1] == '#') || (board[i][0] == board[i][2] && board[i][2] == '#'))
			{
				for (j = 0; j < COL; j++)
				{
					if (board[i][j] == ' ')
					{
						board[i][j] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						goto end;
					}
				}
			}
		}
		for (j = 0; j < col; j++)
		{
			if ((board[0][j] == board[1][j] && board[0][j] == '#') || (board[2][j] == board[1][j] && board[1][j] == '#') || (board[0][j] == board[2][j] && board[0][j] == '#'))
			{
				for (i = 0; i < COL; i++)
				{
					if (board[i][j] == ' ')
					{
						board[i][j] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						goto end;
					}
				}
			}
		}
		if ((board[0][0] == board[1][1] && board[0][0] == '#') || (board[2][2] == board[1][1] && board[1][1] == '#') || (board[0][0] == board[2][2] && board[0][0] == '#'))
		{
			for (j = 0; j < COL; j++)
			{
				if (board[j][j] == ' ')
				{
					board[j][j] = '#';
					system("cls");
					Displayboard(board, ROW, COL);
					goto end;
				}
			}
		}
		if ((board[0][2] == board[1][1] && board[0][2] == '#') || (board[2][0] == board[1][1] && board[1][1] == '#') || (board[2][0] == board[0][2] && board[2][0] == '#'))
		{
			for (j = 0; j < COL; j++)
			{
				if (board[j][2 - j] == ' ')
				{
					board[j][2 - j] = '#';
					system("cls");
					Displayboard(board, ROW, COL);
					goto end;
				}
			}
		}
			if (board[1][1] == '*' && w == 1)
			{
				int x = rand() % (row + 1);
				if (x == 0)
				{
					board[0][2] = '#';
					system("cls");
					Displayboard(board, ROW, COL);
				}
				if (x == 1)
				{
					board[2][0] = '#';
					system("cls");
					Displayboard(board, ROW, COL);
				}
				if (x == 2)
				{
					board[0][0] = '#';
					system("cls");
					Displayboard(board, ROW, COL);
				}
				if (x == 3)
				{
					board[2][2] = '#';
					system("cls");
					Displayboard(board, ROW, COL);
				}
			}
			else
			{
				for(int x=0;x<ROW;x++)
				{
					for(int y=0;y<COL;y++)
					{
						if (board[x][y] == '*' && board[2 - x][2 - y] == ' ' && (!(x == 1 && y == 1)))
						{
							board[2 - x][2 - y] = '#';
							system("cls");
							Displayboard(board, ROW, COL);
							goto end;
						}
					}
				}
				if (((board[0][0] == board[1][1]) && (board[0][0] == ' ') && (board[2][2] == '#')) || ((board[2][2] == board[1][1]) && (board[1][1] == ' ') && (board[0][0] == '#')) || ((board[0][0] == board[2][2]) && (board[0][0] == ' ') && (board[1][1] == '#')))
				{
					for (j = 0;; j += 2)
					{
						if (board[j][j] == ' ')
						{
							board[j][j] = '#';
							system("cls");
							Displayboard(board, ROW, COL);
							goto end;
						}
					}
				}
				if ((board[0][2] == board[1][1] && (board[0][2] == ' ') && board[2][0] == '#') || (board[2][0] == board[1][1] && (board[1][1] == ' ') && board[0][2] == '#') || (board[2][0] == board[0][2] && (board[2][0] == ' ') && board[1][1] == '#'))
				{
					for (j = 0;; j += 2)
					{
						if (board[j][2 - j] == ' ')
						{
							board[j][2 - j] = '#';
							system("cls");
							Displayboard(board, ROW, COL);
							goto end;
						}
					}
				}
				for (i = 0; i < row; i++)
				{
					if ((board[i][0] == board[i][1] && (board[i][0] == ' ') && board[i][2] == '#') || (board[i][2] == board[i][1] && (board[i][1] == ' ') && board[i][0] == '#') || (board[i][0] == board[i][2] && (board[i][2] == ' ') && board[i][1] == '#'))
					{
						for (j = 0;; j += 2)
						{
							if (board[i][j] == ' ')
							{
								board[i][j] = '#';
								system("cls");
								Displayboard(board, ROW, COL);
								goto end;
							}
						}
					}
				}
				for (j = 0; j < col; j++)
				{
					if ((board[0][j] == board[1][j] && (board[0][j] == ' ') && board[2][j] == '#') || (board[2][j] == board[1][j] && (board[1][j] == ' ') && board[0][j] == '#') || (board[0][j] == board[2][j] && (board[0][j] == ' ') && board[1][j] == '#'))
					{
						for (i = 0;; i += 2)
						{
							if (board[i][j] == ' ')
							{
								board[i][j] = '#';
								system("cls");
								Displayboard(board, ROW, COL);
								goto end;
							}
						}
					}
				}
				while (1)
				{
					int f = rand() % 3;
					int h = rand() % 3;
					if (board[f][h] == ' ')
					{
						board[f][h] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						break;
					}
				}
			}
	}
	else
	{
		for (i = 0; i < row; i++)
		{
			if ((board[i][0] == board[i][1] && board[i][0] == '#') || (board[i][2] == board[i][1] && board[i][1] == '#') || (board[i][0] == board[i][2] && board[i][2] == '#'))
			{
				for (j = 0; j < COL; j++)
				{
					if (board[i][j] == ' ')
					{
						board[i][j] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						goto end;
					}
				}
			}
		}
		for (j = 0; j < col; j++)
		{
			if ((board[0][j] == board[1][j] && board[0][j] == '#') || (board[2][j] == board[1][j] && board[1][j] == '#') || (board[0][j] == board[2][j] && board[0][j] == '#'))
			{
				for (i = 0; i < COL; i++)
				{
					if (board[i][j] == ' ')
					{
						board[i][j] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						goto end;
					}
				}
			}
		}
		if ((board[0][0] == board[1][1] && board[0][0] == '#') || (board[2][2] == board[1][1] && board[1][1] == '#') || (board[0][0] == board[2][2] && board[0][0] == '#'))
		{
			for (j = 0; j < COL; j++)
			{
				if (board[j][j] == ' ')
				{
					board[j][j] = '#';
					system("cls");
					Displayboard(board, ROW, COL);
					goto end;
				}
			}
		}
		if ((board[0][2] == board[1][1] && board[0][2] == '#') || (board[2][0] == board[1][1] && board[1][1] == '#') || (board[2][0] == board[0][2] && board[2][0] == '#'))
		{
			for (j = 0; j < COL; j++)
			{
				if (board[j][2 - j] == ' ')
				{
					board[j][2 - j] = '#';
					system("cls");
					Displayboard(board, ROW, COL);
					goto end;
				}
			}
		}
		if (board[1][1] == ' ')
			{
				board[1][1] = '#';
				system("cls");
				Displayboard(board, ROW, COL);
			}
		else
			{
			if ((board[0][0] == board[1][1] && board[0][0] == '*') || (board[2][2] == board[1][1] && board[1][1] == '*') || (board[0][0] == board[2][2] && board[0][0] == '*'))
			{
				for (j = 0; j < COL; j++)
				{
					if (board[j][j] == ' ')
					{
						board[j][j] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						goto end;
					}
				}
			}
			if ((board[0][2] == board[1][1] && board[0][2] == '*') || (board[2][0] == board[1][1] && board[1][1] == '*') || (board[2][0] == board[0][2] && board[2][0] == '*'))
			{
				for (j = 0; j < COL; j++)
				{
					if (board[j][2 - j] == ' ')
					{
						board[j][2 - j] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						goto end;
					}
				}
			}
			for (i = 0; i < row; i++)
				{
					if ((board[i][0] == board[i][1] && board[i][0] == '*') || (board[i][2] == board[i][1] && board[i][1] == '*') || (board[i][0] == board[i][2] && board[i][2] == '*'))
					{
						for (j = 0; j < COL; j++)
						{
							if (board[i][j] == ' ')
							{
								board[i][j] = '#';
								system("cls");
								Displayboard(board, ROW, COL);
								goto end;
							}
						}
					}
				}
			for (j = 0; j < col; j++)
				{
					if ((board[0][j] == board[1][j] && board[0][j] == '*') || (board[2][j] == board[1][j] && board[1][j] == '*') || (board[0][j] == board[2][j] && board[0][j] == '*'))
					{
						for (i = 0; i < COL; i++)
						{
							if (board[i][j] == ' ')
							{
								board[i][j] = '#';
								system("cls");
								Displayboard(board, ROW, COL);
								goto end;
							}
						}
					}
				}
			for (i = 0; i < row; i++)
				{
				if ((board[i][0] == board[i][1] && (board[i][0] == ' ') && board[i][2] == '#') || (board[i][2] == board[i][1] && (board[i][1] == ' ') && board[i][0] == '#') || (board[i][0] == board[i][2] && (board[i][2] == ' ') && board[i][1] == '#'))
					{
						for (j = 0;; j += 2)
						{
							if (board[i][j] == ' ')
							{
								board[i][j] = '#';
								system("cls");
								Displayboard(board, ROW, COL);
								goto end;
							}
						}
					}
				}
			for (j = 0; j < col; j++)
				{
				if ((board[0][j] == board[1][j] && (board[0][j] == ' ') && board[2][j] == '#') || (board[2][j] == board[1][j] && (board[1][j] == ' ') && board[0][j] == '#') || (board[0][j] == board[2][j] && (board[0][j] == ' ') && board[1][j] == '#'))
					{
						for (i = 0;; i += 2)
						{
							if (board[i][j] == ' ')
							{
								board[i][j] = '#';
								system("cls");
								Displayboard(board, ROW, COL);
								goto end;
							}
						}
					}
				}
			if (((board[0][0] == board[1][1]) && (board[0][0] == ' ') && (board[2][2] == '#')) || ((board[2][2] == board[1][1]) && (board[1][1] == ' ') && (board[0][0] == '#')) || ((board[0][0] == board[2][2]) && (board[0][0] == ' ') && (board[1][1] == '#')))
			{
				for (j = 0; j < COL; j++)
				{
					if (board[j][j] == ' ')
					{
						board[j][j] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						goto end;
					}
				}
			}
			if ((board[0][2] == board[1][1] && (board[0][2] == ' ') && board[2][0] == '#') || (board[2][0] == board[1][1] && (board[1][1] == ' ') && board[0][2] == '#') || (board[2][0] == board[0][2] && (board[2][0] == ' ') && board[1][1] == '#'))
			{
				for (j = 0; j < COL; j++)
				{
					if (board[j][2 - j] == ' ')
					{
						board[j][2 - j] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						goto end;
					}
				}
			}
		    while (1)
					{
						int f = rand() % 3;
						int h = rand() % 3;
						if (board[f][h] == ' ')
						{
							board[f][h] = '#';
							system("cls");
							Displayboard(board, ROW, COL);
							break;
						}
					}	
		    }
	}
end:
	;
}
int Full(char board[ROW][COL], int row, int col)
{
	int i, j;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
			{
				return 0;
			}
		}
	}
	return 1;
}
char Win(char board[ROW][COL], int row, int col)
{
	int i,j;
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][2] == board[i][1] && board[i][1] != ' ')
		{
			return board[i][0];
		}
	}
	for (j = 0; j < col; j++)
	{
		if (board[0][j] == board[1][j] && board[2][j] == board[1][j] && board[1][j] != ' ')
		{
			return board[0][j];
		}
	}
	if (board[0][0] == board[1][1] && board[2][2] == board[1][1] && board[1][1] != ' ')
	{
		return board[0][0];
	}
	if (board[0][2] == board[1][1] && board[2][0] == board[1][1] && board[1][1] != ' ')
	{
		return board[0][0];
	}
	int full=Full(board, ROW, COL);
	if (full == 1)
	{
		return 'Q';
	}
	if (full == 0)
	{
		return 'C';
	}
}

这里的重头戏当然就是电脑执行的部分，首先我将下面这一部分代码,即电脑防玩家的部分命名为"电脑防"

if ((board[0][0] == board[1][1] && board[0][0] == '*') || (board[2][2] == board[1][1] && board[1][1] == '*') || (board[0][0] == board[2][2] && board[0][0] == '*'))
{
	for (j = 0; j < COL; j++)
	{
		if (board[j][j] == ' ')
		{
			board[j][j] = '#';
			system("cls");
			Displayboard(board, ROW, COL);
			goto end;
		}
	}
}
if ((board[0][2] == board[1][1] && board[0][2] == '*') || (board[2][0] == board[1][1] && board[1][1] == '*') || (board[2][0] == board[0][2] && board[2][0] == '*'))
{
	for (j = 0; j < COL; j++)
	{
		if (board[j][2 - j] == ' ')
		{
			board[j][2 - j] = '#';
			system("cls");
			Displayboard(board, ROW, COL);
			goto end;
		}
	}
}
for (i = 0; i < row; i++)
	{
		if ((board[i][0] == board[i][1] && board[i][0] == '*') || (board[i][2] == board[i][1] && board[i][1] == '*') || (board[i][0] == board[i][2] && board[i][2] == '*'))
		{
			for (j = 0; j < COL; j++)
			{
				if (board[i][j] == ' ')
				{
					board[i][j] = '#';
					system("cls");
					Displayboard(board, ROW, COL);
					goto end;
				}
			}
		}
	}
for (j = 0; j < col; j++)
	{
		if ((board[0][j] == board[1][j] && board[0][j] == '*') || (board[2][j] == board[1][j] && board[1][j] == '*') || (board[0][j] == board[2][j] && board[0][j] == '*'))
		{
			for (i = 0; i < COL; i++)
			{
				if (board[i][j] == ' ')
				{
					board[i][j] = '#';
					system("cls");
					Displayboard(board, ROW, COL);
					goto end;
				}
			}
		}
	}

这里的两个if是防守两条斜线的,即如果在一条线上有两个玩家的棋时就得防守

两个for语句则是防守竖着三列和横着三排的

然后我将下面这一部分电脑在不需要防御时攻击玩家的部分拷贝下来,简称"电脑攻"跟"电脑防"相似,两条斜线方向和三条竖线三条横线上若有一个地方是棋盘下的而其他两处是空的,则可以下在两个地方的其中一处,而优先下在哪里下面会细讲

if (((board[0][0] == board[1][1]) && (board[0][0] == ' ') && (board[2][2] == '#')) || ((board[2][2] == board[1][1]) && (board[1][1] == ' ') && (board[0][0] == '#')) || ((board[0][0] == board[2][2]) && (board[0][0] == ' ') && (board[1][1] == '#')))
{
				for (j = 0;; j += 2)
				{
					if (board[j][j] == ' ')
					{
						board[j][j] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						goto end;
					}
				}
}
if ((board[0][2] == board[1][1] && (board[0][2] == ' ') && board[2][0] == '#') || (board[2][0] == board[1][1] && (board[1][1] == ' ') && board[0][2] == '#') || (board[2][0] == board[0][2] && (board[2][0] == ' ') && board[1][1] == '#'))
{
				for (j = 0;; j += 2)
				{
					if (board[j][2 - j] == ' ')
					{
						board[j][2 - j] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						goto end;
					}
				}
}
for (i = 0; i < row; i++)
{
				if ((board[i][0] == board[i][1] && (board[i][0] == ' ') && board[i][2] == '#') || (board[i][2] == board[i][1] && (board[i][1] == ' ') && board[i][0] == '#') || (board[i][0] == board[i][2] && (board[i][2] == ' ') && board[i][1] == '#'))
				{
					for (j = 0;; j += 2)
					{
						if (board[i][j] == ' ')
						{
							board[i][j] = '#';
							system("cls");
							Displayboard(board, ROW, COL);
							goto end;
						}
					}
				}
}
for (j = 0; j < col; j++)
{
				if ((board[0][j] == board[1][j] && (board[0][j] == ' ') && board[2][j] == '#') || (board[2][j] == board[1][j] && (board[1][j] == ' ') && board[0][j] == '#') || (board[0][j] == board[2][j] && (board[0][j] == ' ') && board[1][j] == '#'))
				{
					for (i = 0;; i += 2)
					{
						if (board[i][j] == ' ')
						{
							board[i][j] = '#';
							system("cls");
							Displayboard(board, ROW, COL);
							goto end;
						}
					}
				}
}

这里重点介绍的是电脑下棋的原理，因此就暂且不分析三子棋游戏的制作过程了。

工作原理大致如下：（以下’#‘为电脑下的棋，’*‘则视为玩家下的棋）

因为玩家先下，所以可以将代码分为两部分，第一部分是玩家将第一颗棋下在中间的位置，这时电脑如果下在九宫格上下左右的四个位置任意一处，玩家就一定有机会赢，示例如下：

b5b49a93422648609e44006a3a3cf2cd.png

假设电脑将棋子下在（1，2），则玩家可以下在（3，3）处，这样的话电脑就必须堵在（1，1）处，此时玩家下在（1，3）处时，电脑不论是堵住（3，1）还是（2，3）玩家都能稳赢

故我们只能让电脑将棋下在四个角中的任意一处，而下在哪一处就可以用时间戳确定的随机值来确定了，代码如下：

if (board[1][1] == '*' && w == 1)
{
	int x = rand() % (row + 1);
	if (x == 0)
	{
		board[0][2] = '#';
		system("cls");
		Displayboard(board, ROW, COL);
	}
	if (x == 1)
	{
		board[2][0] = '#';
		system("cls");
		Displayboard(board, ROW, COL);
	}
	if (x == 2)
	{
		board[0][0] = '#';
		system("cls");
		Displayboard(board, ROW, COL);
	}
	if (x == 3)
	{
		board[2][2] = '#';
		system("cls");
		Displayboard(board, ROW, COL);
	}
}

 这里的'w'是在开始的时候监测棋盘中玩家下的棋的个数，因为只需要在玩家在中间下了一棋之后电脑在四角下棋，其他情况就没有必要了，故w==1时才能在四角任下一棋。

而后面玩家再下一棋后就一定会出现一条线上有两个是玩家的棋，因为玩家已经在中盘下了一棋，此时电脑就得防守了，若玩家下在二维数组的（0，0）处，则电脑需要堵在（2-0，2-0）即（2，2）处，若玩家下在二维数组的（0，1）处，则电脑需要将棋下在（2-0，2-1）即（2，1）处

则代码如下

for(int x=0;x<ROW;x++)
{
				for(int y=0;y<COL;y++)
				{
					if (board[x][y] == '*' && board[2 - x][2 - y] == ' ' && (!(x == 1 && y == 1)))
					{
						board[2 - x][2 - y] = '#';
						system("cls");
						Displayboard(board, ROW, COL);
						goto end;
					}
				}
}

但还是得防玩家不将棋子下在有机会连成线的情况,例如下面情况:

9170fa868fae4a1f8efc6282660c3036.png

这种情况就不需要防守了,所以为了防止这种现象,我们就得写一段代码让电脑攻,上面已经将电脑攻讲到了,而我们要判断的就是电脑应当先将棋子下在哪里,若将棋子下在上下左右四个格子中的一处,玩家就又有机会赢得游戏,解释与之前的相似故省略,所以我们可以先将棋子下在对角线处,而这里有一步可以减少计算机的计算量即:

for (i = 0;; i += 2)

这样的话电脑就会先监测j=0和j=2处,而不会监测j=1即中间的坐标,因为中间已经有棋了,所以再监测也没有意义了

而后面的while部分主要为了防一些特殊情况,则直接让电脑下在随机坐标,根据目前监测来看基本上是用不到的

---------------------------------------------------------------------------------------------------------------------------------下面讲解玩家第一步没有下在中间的情况,这样来看的话电脑第一步直接将棋下在中间就行了,即

if (board[1][1] == ' ')
	{
		board[1][1] = '#';
		system("cls");
		Displayboard(board, ROW, COL);
	}

然后就要将优先级最高的防玩家部分写下来了,即将"电脑防"的部分写下来,上面已经讲到过就不重复代码了

那么接下来就是写"电脑攻"的部分了,这里同样要考虑下棋优先级的问题,首先电脑一定不能将棋下在四角处,这里与第一部分的攻击方式不同,原因如下:

d4dc2afdf3d34930ae1ca0e41848e104.png

假设玩家将棋下在二维数组(0,0)处,电脑首先肯定将棋下在棋盘中间,然后玩家若将棋下在棋盘的右下角处,而电脑将棋下在了右上角,则玩家再将棋下在左下角处电脑就基本不可能获胜了

因此先攻中路,即中间的一排,用两个for语句就可以将棋下在第二排的左边或右边,之后再监测两条对角线,这样防守就更加坚固了

后面的while部分主要为了防一些特殊情况,则直接让电脑下在随机坐标,根据目前监测来看基本上是用不到的(目前还没有发现)

而电脑如果发现有一条线上有两个都是自己的棋而另一处正好是空白,则直接将最后一棋下出来获得游戏胜利,这个优先级无疑是最高的,故放在两种情况的代码的最前面,即

for (i = 0; i < row; i++)
{
	if ((board[i][0] == board[i][1] && board[i][0] == '#') || (board[i][2] == board[i][1] && board[i][1] == '#') || (board[i][0] == board[i][2] && board[i][2] == '#'))
	{
		for (j = 0; j < COL; j++)
		{
			if (board[i][j] == ' ')
			{
				board[i][j] = '#';
				system("cls");
				Displayboard(board, ROW, COL);
				goto end;
			}
		}
	}
}
for (j = 0; j < col; j++)
{
	if ((board[0][j] == board[1][j] && board[0][j] == '#') || (board[2][j] == board[1][j] && board[1][j] == '#') || (board[0][j] == board[2][j] && board[0][j] == '#'))
	{
		for (i = 0; i < COL; i++)
		{
			if (board[i][j] == ' ')
			{
				board[i][j] = '#';
				system("cls");
				Displayboard(board, ROW, COL);
				goto end;
			}
		}
	}
}
if ((board[0][0] == board[1][1] && board[0][0] == '#') || (board[2][2] == board[1][1] && board[1][1] == '#') || (board[0][0] == board[2][2] && board[0][0] == '#'))
{
	for (j = 0; j < COL; j++)
	{
		if (board[j][j] == ' ')
		{
			board[j][j] = '#';
			system("cls");
			Displayboard(board, ROW, COL);
			goto end;
		}
	}
}
if ((board[0][2] == board[1][1] && board[0][2] == '#') || (board[2][0] == board[1][1] && board[1][1] == '#') || (board[2][0] == board[0][2] && board[2][0] == '#'))
{
	for (j = 0; j < COL; j++)
	{
		if (board[j][2 - j] == ' ')
		{
			board[j][2 - j] = '#';
			system("cls");
			Displayboard(board, ROW, COL);
			goto end;
		}
	}
}

至此,电脑下棋部分的代码就讲完了,作为一名大一新生写一篇博客不容易,所以麻烦各位点一个免费的赞支持一下我吧,感谢观看!

 

刘家炫
关注
  • 6
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
暖心AI陪你下三子棋.zip
12-06
"暖心AI陪你下三子棋"正是一款利用人工智能技术，专为那些需要陪伴的人设计的休闲游戏。通过与AI对弈，不仅能够消磨时间，还能在智力的碰撞中找到乐趣，帮助玩家找回自我。 三子棋，又称井字游戏，是一种简单却富有...
C语言实现简单三子棋程序
08-27
"C语言实现简单三子棋程序...本资源为读者提供了一个完整的三子棋程序的实现方法，包括数组的初始化、棋盘的打印、电脑和玩家的走棋、输赢的判断等。通过学习本资源，读者可以提高自己的C语言编程技巧和逻辑思维能力。
为何谷歌围棋AI AlphaGo可能会把李世石击溃
张俊林的博客
02-03 1万+
谷歌DeepMind开发的人工智能围棋程序AlphaGo以5:0的压倒性优势击败了欧洲围棋冠军、专业二段棋手Fan Hui，这是最近一周来最火爆的新闻了。16年3月份AlphaGo会和最近10年平均成绩表现最优秀的韩国九段、世界冠军李世石进行对弈，这无疑也是最吸引眼球的一场人机世纪大战，如果此役AlphaGo获胜，这意味着人工智能真正里程碑式的胜利，从此起码在智力博弈类游戏范围内，碳基体人类将无法抵挡硅基类机器的狂风骤雨，不知这是该令人惊恐还是令人兴奋呢？
C语言小项目——井字棋游戏（升级版）
热门推荐
Edison's 小宇宙
01-25 3万+
史上最强三子棋/井字棋小游戏（动图+示例+升级版+代码详解）
人工智能在围棋程序中的应用
cjianwyr的博客
02-07 9004
围棋程序的编制被称作人工智能的“试金石”，是人工智能技术的一大难题。    本文介绍了人工智能在围棋程序中的应用与发展，对比了围棋与国际象棋博弈算法的差别和复杂度，从而分析围棋算法的难点，讨论各种博弈算法（气位理论、模式匹配与博弈树）在围棋程序中的融合运用。 【关键字】  围棋，搜索，模式匹配，博弈树 一、概述    1、围棋简介 　　围棋相传为尧所创，纵
3D游戏引擎剖析
wolf96的专栏
02-21 4769
介绍 自Doom游戏时代以来我们已经走了很远。 DOOM不只是一款伟大的游戏，它同时也开创了一种新的游戏编程模式: 游戏 "引擎"。 这种模块化，可伸缩和扩展的设计观念可以让游戏玩家和程序设计者深入到游戏核心，用新的模型，场景和声音创造新的游戏， 或向已有的游戏素材中添加新的东西。大量的新游戏根据已经存在的游戏引擎开发出来，而大多数都以ID公司的Quake引擎为基础， 这些游戏包括Coun
（转载）人工智能在围棋程序中的应用——复旦大学附属中学（施遥）
weixin_30371875的博客
02-27 532
人工智能在围棋程序中的应用 复旦大学附属中学 施 遥 【关键字】 围棋，搜索，模式匹配，博弈树 【摘要】 围棋程序的编制被称作人工智能的“试金石”，是人工智能技术的一大难题。 本文介绍了人工智能在围棋程序中的应用与发展，对比了围棋与国际象棋博弈算法的差别和复杂度，从而分析围棋算法的难点，讨论各种博弈算法（气位理论、模式匹配与博弈树）在围棋程序...
【人工智能】未来三年（2018-2020），我们在新一代人工智能产业能做什么
产业智能官
01-17 1万+
国务院于2017年7月21日印发了《新一代人工智能发展规划》，提出了面向2030年我国新一代人工智能发展的指导思想、战略目标、重点任务和保障措施，部署构筑我国人工智能发展的先发优势，加快建设创新型国家和世界科技强国。工信部于2017年12月14日印发了《促进新一代人工智能产业发展三年行动计划（2018-2020年）》，明确以信息技术与制造技术深度融合为主线，以新一代人工智能技术的产业化和集成应用为
游戏引擎介绍------个人认为很不错的一篇游戏开发的文章
hada1234的专栏
12-21 6652
游戏引擎介绍 第1部分: 游戏引擎介绍， 渲染和构造3D世界 介绍　　自Doom游戏时代以来我们已经走了很远。 DOOM不只是一款伟大的游戏，它同时也开创了一种新的游戏编程模式: 游戏 "引擎"。 这种模块化，可伸缩和扩展的设计观念可以让游戏玩家和程序设计者深入到游戏核心，用新的模型，场景和声音创造新的游戏， 或向已有的游戏素材中添加新的东西。大量的新游戏根据已经存在的游戏引擎开发出来，而大多数都
算法 {博弈论,组合游戏,SG游戏}
qq_66485519的博客
03-20 107
1
幽灵的礼物
it草稿纸
04-06 5192
1 幽灵的礼物 前言我是你成功背后的影子 序言在幽灵的礼物中发现金矿 引子分享幽灵的智慧 第一章你是谁？交易圈中的幽灵 第二章备战交易：大师的匠心 第三章规则一：只持有正确的仓位 第四章规则二：正确加码才能获利 第五章规则一加二实战示范 第六章当日交易：规则成就短线高手 第七章妙手连连赢定期权 第八章图表交易：大师的天机 第九章一声棒喝：改变你的行为习惯 第十章跟我来游戏：放松练就创造力 第十一章...
三子棋_三子棋_
10-03
在本文中，我们将深入探讨三子棋的基本规则、常见策略以及提升技巧，让你在游戏中更上一层楼。 一、基本规则 三子棋的棋盘通常为3x3或4x4的方格，双方玩家分别执黑子和白子，目标是在棋盘上连成一线，即横向、纵向...
SanZiQi1.rar_三子棋
09-24
在SanZiQi1.rar_三子棋这个项目中，我们探讨了如何实现一个基本的三子棋游戏，并特别关注了人机对战模式下计算机的随机走法。下面将详细阐述这个游戏的实现原理、设计思路以及随机算法的应用。 一、游戏规则与界面...
sanziqi.zip_sanziqi java_三子棋
09-23
这里我们关注的是一个用Java语言编写的三子棋程序——"sanziqi.zip_sanziqi java_三子棋"。三子棋，也称井字游戏，是一个简单但策略丰富的双人对弈游戏，它对于初学者来说是理解游戏逻辑和编程概念的绝佳案例。 ...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 878
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 181
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
cf场+线性dp
xxx_jsu的博客
07-23 329
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法-KMP字符串匹配
xx_xb的博客
07-23 262
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
C++实现人机对弈三子棋程序设计
"该资源是一个关于使用C++编程语言设计三子棋游戏的课程设计项目。项目旨在实现一个人机对弈的三子棋游戏，玩家与计算机交替在棋盘上下棋，目标是形成水平、垂直或对角线上的连续三个同色棋子以赢得比赛。系统具备...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

刘家炫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值