C语言实现三子棋(会堵棋,加强版)智能AI博弈

已于 2023-07-06 12:21:34 修改
阅读量1.8k 收藏 19
点赞数 34
分类专栏： C语言 初阶算法 游戏 文章标签： c语言 开发语言 游戏程序
于 2022-11-10 22:24:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AkieMo/article/details/127797093
版权
初阶算法 同时被 3 个专栏收录
9 篇文章 0 订阅
订阅专栏
C语言
4 篇文章 0 订阅
订阅专栏
游戏
2 篇文章 0 订阅
订阅专栏

目录

 三子棋介绍:

功能实现:

1:打印菜单

 2:棋盘初始化

3:打印棋盘

 4:玩家下棋

5:电脑下棋

5:输赢的判断

代码总和：

C语言实现三子棋(会堵棋,加强版)智能AI博弈

 三子棋介绍:

三子棋是一种民间传统游戏，又叫九宫棋、圈圈叉叉棋、一条龙、井字棋等。游戏分为双方对战，双方依次在9宫格棋盘上摆放棋子，率先将自己的三个棋子走成一条线就视为胜利，而对方就算输了，但是三子棋在很多时候会出现和棋的局面。

功能实现:

1:打印菜单

2:棋盘初始化

3:打印棋盘

4:玩家下棋

5:电脑下棋（优化）

6：判断输赢

1:打印菜单

void meue() {
	printf("**************************\n");
	printf("**************************\n");
	printf("****1.Play******0.Exit****\n");
	printf("**************************\n");
	printf("**************************\n");
}

 2:棋盘初始化

首先，三子棋是一个3*3的棋盘，所以我们可以用一个二维数组来表示这个棋盘，当没有下棋的时候棋盘为空，而怎么用二维数组表示呢？

我们可以将一个char类型的二维数组全部初始化为空格，这样就能表示空棋盘了

3:打印棋盘

首先对棋盘进行分析:

一共5行，第一行由空格（' '）和  |  组成，但 | 只有两个，因此需要进行判断

第二行全部由---组成，却只有两行，所以也需要进行判断

这是一个3*3的棋盘，row=3,col=3。条件则为i<row-1的时候打印 | ，j<col-1的时候打印---

void print_board(char board[ROW][COL], int row, int col) {
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++) 
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1) 
			{
				printf("|");
			}
		}
			printf("\n");
			if (i < row - 1) 
			{
				for (j = 0; j < col; j++)
				{
					printf("---");
					if (j < col - 1) 
					{
						printf("|");
					}
				}
					printf("\n");
		}
	}
}

 4:玩家下棋

玩家下棋的时候X和Y的坐标范围都是（1，3），但数组是从0开始算的，所以我们需要将X和Y减1才能作为数组中的下标使用，在下棋子的时候需要进行判断，这个坐标是否合法，是否没有被占用

void player_move(char board[ROW][COL], int row, int col) {
	printf("玩家下棋\n");
	while (1) {
		printf("请输入要下的坐标:>");
		int x = 0, y = 0;
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= y && y <= col) {
			if (board[x - 1][y - 1] == ' ') {
				board[x - 1][y - 1] = '*';
				break;
			}
			else {
				printf("坐标已经被占用,请重新输入\n");
			}
		}
		else {
			printf("坐标不合法,请重新输入\n");
		}
	}
}

5:电脑下棋

首先展示无脑版本，堵棋全看运气->利用随机数种子来下棋，随机生成的数组%3得到的范围就是(0,2)，刚好是数组的下标范围

void cmp_move(char board[ROW][COL], int row, int col) {
	printf("电脑下棋:\n");
	while (1) {
		int x = rand() % row;
		int y = rand() % col;
		if (board[x][y] == ' ') {
			board[x][y] = '#';
			break;
		}
	}
}

接下来是会堵棋的版本:

思路很简单，直接遍历整个数组，行 列 对角线是否有满足凑齐了两个还空一个的位置，是的话就堵，这里可以使用一个计数器来记录该方向是否存在两个相同的棋子，并且是否有空的位置，我们新定义两个变量X和Y来记录空格的位置，将X和Y初始化为-1，这样就可以判断出是否真的找到了空位，而不需要用flag来判断

而什么时候进攻，什么时候防守呢？那当然是能进攻就进攻，不能进攻则防守咯。

还有就是能抢（2，2）的位置一定要抢，抢不到则在四个角落随便找个位置，这里我选择左上角的位置

int intelligence_play(char board[ROW][COL], int row, int col) {
	//先抢占（2，2）的位置，若已经被占用，则下四个角落之一，以左上角为例（1，1）->对应的数组坐标为(0,0);
	if (board[1][1] == ' ') {
		board[1][1] = '#';
		return 1;
	}
	else if(board[0][0]==' ') {
		board[0][0] = '#';
		return 1;
	}
	//抢占位置后判断是攻还是防
	//cnt用于记录玩家棋子个数，cnt1为电脑，x，y为空格的坐标
	int cnt = 0, cnt1 = 0, x = -1, y = -1, x1 = -1, y1 = -1, flag = 1;
	//先判断自己是否满足胜利条件
	//判断行
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			if (board[i][j] == '#') {
				cnt++;
			}
			if (board[i][j] == ' ') {
				//记录空的位置
				x = i, y = j;
			}
			if (cnt == 2&&x!=-1&&y!=-1) {
				//开始进攻，连成三个棋，计数清零
				cnt = 0;
				board[x][y] = '#';
				x = -1, y = -1;
				return 1;
			}
		}
		//每一行检查结束后需要计数清零
		cnt = 0;
		x = -1, y = -1;
	}
	//是否需要进行堵棋
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			if (board[i][j] == '*') {
				cnt1++;
			}
			if (board[i][j] == ' ') {
				x = i, y = j;
			}
			if (cnt1 == 2 && x != -1 && y != -1) {
				cnt = 0;
				board[x][y] = '#';
				x = -1, y = -1;
				return 1;
			}
		}
		cnt1 = 0;
		x = -1, y = -1;
	}
	//判断列
	for (int j = 0; j < col; j++) {
		for (int i = 0; i < row; i++) {
			if (board[i][j] == '#') {
				cnt++;
			}
			if (board[i][j] == ' ') {
				x = i, y = j;
			}
			if (cnt == 2 && x != -1 && y != -1) {
				cnt = 0;
				board[x][y] = '#';
				x = -1, y = -1;
				return 1;
			}
		}
		cnt = 0;
		x = -1, y = -1;
	}
	for (int j = 0; j < col; j++) {
		for (int i = 0; i < row; i++) {
			if (board[i][j] == '*') {
				cnt++;
			}
			if (board[i][j] == ' ') {
				x = i, y = j;
			}
			if (cnt == 2 && x != -1 && y != -1) {
				cnt = 0;
				board[x][y] = '#';
				x = -1, y = -1;
				return 1;
			}
		}
		cnt = 0;
		x = -1, y = -1;
	}
	//判断逆对角线
	for (int i = 0; i < row; i++) {
		if (board[i][row - i - 1] == '#') {
			cnt++;
		}
		if (board[i][row - i - 1] == ' ') {
			x = i, y = row - i - 1;
		}
		if (cnt == 2 && x != -1 && y != -1) {
			cnt = 0;
			board[x][y] = '#';
			x = -1, y = -1;
			return 1;
		}
	}
	cnt = 0, x = -1, y = -1;
	for (int i = 0; i < row; i++) {
		if (board[i][row - i - 1] == '*') {
			cnt++;
		}
		if (board[i][row - i - 1] == ' ') {
			x = i, y = row - i - 1;
		}
		if (cnt == 2 && x != -1 && y != -1) {
			cnt = 0;
			board[x][y] = '#';
			x = -1, y = -1;
			return 1;
		}
	}
	cnt = 0, x = -1, y = -1;
	//判断逆对角线
	for (int i = 0; i < row; i++) {
		if (board[i][i] == '#') {
			cnt++;
		}
		if (board[i][i] == ' ') {
			x = i, y = row - i - 1;
		}
		if (cnt == 2 && x != -1 && y != -1) {
			cnt = 0;
			board[x][y] = '#';
			x = -1, y = -1;
			return 1;
		}
	}
	cnt = 0, x = -1, y = -1;
	for (int i = 0; i < row; i++) {
		if (board[i][i] == '*') {
			cnt++;
		}
		if (board[i][i] == ' ') {
			x = i, y = row - i - 1;
		}
		if (cnt == 2 && x != -1 && y != -1) {
			cnt = 0;
			board[x][y] = '#';
			x = -1, y = -1;
			return 1;
		}
	}
	cnt = 0, x = -1, y = -1;
	//如果上述条件都不满足，则随机下棋
	cmp_move(board, row, col);
}

5:输赢的判断

先判断棋盘是否已经满了，这个很简单，直接遍历整个数组，如果还能找到有空格的位置就还没有满，找不到了就满了

int isfull(char board[ROW][COL], int row, int col) {
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			if (board[i][j] == ' ') {
				return 0;
			}
		}
	}
	return 1;
}

接下来是判断输赢：

#为电脑赢，*为玩家赢了,Q为平局，C为继续游戏

用两个计数器来记录玩家和电脑棋子在该方向上的棋子数量，当等于3的时候就胜利

char iswin(char board[ROW][COL], int row, int col) {
	int num0f0 = 0;//玩家
	int num0fX = 0;//电脑
	//判断行
	for (int i = 0; i < row; i++) {
		num0f0 = num0fX = 0;
		for (int j = 0; j < col; j++) {
			if (board[i][j] == '*') {
				num0f0++;
			}
			else if (board[i][j] == '#') {
				num0fX++;
			}
		}
		if (num0f0 == ROW) {
			return '*';
		}
		else if (num0fX == COL) {
			return '#';
		}
	}
	//判断列
	for (int j = 0; j < col; j++) {
		num0f0 = num0fX = 0;
		for (int i = 0; i < row; i++) {
			if (board[i][j] == '*') {
				num0f0++;
			}
			else if (board[i][j] == '#') {
				num0fX++;
			}
		}
		if (num0f0 == row) {
			return '*';
		}
		else if (num0fX == col) {
			return '#';
		}
	}
	//判断正对角线
	num0f0 = num0fX = 0;
	for (int i = 0; i < row; i++) {
			if (board[i][i] == '*') {
				num0f0++;
			}
			else if (board[i][i] == '#') {
				num0fX++;
			}
		}
		if (num0f0 == row) {
			return '*';
		}
		else if (num0fX == col) {
			return '#';
		}
	//检查逆对角线
		num0f0 = num0fX = 0;
		for (int i = 0; i < row; i++) {
			if (board[i][row - i - 1] == '*') {
				num0f0++;
			}
			else if (board[i][row - i - 1] == '#') {
				num0fX++;
			}
		}
		if (num0f0 == row) {
			return '*';
		}
		else if (num0fX == col) {
			return '#';
		}
		//判断是否平均，是否需要继续
		int ret = isfull(board, ROW, COL);
		if (ret == 1) {
			return 'Q';
		}
		else {
			return 'C';//继续游戏
		}
}

代码总和：

game.h文件

#pragma once
#define COL 3
#define ROW 3
//函数申明
void init_board(char board[ROW][COL],int row, int col);
void print_board(char board[ROW][COL], int row, int col);
int isfull(char board[ROW][COL], int row, int col);
char iswin(char board[ROW][COL], int row, int col);

game.c文件

#include"game.h"
#include<stdlib.h>
#include<time.h>

//初始化棋盘为空格
void init_board(char board[ROW][COL], int row, int col) {
	for (int i = 0; i < row;i++) 
	{
		for (int j = 0; j < col;j++) 
		{
			board[i][j] = ' ';
		}
	}
}
//打印棋盘
void print_board(char board[ROW][COL], int row, int col) {
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++) 
		{
			printf(" %c ", board[i][j]);
			if (j < col - 1) 
			{
				printf("|");
			}
		}
			printf("\n");
			if (i < row - 1) 
			{
				for (j = 0; j < col; j++)
				{
					printf("---");
					if (j < col - 1) 
					{
						printf("|");
					}
				}
					printf("\n");
		}
	}
}

void player_move(char board[ROW][COL], int row, int col) {
	printf("玩家下棋\n");
	while (1) {
		printf("请输入要下的坐标:>");
		int x = 0, y = 0;
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= y && y <= col) {
			if (board[x - 1][y - 1] == ' ') {
				board[x - 1][y - 1] = '*';
				break;
			}
			else {
				printf("坐标已经被占用,请重新输入\n");
			}
		}
		else {
			printf("坐标不合法,请重新输入\n");
		}
	}
}
//电脑下棋，简单版本->随机生成坐标rand()
void cmp_move(char board[ROW][COL], int row, int col) {
	printf("电脑下棋:\n");
	while (1) {
		int x = rand() % row;
		int y = rand() % col;
		if (board[x][y] == ' ') {
			board[x][y] = '#';
			break;
		}
	}
}
//判断棋盘是否已经满了,如果满了则返回1，没满返回0
int isfull(char board[ROW][COL], int row, int col) {
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			if (board[i][j] == ' ') {
				return 0;
			}
		}
	}
	return 1;
}
//判断胜负
//#为电脑赢，*为玩家赢了,Q为平局，C为继续游戏
char iswin(char board[ROW][COL], int row, int col) {
	int num0f0 = 0;//玩家
	int num0fX = 0;//电脑
	//判断行
	for (int i = 0; i < row; i++) {
		num0f0 = num0fX = 0;
		for (int j = 0; j < col; j++) {
			if (board[i][j] == '*') {
				num0f0++;
			}
			else if (board[i][j] == '#') {
				num0fX++;
			}
		}
		if (num0f0 == ROW) {
			return '*';
		}
		else if (num0fX == COL) {
			return '#';
		}
	}
	//判断列
	for (int j = 0; j < col; j++) {
		num0f0 = num0fX = 0;
		for (int i = 0; i < row; i++) {
			if (board[i][j] == '*') {
				num0f0++;
			}
			else if (board[i][j] == '#') {
				num0fX++;
			}
		}
		if (num0f0 == row) {
			return '*';
		}
		else if (num0fX == col) {
			return '#';
		}
	}
	//判断正对角线
	num0f0 = num0fX = 0;
	for (int i = 0; i < row; i++) {
			if (board[i][i] == '*') {
				num0f0++;
			}
			else if (board[i][i] == '#') {
				num0fX++;
			}
		}
		if (num0f0 == row) {
			return '*';
		}
		else if (num0fX == col) {
			return '#';
		}
	//检查逆对角线
		num0f0 = num0fX = 0;
		for (int i = 0; i < row; i++) {
			if (board[i][row - i - 1] == '*') {
				num0f0++;
			}
			else if (board[i][row - i - 1] == '#') {
				num0fX++;
			}
		}
		if (num0f0 == row) {
			return '*';
		}
		else if (num0fX == col) {
			return '#';
		}
		//判断是否平均，是否需要继续
		int ret = isfull(board, ROW, COL);
		if (ret == 1) {
			return 'Q';
		}
		else {
			return 'C';//继续游戏
		}
}

int intelligence_play(char board[ROW][COL], int row, int col) {
	//先抢占（2，2）的位置，若已经被占用，则下四个角落之一，以左上角为例（1，1）->对应的数组坐标为(0,0);
	if (board[1][1] == ' ') {
		board[1][1] = '#';
		return 1;
	}
	else if(board[0][0]==' ') {
		board[0][0] = '#';
		return 1;
	}
	//抢占位置后判断是攻还是防
	//cnt用于记录玩家棋子个数，cnt1为电脑，x，y为空格的坐标
	int cnt = 0, cnt1 = 0, x = -1, y = -1, x1 = -1, y1 = -1, flag = 1;
	//先判断自己是否满足胜利条件
	//判断行
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			if (board[i][j] == '#') {
				cnt++;
			}
			if (board[i][j] == ' ') {
				//记录空的位置
				x = i, y = j;
			}
			if (cnt == 2&&x!=-1&&y!=-1) {
				//开始进攻，连成三个棋，计数清零
				cnt = 0;
				board[x][y] = '#';
				x = -1, y = -1;
				return 1;
			}
		}
		//每一行检查结束后需要计数清零
		cnt = 0;
		x = -1, y = -1;
	}
	//是否需要进行堵棋
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			if (board[i][j] == '*') {
				cnt1++;
			}
			if (board[i][j] == ' ') {
				x = i, y = j;
			}
			if (cnt1 == 2 && x != -1 && y != -1) {
				cnt = 0;
				board[x][y] = '#';
				x = -1, y = -1;
				return 1;
			}
		}
		cnt1 = 0;
		x = -1, y = -1;
	}
	//判断列
	for (int j = 0; j < col; j++) {
		for (int i = 0; i < row; i++) {
			if (board[i][j] == '#') {
				cnt++;
			}
			if (board[i][j] == ' ') {
				x = i, y = j;
			}
			if (cnt == 2 && x != -1 && y != -1) {
				cnt = 0;
				board[x][y] = '#';
				x = -1, y = -1;
				return 1;
			}
		}
		cnt = 0;
		x = -1, y = -1;
	}
	for (int j = 0; j < col; j++) {
		for (int i = 0; i < row; i++) {
			if (board[i][j] == '*') {
				cnt++;
			}
			if (board[i][j] == ' ') {
				x = i, y = j;
			}
			if (cnt == 2 && x != -1 && y != -1) {
				cnt = 0;
				board[x][y] = '#';
				x = -1, y = -1;
				return 1;
			}
		}
		cnt = 0;
		x = -1, y = -1;
	}
	//判断逆对角线
	for (int i = 0; i < row; i++) {
		if (board[i][row - i - 1] == '#') {
			cnt++;
		}
		if (board[i][row - i - 1] == ' ') {
			x = i, y = row - i - 1;
		}
		if (cnt == 2 && x != -1 && y != -1) {
			cnt = 0;
			board[x][y] = '#';
			x = -1, y = -1;
			return 1;
		}
	}
	cnt = 0, x = -1, y = -1;
	for (int i = 0; i < row; i++) {
		if (board[i][row - i - 1] == '*') {
			cnt++;
		}
		if (board[i][row - i - 1] == ' ') {
			x = i, y = row - i - 1;
		}
		if (cnt == 2 && x != -1 && y != -1) {
			cnt = 0;
			board[x][y] = '#';
			x = -1, y = -1;
			return 1;
		}
	}
	cnt = 0, x = -1, y = -1;
	//判断逆对角线
	for (int i = 0; i < row; i++) {
		if (board[i][i] == '#') {
			cnt++;
		}
		if (board[i][i] == ' ') {
			x = i, y = row - i - 1;
		}
		if (cnt == 2 && x != -1 && y != -1) {
			cnt = 0;
			board[x][y] = '#';
			x = -1, y = -1;
			return 1;
		}
	}
	cnt = 0, x = -1, y = -1;
	for (int i = 0; i < row; i++) {
		if (board[i][i] == '*') {
			cnt++;
		}
		if (board[i][i] == ' ') {
			x = i, y = row - i - 1;
		}
		if (cnt == 2 && x != -1 && y != -1) {
			cnt = 0;
			board[x][y] = '#';
			x = -1, y = -1;
			return 1;
		}
	}
	cnt = 0, x = -1, y = -1;
	//如果上述条件都不满足，则随机下棋
	cmp_move(board, row, col);
}

test.c文件

#include<stdio.h>
#include"game.h"
void meue() {
	printf("**************************\n");
	printf("**************************\n");
	printf("****1.Play******0.Exit****\n");
	printf("**************************\n");
	printf("**************************\n");
}

void game() {
	char ret = 0;
	char board[ROW][COL];
	//初始化棋盘
	init_board(board, ROW, COL);
	//打印棋盘
	print_board(board, ROW, COL);
	while (1) {
		//玩家下棋
		player_move(board, ROW, COL);
		print_board(board, ROW, COL);
		ret = iswin(board, ROW, COL);
		if (ret != 'C') {
			break;
		}
		//电脑下棋
		//cmp_move(board, ROW, COL);
		intelligence_play(board, ROW, COL);
		printf("\n");
		print_board(board, ROW, COL);
		ret = iswin(board, ROW, COL);
		if (ret != 'C') {
			break;
		}
	}
	if (ret == '#') 
	{
		printf("电脑Win\n");
	}
	else if (ret == '*')
	{
		printf("玩家Win\n");
	}
	else if (ret == 'Q') 
	{
		printf("平局\n");
	}
}

void test() {
	srand(time(NULL));
	int input = 0;
	do {
		meue();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input) {
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，请重新选择\n");
			break;
		}
	} while (input);
}

int main(void) {
	test();
	return 0;
}
Hayaizo
关注
专栏目录
【C语言】三子棋(智能下棋 + 阻拦玩家)
StackFrame
07-28 1979
图文讲解实现三子棋 + 电脑智能下棋 + 堵棋
C语言五子棋评分函数,五子棋评分表算法
weixin_36387422的博客
05-24 1372
最近学了一点QT的绘图，因而乎照着学长的代码绘制了五子棋的小游戏。算法最基础的东西这里就不说了，本身的知识也仅仅比会用多那么一点，下面咱们来讲说这里貌似高大上的人机AI吧。编程评分表算法数组通常状况下棋盘是15*15的。那么应该是572个五元组。而这五元组由黑棋白棋还有空格组成。也就是 3^5 * 572 = 138996; 看着不少吧，实际上是能够分类的。每一个五元组就是一种局势。.net咱们只...
c语言三子棋详解！！! （电脑智能下棋）（附上完整代码）
weixin_61638178的博客
07-31 2347
三字棋详细讲解，附上完整代码
【C语言】三子棋详解（电脑智能下棋算法）
jhao的博客
04-26 1338
C语言的学习阶段，学到数组我们就可以开始弄一些好玩的小游戏来增强我们的学习兴趣，接下来跟着博主一起领略这好玩的小游戏吧
C语言三子棋游戏实现及AI设想、五子棋推广
weixin_54225634的博客
01-24 4731
@Part1： Part 1 三子棋游戏基础实现： 1、操作界面实现： 即实现供用户选择的的菜单：我们定义为menu函数 void menu(){ printf("****************\n"); printf("*****1.play*****\n"); printf("*****0.exit*****\n"); printf("****************\n"); } 我们希望达到的目的是用户可以不断选择，直至按0退出游戏，于是我们在主函数中需要搭建框架
C语言实现三子棋(井字棋)并实现一定程度智能走棋（详解）
最新发布
ikjihjdi的博客
09-20 219
action为玩家输入的数字，每一次输入后需要检测输入的位置上是否有棋子，如果有棋子则令con = 1，使输入循环继续，直到输入正确的位置。本文使用二维数组储存棋盘的状态信息，使用数字小键盘确定下棋位置，实现了棋局胜负的判断，程序能根据一定规则自动走棋，而非其他教程中的随机落子，原题目如下，有兴趣的可以自行翻译阅读。具体代码实现如下，看着很复杂，其实只是复制粘贴修改坐标，你也可以用一个数组来储存这些信息，会更加简洁，这里我懒就不改了。本人也是初学者，本文仅作为一次作业的记录，如有错误请在评论区指出！
五子棋的AI算法C语言
12-27
在C语言中，我们会编写一个函数，递归地探索所有可能的走法，直到达到游戏结束条件（例如，一方形成五子连珠或者棋盘填满）。每到达一个节点，就计算该状态下对AI的评分，然后根据评分选择最佳走法。 为了提高效率...
C语言实现一字棋AI：简易五子棋游戏
这个项目提供了一个基础的AI实现，可以帮助初学者理解如何在C语言中构建一个简单的游戏并实现基本的人工智能决策。然而，为了提升游戏体验和AI的性能，可以考虑优化搜索算法，增加启发式函数以更好地评估棋局，或者...
C++实现基于博弈树的5x5一子棋人机对战
XZY1952911554的博客
11-02 1211
基于C++的简单博弈树算法实现5X5一子棋人机对战，有较为通俗易懂的博弈树原理介绍，希望能帮助大家
详解三子棋（九宫格）游戏
m0_74089804的博客
11-10 7269
对于三子棋的一点小见解
基于qt实现的三连棋（井字棋）游戏（含AI算法）
07-23
基于qt实现的三连棋，包括初始界面，有人机对战和双人对战，人机对战采用min-max搜索来实现，代码量较小，适合新手学习。
井字棋（三连棋）的AI实现，C/C++
10-10
井字棋的AI实现（完整包）无界面 创建TicTacToe类，使你可以编写一个完整的三连棋游戏程序。这个类包含一个作为private数据的3*3的二维整数数组。构造函数应将空棋盘初始化为0。允许两个人玩游戏。无论第一个人移动到哪里，都在指定的棋格中放置1，无论第二个人移动到哪里，都在指定的棋格中放置2。每次移动都必须到达一个空格。在每次移动后，确定是否已分胜负，还是出现了平局。此外，必须让玩家决定谁先走说后走。开发一个人机大战游戏。
人工智能四子棋AI
06-23
是重力四子棋AI，基于alpha-beta剪枝算法，加上迭代加深和估价函数。
C语言实现三子棋小游戏
aixintianshideshouhu的博客
07-18 197
三子棋（C语言） 用了这好几天的时间在闲暇时间写了一个小时候玩的井字棋，或者叫三子棋的小游戏，来娱乐娱乐，虽然是黑白框，并且电脑有点傻之外，一切良好。 首先写之前就要先明白思路，这个棋盘要放到一个二维数组里面这样才能更好的显示出来，并且方便操作，先打印出来棋盘这是必须的，这就是基本的二维数组的打印就好，把棋盘初始化为空格就好了，然后等到走的时候，拿相应的字符来代替就好了；电脑走的话就用随机数来...
C语言 |教你与AI对弈三子棋 从此不再孤单寂寞冷
weixin_44212838的博客
12-06 7183
创建 一个智能Al来陪我们对弈下棋，这篇博客将手把手教会你 自己解决孤独！
C语言自制小游戏：三子棋（井字棋）智能下棋补充
weixin_55547460的博客
02-13 3515
一.前期准备 这篇博客并不包含三子棋大体的内容设计，只有怎样让计算机下的棋更智能一些的讲解如果想看怎样实现三子棋大体程序设计内容还请跳转：https://blog.csdn.net/weixin_55547460/article/details/122648554 在进行下面的内容开始前，需要你首先完善好大体的三子棋程序内容设计 二.程序逻辑结构 这次我们要实现的是让计算机能更加智能的判断应该在哪个坐标下下入棋子，从而实现对玩家的“围追堵截” 在思考这个问题前，我们不妨将计算机替换成自己，想象一下，如果是你
三子棋（C实现）
MrY_Yz的博客
08-09 148
三子棋小项目 写项目就得先新建个项目，并且在源文件添加test.c文件，且由于函数太多，所以将之放在另一个.c文件中，我把它命名为game.c，要在主函数下引用这些函数，就需要同时创建一个名字相同.h的头文件，即game.h。 写在前面： 本来写项目应该是按照逻辑一步一步来写的，但是因为已经写完了，且都展开来讲有点长，故而在这里只将各部分代码粘在下面并加以解释。 头文件 #ifndef...
简单的小游戏，C语言六步实现三字棋
Z1tai的博客
07-29 885
三子棋的简单实现！
三子棋AI+java实现+极大极小算法+alphabeta剪枝
zwn888zwn的博客
03-13 963
极大极小算法的总体思想就是，甲乙双方进行博弈，假设双方都想获得最大收益的情况下，确定甲做出的最优选择。 应用在棋类问题上，就是甲方要考虑自己最大利益时，也要考虑乙方最大利益时的情况。 getValue（）用来判断场面局势，把空格全部填上Mark后 满足3个连一起的个数。 对棋盘进行DFS获取对应深度的最大最小值，最后返回到第0层时，选择最大值的走法。 下面这张图帮助理解，我们从0层开始dfs遍...
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值