C语言实现AI五子棋算法

已于 2023-01-23 22:53:26 修改
阅读量1.7k 收藏 44
点赞数 10
文章标签： 算法 c语言 c++ 人工智能 剪枝
于 2023-01-09 15:44:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gsy_nb/article/details/128615557
版权

文章目录

前言

该文章用于记录在人工智能算法学习中的学习经历，同时也将所遇到的问题与经验分享给大家以作参考。

具体思路与分析有 时间会一一分享。

详细介绍

棋盘、棋子、主菜单绘制

通过一些特殊的符号对于棋盘进行绘制：

//绘制棋盘
void draw_chessboardn(int row, int col, int chessboard[][MAX_COL]) {
	for (int i = 0; i < row; i++) {
		if (i == 0) {
			for (int j = 0; j < col; j++) {
				if (j == 0)
					draw_chessman(chessboard[i][j], "┌ ");
				else if (j == 14)
					draw_chessman(chessboard[i][j], "┐");
				else
					draw_chessman(chessboard[i][j], "┬ ");
			}
			printf("\n");
		}
		else if (i == 14) {
			for (int j = 0; j < col; j++) {
				if (j == 0)
					draw_chessman(chessboard[i][j], "└ ");
				else if (j == 14)
					draw_chessman(chessboard[i][j], "┘ ");
				else
					draw_chessman(chessboard[i][j], "┴ ");
			}
			printf("\n");
		}
		else {
			for (int j = 0; j < col; j++) {
				if (j == 0)
					draw_chessman(chessboard[i][j], "├ ");
				else if (j == 14)
					draw_chessman(chessboard[i][j], "┤");
				else
					draw_chessman(chessboard[i][j], "┼ ");
			}
			printf("\n");
		}
	}
}
//绘制棋子
void draw_chessman(int type, const char* tableline) {
	if (type == WHITE)
		printf("●");
	if (type == BLACK)
		printf("○");
	if (type == BLANK)
		printf("%s", tableline);
}
//绘制主菜单
void draw_menu(void) {
	printf("******************************\n");
	printf("******* 欢迎使用五子棋 *******\n");
	printf("***     研发者：666        ***\n");
	printf("***     请选择对战方式     ***\n");
	printf("*      1.人-人对战           *\n");
	printf("*      2.人-机对战           *\n");
	printf("*      3.退出                *\n");
	printf("******************************\n");
	printf("请选择：");
}

胜负判断

五子棋正常来说是不会将棋盘所占满的，但是不排除这种极端情况，故小写了一个判断棋盘是否满的函数：

//判断棋盘是否已满
int is_full(int chessboard[][MAX_COL], int row, int col) {
	int ret = 1;
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			if (chessboard[i][j] == BLANK) {        //遍历数组，当有一个位置为空，则棋盘不满
				ret = 0;
				break;
			}
		}
	}
	return ret;
}

之后是通过遍历棋盘来判断是否有五子连珠的情况，此处的返回值是棋子的颜色，也就是1，-1或者0。

//判断胜负
int is_win(int chessboard[][MAX_COL], int row, int col) {
	int i, j;
	for (i = 0; i < row; i++) {
		for (j = 0; j < col; j++) {
			if (chessboard[i][j] == BLANK)
				continue;
			if (j < col - 4)
				if (chessboard[i][j] == chessboard[i][j + 1] && chessboard[i][j] == chessboard[i][j + 2]
					&& chessboard[i][j] == chessboard[i][j + 3] && chessboard[i][j] == chessboard[i][j + 4])
					return chessboard[i][j];
			if (i < row - 4)
				if (chessboard[i][j] == chessboard[i + 1][j] && chessboard[i][j] == chessboard[i + 2][j]
					&& chessboard[i][j] == chessboard[i + 3][j] && chessboard[i][j] == chessboard[i + 4][j])
					return chessboard[i][j];
			if (i < row - 4 && j < col - 4)
				if (chessboard[i][j] == chessboard[i + 1][j + 1] && chessboard[i][j] == chessboard[i + 2][j + 2]
					&& chessboard[i][j] == chessboard[i + 3][j + 3] && chessboard[i][j] == chessboard[i + 4][j + 4])
					return chessboard[i][j];
			if (i < row - 4 && j > 4)
				if (chessboard[i][j] == chessboard[i + 1][j - 1] && chessboard[i][j] == chessboard[i + 2][j - 2]
					&& chessboard[i][j] == chessboard[i + 3][j - 3] && chessboard[i][j] == chessboard[i + 4][j - 4])
					return chessboard[i][j];
		}
	}
	return BLANK;
}

人人对战

void person_person(void) {
	int chessboard[MAX_ROW][MAX_COL] = { BLANK };
	int chessboard_c[MAX_ROW][MAX_COL] = { BLANK };
	int i, j;
	int ij[10][4] = { 0 };
	char key;
	draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
	for (int step = 1; step <= MAX_ROW * MAX_COL; step++) {    //黑子先行，然后双方轮流下棋
		if (step % 2 == 1) {                                   //当前步数为单数，黑棋落子。
			printf("请黑棋落子:");
			while (1) {
				scanf("%d %d", &i, &j);
				if (chessboard[i][j] != BLANK) {
					printf("该位置已有棋子，请重新输入\n");        //棋子只能落在空白处
					continue;
				}
				if (i >= MAX_ROW || j >= MAX_COL || i < 0 || j < 0) {
					printf("输入超出棋盘范围，请重新输入\n");      //棋子坐标不可超出棋盘
					continue;
				}
				break;
			}
			chessboard[i][j] = BLACK;
			printf("%d %d\n", ij[0][0], ij[0][1]);
			draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
			if (is_win(chessboard, MAX_ROW, MAX_COL) == BLACK) {
				printf("黑棋胜");
				exit(0);
			}
			//save_chess(chessboard, MAX_ROW, MAX_COL);
		}
		else if (step % 2 == 0) {                            //当前步数为双数，则白棋落子
			printf("请白棋落子:");
			while (1) {
				scanf("%d %d", &i, &j);
				if (chessboard[i][j] != BLANK) {
					printf("该位置已有棋子，请重新输入\n");        //棋子只能落在空白处
					continue;
				}
				if (i >= MAX_ROW || j >= MAX_COL || i < 0 || j < 0) {
					printf("输入超出棋盘范围，请重新输入\n");     //棋子坐标不可超出棋盘
					continue;
				}
				break;
			}
			chessboard[i][j] = WHITE;
			printf("%d %d\n", ij[0][0], ij[0][1]);
			draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
			if (is_win(chessboard, MAX_ROW, MAX_COL) == WHITE) {
				printf("白棋胜");
				exit(0);
			}
		}
	}
	if (is_full(chessboard, MAX_ROW, MAX_COL) == 1)
		printf("棋盘已满");
}

人机对战

在人机对战模块，这里设置的紧紧是人为先手后，机器后手计算最优解，再进行对弈。在函数传参的过程中，利用两个数组，通过复制函数chessboard_copy()来进行后续多层深度的计算，从而不影响原本棋盘状态：

//棋盘复制
void chessboard_copy(int chessboard_c[][MAX_COL],int chessboard[][MAX_COL])
{	
	//复制棋盘，用于试下，不破坏原有棋盘
	for (int i = 0; i < MAX_ROW; i++) {
		for (int j = 0; j < MAX_COL; j++) {
			chessboard_c[i][j] = chessboard[i][j];
		}
	}
}

在传递坐标过程中，用一个数组ij[]来存储当前最优坐标进行传递参数。具体的函数操作如下：

void person_computer_random(void) {
	int chessboard[MAX_ROW][MAX_COL] = { BLANK };
	int chessboard_c[MAX_ROW][MAX_COL] = { BLANK };
	int i, j;
	int ij[4] = { 0 }; //用于传递生成的坐标值
	draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
	for (int step = 1; step <= MAX_ROW * MAX_COL; step++) {
		if (step % 2 == 1) {
			printf("请黑棋落子:");
			while (1) {
				scanf("%d %d", &i, &j);
				if (chessboard[i][j] != BLANK) {
					printf("该位置已有棋子，请重新输入\n");
					continue;
				}
				if (i >= MAX_ROW || j >= MAX_COL || i < 0 || j < 0) {
					printf("输入超出棋盘范围，请重新输入\n");
					continue;
				}
				break;
			}
			chessboard[i][j] = BLACK;
			draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
			if (is_win(chessboard, MAX_ROW, MAX_COL) == BLACK) {
				printf("黑棋胜");
				exit(0);
			}
		}
		else if (step % 2 == 0) {
			deep_search(ij, chessboard,WHITE, 0, i, j);
			printf(" 白棋落子(%d %d)\n", ij[0], ij[1]);
			chessboard[ij[0]][ij[1]] = WHITE;
			draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
			if (is_win(chessboard, MAX_ROW, MAX_COL) == WHITE) {
				printf("白棋胜");
				exit(0);
			}
		}
	}
	if (is_full(chessboard, MAX_ROW, MAX_COL) == 1)
		printf("棋盘已满");
}

评分判断

我们在编写AI对弈相关程序的同时，我们要清楚如何告诉机器，每个点的价值，此处我们通过五子棋的特点，通过活二、活三等棋型，通过棋盘上每个空点位能够实现几种棋型，以及每种棋型相应的得分相加，得到每个点位的评分机制。这段代码是编写AI的基础，具体代码如下：

//评分计算各个点的价值
void calculateScore(int chessboard[][MAX_COL])
{
	int personNum = 0; //玩家方（黑棋）多少个连续的棋子
	int aiNum = 0; //系统方（白棋）连续有多少个连续的棋子
	int emptyNum = 0; // 该方向上空白位的个数

	// 评分数组清零
	pfclear();

	for (int row = 0; row < 15; row++) {
		for (int col = 0; col < 15; col++) {
			//对每个点进行计算
			if (chessboard[row][col]) { continue; } //避开已经下过的点 -1、1都是true

			//控制方向 一共4个正方向：y不变 x+、y- x-、y- x不变、y- x+
			for (int y = -1; y <= 0; y++) {        //Y的范围是-1,0
				for (int x = -1; x <= 1; x++) {    //X的范围是 -1,0,1
					if (y == 0 && x == 0) { continue; }
					if (y == 0 && x != 1) { continue; } //当y=0时，仅允许x=1

					personNum = 0;
					aiNum = 0;
					emptyNum = 0;

					// 假设黑棋在该位置落子，会构成什么棋型
					for (int i = 1; i <= 4; i++) {
						int curRow = row + i * y;
						int curCol = col + i * x;

						if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 1) {
							personNum++;
						}
						else if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 0) {
							emptyNum++;
							break;
						}
						else {
							break;
						}
					}

					// 反向继续计算
					for (int i = 1; i <= 4; i++) {
						int curRow = row - i * y;
						int curCol = col - i * x;

						if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 1) {
							personNum++;
						}
						else if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 0) {
							emptyNum++;
							break;
						}
						else {
							break;
						}
					}

					if (personNum == 1) { //连2
						pf[row][col] += 10;
					}
					else if (personNum == 2) {
						if (emptyNum == 1) { //死3
							pf[row][col] += 30;
						}
						else if (emptyNum == 2) { //活3
							pf[row][col] += 40;
						}
					}
					else if (personNum == 3) {
						if (emptyNum == 1) { //死4
							pf[row][col] = 60;
						}
						else if (emptyNum == 2) { //活4
							pf[row][col] = 5000;
						}
					}
					else if (personNum == 4) { //连5
						pf[row][col] = 20000;
					}

					// 假设白棋在该位置落子，会构成什么棋型
					emptyNum = 0;

					for (int i = 1; i <= 4; i++) {
						int curRow = row + i * y;
						int curCol = col + i * x;

						if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == -1) {
							aiNum++;
						}
						else if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 0) {
							emptyNum++;
							break;
						}
						else {
							break;
						}
					}

					for (int i = 1; i <= 4; i++) {
						int curRow = row - i * y;
						int curCol = col - i * x;

						if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == -1) {
							aiNum++;
						}
						else if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 0) {
							emptyNum++;
							break;
						}
						else {
							break;
						}
					}

					if (aiNum == 0) {
						pf[row][col] += 5;
					}
					else if (aiNum == 1) { //连2
						pf[row][col] += 10;
					}
					else if (aiNum == 2) {
						if (emptyNum == 1) { //死3
							pf[row][col] += 25;
						}
						else if (emptyNum == 2) { //活3
							pf[row][col] += 50;
						}
					}
					else if (aiNum == 3) {
						if (emptyNum == 1) { //死4
							pf[row][col] += 55;
						}
						else if (emptyNum == 2) { //活4
							pf[row][col] += 10000;
						}
					}
					else if (aiNum >= 4) { //连5
						pf[row][col] += 30000;
					}
				}
			}
		}
	}
}

总体代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX_ROW 15  //行
#define MAX_COL 15  //列
#define WHITE -1
#define BLACK 1
#define BLANK 0
 
struct Chess_b_score
{
	int  score;//当前位置的得分
	int	 i, j;//上一级棋子位置
	int  best[32][3];//用于存放同一状态下评分相同且最优的各个点
	int	 s_list[MAX_ROW][MAX_COL];//当前棋盘下各个点得分值
	struct Chess_b_score* c[MAX_ROW][MAX_COL];//下一等级搜索的指针 
};
 
 
void draw_chessboardn(int row, int col, int chessboard[][MAX_COL]);
void draw_chessman(int type, const char* tableline);
int random_create_point(void);
void draw_menu(void);
void person_person(void);
void person_computer_random(void);
int is_full(int chessboard[][MAX_COL], int row, int col);
int is_win(int chessboard[][MAX_COL], int row, int col);
void chessboard_copy(int chessboard_c[][MAX_COL], int chessboard[][MAX_COL]);
void pfclear();
void deep_search(int ij[4], int chessboard[][MAX_COL],int BOW, int n, int row, int col);
int deep666(Chess_b_score* chess,int chessboard[][MAX_COL],int row,int col,int BOW);
void calculateScore(int chessboard[][MAX_COL]);
 
int pf[MAX_ROW][MAX_COL] = {};//全局变量的二维数组，用于存储各点位价值
 
 
int main() {
	int choice;
	draw_menu();
	while (1) {
		scanf("%d", &choice);
		switch (choice) {
		case 1:
			person_person();
			break;
		case 2:
			person_computer_random();
			break;
		case 3:
			exit(0);
			break;
		default:
			printf("输入错误，请重新选择\n");
		}
	}
	return 0;
}
//绘制棋盘
void draw_chessboardn(int row, int col, int chessboard[][MAX_COL]) {
	for (int i = 0; i < row; i++) {
		if (i == 0) {
			for (int j = 0; j < col; j++) {
				if (j == 0)
					draw_chessman(chessboard[i][j], "┌ ");
				else if (j == 14)
					draw_chessman(chessboard[i][j], "┐");
				else
					draw_chessman(chessboard[i][j], "┬ ");
			}
			printf("\n");
		}
		else if (i == 14) {
			for (int j = 0; j < col; j++) {
				if (j == 0)
					draw_chessman(chessboard[i][j], "└ ");
				else if (j == 14)
					draw_chessman(chessboard[i][j], "┘ ");
				else
					draw_chessman(chessboard[i][j], "┴ ");
			}
			printf("\n");
		}
		else {
			for (int j = 0; j < col; j++) {
				if (j == 0)
					draw_chessman(chessboard[i][j], "├ ");
				else if (j == 14)
					draw_chessman(chessboard[i][j], "┤");
				else
					draw_chessman(chessboard[i][j], "┼ ");
			}
			printf("\n");
		}
	}
}
//绘制棋子
void draw_chessman(int type, const char* tableline) {
	if (type == WHITE)
		printf("●");
	if (type == BLACK)
		printf("○");
	if (type == BLANK)
		printf("%s", tableline);
}
//随机算法获取棋子的坐标
int random_create_point(void) {
	int point; 
	srand((unsigned)time(NULL));
	//point = rand() % MAX_ROW;
	point = rand() % 15;
	if (point <4)return -1;
	if (point >= 5 && point <= 9)return 0;
	if (point >= 10 && point <= 15)return 1;
	//printf("%d", point);
}
//绘制主菜单
void draw_menu(void) {
	printf("******************************\n");
	printf("******* 欢迎使用五子棋 *******\n");
	printf("***     研发者：666        ***\n");
	printf("***     请选择对战方式     ***\n");
	printf("*      1.人-人对战           *\n");
	printf("*      2.人-机对战           *\n");
	printf("*      3.退出                *\n");
	printf("******************************\n");
	printf("请选择：");
}
//人人对战
void person_person(void) {
	int chessboard[MAX_ROW][MAX_COL] = { BLANK };
	int chessboard_c[MAX_ROW][MAX_COL] = { BLANK };
	int i, j;
	int ij[10][4] = { 0 };
	char key;
	draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
	for (int step = 1; step <= MAX_ROW * MAX_COL; step++) {    //黑子先行，然后双方轮流下棋
		if (step % 2 == 1) {                                   //当前步数为单数，黑棋落子。
			printf("请黑棋落子:");
			while (1) {
				scanf("%d %d", &i, &j);
				if (chessboard[i][j] != BLANK) {
					printf("该位置已有棋子，请重新输入\n");        //棋子只能落在空白处
					continue;
				}
				if (i >= MAX_ROW || j >= MAX_COL || i < 0 || j < 0) {
					printf("输入超出棋盘范围，请重新输入\n");      //棋子坐标不可超出棋盘
					continue;
				}
				break;
			}
			chessboard[i][j] = BLACK;
			printf("%d %d\n", ij[0][0], ij[0][1]);
			draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
			if (is_win(chessboard, MAX_ROW, MAX_COL) == BLACK) {
				printf("黑棋胜");
				exit(0);
			}
			//save_chess(chessboard, MAX_ROW, MAX_COL);
		}
		else if (step % 2 == 0) {                            //当前步数为双数，则白棋落子
			printf("请白棋落子:");
			while (1) {
				scanf("%d %d", &i, &j);
				if (chessboard[i][j] != BLANK) {
					printf("该位置已有棋子，请重新输入\n");        //棋子只能落在空白处
					continue;
				}
				if (i >= MAX_ROW || j >= MAX_COL || i < 0 || j < 0) {
					printf("输入超出棋盘范围，请重新输入\n");     //棋子坐标不可超出棋盘
					continue;
				}
				break;
			}
			chessboard[i][j] = WHITE;
			printf("%d %d\n", ij[0][0], ij[0][1]);
			draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
			if (is_win(chessboard, MAX_ROW, MAX_COL) == WHITE) {
				printf("白棋胜");
				exit(0);
			}
			//save_chess(chessboard, MAX_ROW, MAX_COL);
		}
	}
	if (is_full(chessboard, MAX_ROW, MAX_COL) == 1)
		printf("棋盘已满");
}
//判断棋盘是否已满
int is_full(int chessboard[][MAX_COL], int row, int col) {
	int ret = 1;
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			if (chessboard[i][j] == BLANK) {        //遍历数组，当有一个位置为空，则棋盘不满
				ret = 0;
				break;
			}
		}
	}
	return ret;
}
//判断胜负
int is_win(int chessboard[][MAX_COL], int row, int col) {
	int i, j;
	for (i = 0; i < row; i++) {
		for (j = 0; j < col; j++) {
			if (chessboard[i][j] == BLANK)
				continue;
			if (j < col - 4)
				if (chessboard[i][j] == chessboard[i][j + 1] && chessboard[i][j] == chessboard[i][j + 2]
					&& chessboard[i][j] == chessboard[i][j + 3] && chessboard[i][j] == chessboard[i][j + 4])
					return chessboard[i][j];
			if (i < row - 4)
				if (chessboard[i][j] == chessboard[i + 1][j] && chessboard[i][j] == chessboard[i + 2][j]
					&& chessboard[i][j] == chessboard[i + 3][j] && chessboard[i][j] == chessboard[i + 4][j])
					return chessboard[i][j];
			if (i < row - 4 && j < col - 4)
				if (chessboard[i][j] == chessboard[i + 1][j + 1] && chessboard[i][j] == chessboard[i + 2][j + 2]
					&& chessboard[i][j] == chessboard[i + 3][j + 3] && chessboard[i][j] == chessboard[i + 4][j + 4])
					return chessboard[i][j];
			if (i < row - 4 && j > 4)
				if (chessboard[i][j] == chessboard[i + 1][j - 1] && chessboard[i][j] == chessboard[i + 2][j - 2]
					&& chessboard[i][j] == chessboard[i + 3][j - 3] && chessboard[i][j] == chessboard[i + 4][j - 4])
					return chessboard[i][j];
		}
	}
	return BLANK;
}
//人机对战
void person_computer_random(void) {
	int chessboard[MAX_ROW][MAX_COL] = { BLANK };
	int chessboard_c[MAX_ROW][MAX_COL] = { BLANK };
	int i, j;
	int ij[4] = { 0 }; //用于传递生成的坐标值
	draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
	for (int step = 1; step <= MAX_ROW * MAX_COL; step++) {
		if (step % 2 == 1) {
			printf("请黑棋落子:");
			while (1) {
				scanf("%d %d", &i, &j);
				if (chessboard[i][j] != BLANK) {
					printf("该位置已有棋子，请重新输入\n");
					continue;
				}
				if (i >= MAX_ROW || j >= MAX_COL || i < 0 || j < 0) {
					printf("输入超出棋盘范围，请重新输入\n");
					continue;
				}
				break;
			}
			chessboard[i][j] = BLACK;
			draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
			if (is_win(chessboard, MAX_ROW, MAX_COL) == BLACK) {
				printf("黑棋胜");
				exit(0);
			}
		}
		else if (step % 2 == 0) {
			deep_search(ij, chessboard,WHITE, 0, i, j);
			printf(" 白棋落子(%d %d)\n", ij[0], ij[1]);
			chessboard[ij[0]][ij[1]] = WHITE;
			draw_chessboardn(MAX_ROW, MAX_COL, chessboard);
			if (is_win(chessboard, MAX_ROW, MAX_COL) == WHITE) {
				printf("白棋胜");
				exit(0);
			}
		}
	}
	if (is_full(chessboard, MAX_ROW, MAX_COL) == 1)
		printf("棋盘已满");
}
//棋盘复制
void chessboard_copy(int chessboard_c[][MAX_COL],int chessboard[][MAX_COL])
{	
	//复制棋盘，用于试下，不破坏原有棋盘
	for (int i = 0; i < MAX_ROW; i++) {
		for (int j = 0; j < MAX_COL; j++) {
			chessboard_c[i][j] = chessboard[i][j];
		}
	}
}
//全局变量价值表初始化
void pfclear()
{
	for (int i = 0; i < MAX_ROW; i++) {
		for (int j = 0; j < MAX_COL; j++) {
			pf[i][j] = 0;
		}
	}
}
//全局搜索
void deep_search(int ij[4],int chessboard[][MAX_COL],int BOW,int n,int row,int col)
{
	Chess_b_score *chess0;
	int score_max=0, score=0,score_min=10000000,score_2=0;
	int m=0;
	int chessboard_c[MAX_ROW][MAX_COL] = { BLANK };
	chess0 = (struct Chess_b_score*)malloc(sizeof(struct Chess_b_score));
	chessboard_copy(chessboard_c, chessboard);
	calculateScore(chessboard_c);
	//由上一步为中心向四周发散搜素
	for (int i = row; i < MAX_ROW; i++) {
		for (int j = col; j < MAX_COL; j++) {
			if (chessboard_c[i][j] == BLANK)
			{
				score = pf[i][j];
				chess0->s_list[i][j] = score;
				if (score > score_max) {
					score_max = score;
				}
			}
			else {
				chess0->s_list[i][j] =chessboard_c[i][j];
			}
		}
	}  //右上
	for (int i = row; i < MAX_ROW; i++) {
		for (int j = col; j >= 0; j--) {
			if (chessboard_c[i][j] == BLANK)
			{
				score = pf[i][j];
				chess0->s_list[i][j] = score;
				if (score > score_max) {
					score_max = score;
				}
			}
			else {
				chess0->s_list[i][j] = chessboard_c[i][j];;
			}
		}
	}
	for (int i = row; i >= 0; i--) {
		for (int j = col; j >= 0; j--) {
			if (chessboard_c[i][j] == BLANK)
			{
				score = pf[i][j];
				chess0->s_list[i][j] = score;
				if (score > score_max) {
					score_max = score;
				}
			}
			else {
				chess0->s_list[i][j] = chessboard_c[i][j];;
			}
		}
	}
	for (int i = row; i >= 0; i--) {
		for (int j = col; j < MAX_COL; j++) {
			if (chessboard_c[i][j] == BLANK)
			{
				score = pf[i][j];
				chess0->s_list[i][j] = score;
				if (score > score_max) {
					score_max = score;
				}
			}
			else {
				chess0->s_list[i][j] = chessboard_c[i][j];
			}
		}
	}
	printf("\n");
	//将搜索评价表的最大值放入到该棋盘结构体中的best数组中，用于后面的深层搜索
	for (int i = 0; i < MAX_ROW; i++) {
		for (int j = 0; j < MAX_COL; j++) {
			if (pf[i][j] == score_max) {
				chess0->best[m][0] = i;
				chess0->best[m][1] = j;
				chess0->best[m][2] = score_max;
				m++;
			}
		}
	}
	m--;
	//判断二层搜索结果，将第一层相等的点位对第二层进行搜索，然后取第二层的min值。
	while (m!=-1) {
		score_2=deep666(chess0,chessboard_c,chess0->best[m][0], chess0->best[m][1],WHITE);
		if (score_2 < score_min) {
			score_min = score_2;
			chess0->i = chess0->best[m][0];
			chess0->j = chess0->best[m][1];
		}
		m--;
	}
	ij[0] = chess0->i;
	ij[1] = chess0->j;
}
//二层搜索
int deep666(Chess_b_score* chess,int chessboard[][MAX_COL],int row,int col,int BOW)
{
	int m = 0;
	Chess_b_score* p;
	int chessboard_c[MAX_ROW][MAX_COL] = { BLANK };
	p= (struct Chess_b_score*)malloc(sizeof(struct Chess_b_score));
	chess->c[row][col]= (struct Chess_b_score*)malloc(sizeof(struct Chess_b_score));
	chessboard_copy(chessboard_c, chessboard);
	chessboard_c[row][col] = BOW;
	calculateScore(chessboard_c);
	p = chess->c[row][col];
	chess->c[row][col]->score = 0;
	for (int i = 0; i < MAX_ROW; i++) {
		for (int j = 0; j < MAX_COL; j++) {
			p->s_list[i][j] = pf[i][j];
			if (pf[i][j] > p->score) {
				p->score = pf[i][j];
			}
		}
	}
	for (int i = 0; i < MAX_ROW; i++) {
		for (int j = 0; j < MAX_COL; j++) {
			if (pf[i][j] == p->score) {
				p->best[m][0] = i;
				p->best[m][1] = j;
				p->best[m][2] = p->score;
				m++;
			}
		}
	}
	return p->score;
}
//评分计算各个点的价值
void calculateScore(int chessboard[][MAX_COL])
{
	int personNum = 0; //玩家方（黑棋）多少个连续的棋子
	int aiNum = 0; //系统方（白棋）连续有多少个连续的棋子
	int emptyNum = 0; // 该方向上空白位的个数
 
	// 评分数组清零
	pfclear();
 
	for (int row = 0; row < 15; row++) {
		for (int col = 0; col < 15; col++) {
			//对每个点进行计算
			if (chessboard[row][col]) { continue; } //避开已经下过的点 -1、1都是true
 
			//控制方向 一共4个正方向：y不变 x+、y- x-、y- x不变、y- x+
			for (int y = -1; y <= 0; y++) {        //Y的范围是-1,0
				for (int x = -1; x <= 1; x++) {    //X的范围是 -1,0,1
					if (y == 0 && x == 0) { continue; }
					if (y == 0 && x != 1) { continue; } //当y=0时，仅允许x=1
 
					personNum = 0;
					aiNum = 0;
					emptyNum = 0;
 
					// 假设黑棋在该位置落子，会构成什么棋型
					for (int i = 1; i <= 4; i++) {
						int curRow = row + i * y;
						int curCol = col + i * x;
 
						if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 1) {
							personNum++;
						}
						else if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 0) {
							emptyNum++;
							break;
						}
						else {
							break;
						}
					}
 
					// 反向继续计算
					for (int i = 1; i <= 4; i++) {
						int curRow = row - i * y;
						int curCol = col - i * x;
 
						if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 1) {
							personNum++;
						}
						else if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 0) {
							emptyNum++;
							break;
						}
						else {
							break;
						}
					}
 
					if (personNum == 1) { //连2
						pf[row][col] += 10;
					}
					else if (personNum == 2) {
						if (emptyNum == 1) { //死3
							pf[row][col] += 30;
						}
						else if (emptyNum == 2) { //活3
							pf[row][col] += 40;
						}
					}
					else if (personNum == 3) {
						if (emptyNum == 1) { //死4
							pf[row][col] = 60;
						}
						else if (emptyNum == 2) { //活4
							pf[row][col] = 5000;
						}
					}
					else if (personNum == 4) { //连5
						pf[row][col] = 20000;
					}
 
					// 假设白棋在该位置落子，会构成什么棋型
					emptyNum = 0;
 
					for (int i = 1; i <= 4; i++) {
						int curRow = row + i * y;
						int curCol = col + i * x;
 
						if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == -1) {
							aiNum++;
						}
						else if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 0) {
							emptyNum++;
							break;
						}
						else {
							break;
						}
					}
 
					for (int i = 1; i <= 4; i++) {
						int curRow = row - i * y;
						int curCol = col - i * x;
 
						if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == -1) {
							aiNum++;
						}
						else if (curRow >= 0 && curRow < 15 &&
							curCol >= 0 && curCol < 15 &&
							chessboard[curRow][curCol] == 0) {
							emptyNum++;
							break;
						}
						else {
							break;
						}
					}
 
					if (aiNum == 0) {
						pf[row][col] += 5;
					}
					else if (aiNum == 1) { //连2
						pf[row][col] += 10;
					}
					else if (aiNum == 2) {
						if (emptyNum == 1) { //死3
							pf[row][col] += 25;
						}
						else if (emptyNum == 2) { //活3
							pf[row][col] += 50;
						}
					}
					else if (aiNum == 3) {
						if (emptyNum == 1) { //死4
							pf[row][col] += 55;
						}
						else if (emptyNum == 2) { //活4
							pf[row][col] += 10000;
						}
					}
					else if (aiNum >= 4) { //连5
						pf[row][col] += 30000;
					}
				}
			}
		}
	}
}

总结

呜呼乌拉拉
关注
  • 10
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
五子棋 AI（一）
大田二十
03-26 4287
五子棋 AI（一）
c语言 五子棋 ai
11-08
五子棋ai，人工智能，属于简单电脑，终端下棋，下棋时，输入相应坐标 电脑：＊ ,自己:#
五子棋的AI算法C语言
12-27
五子棋的AI算法C语言
C语言五子棋算法
cosio的专栏
09-27 3255
作者：unknown 更新时间： 2005-03-13    任何一种棋类游戏其关键是对当前棋局是否有正确的评分,评分越准确则电脑的AI越高。五子棋游戏也是如此，但在打分之前，我们先扫描整个棋盘，把每个空位从八个方向上的棋型填入数组gStyle(2, 15, 15, 8, 2)，其中第一个下标为1时表示黑棋，为2时表示白棋，第二和第三个下标表示(x,y)，第四个下标表示8个方向，最后一个下标为1时
探索智能对弈：Gomoku - 五子棋AI实战平台
最新发布
gitblog_00044的博客
04-23 557
探索智能对弈：Gomoku - 五子棋AI实战平台 项目地址:https://gitcode.com/cw1997/Gomoku 项目简介 Gomoku 是一个由 cw1997 开发的开源五子棋游戏项目，它不仅是一个娱乐工具，更是一个研究人工智能对弈策略的理想平台。该项目基于Python编写，采用Minimax算法与Alpha-Beta剪枝，让你能在享受五子棋的乐趣的同时，了解和学习AI的基本工作...
【Unity】五子棋AI博弈算法实讲
Leibnezz的博客
02-21 1857
系统的，分层次的讲解了五子棋AI博弈算法。
五子棋AI算法简易实现（三）
ZTao-z的博客
03-06 4106
电脑AI篇 （1）评估函数 对当前局面的评估函数在实现五子棋的AI算法的过程中是十分重要的，它能够帮助电脑很好的进行对当前棋盘中双方优势的评估，以便于电脑采取更优的下棋策略，是后面的minimax算法和AlphaBeta剪枝算法中作为一个节点权值的重要评估标准。 当前版本下，我将评估函数分成了五个部分：评估标准、棋盘的切分、评估函数针对各种棋型的定义、对棋盘上每一个位置的点估值、统计...
【c语言五子棋】简单ai算法（理论）
dancehole的博客
01-14 1991
博弈树 | | 极大极小值搜索 | | α ─ β 剪枝（Alpha-Beta剪枝）
基于C语言实现五子棋博弈算法源码(阿尔法贝塔剪枝法和贪心算法).zip
12-29
1.项目代码均经过功能验证ok，确保稳定可靠运行。欢迎下载体验！下载完使用问题请私信沟通。 2.主要针对各个计算机相关专业，包括计算机科学、信息...基于C语言实现五子棋博弈算法源码(阿尔法贝塔剪枝法和贪心算法).zip
C语言五子棋代码AI或者人机
01-13
五子棋，纯C实现。支持人机对战、人人对战。代码分块，可单独使用某个模块。
五子棋代码，C语言满分课设，实现了人机对弈，还带有BGM
03-24
C语言满分课设，实现了人机对弈，还带有BGM
AI智能五子棋代码
07-30
这是一份AI智能五子棋代码，主要是用HTML,JS和CSS编写的，适用于学习JS或者前端的同学们，不要小看这份代码哦，一不小心你会输给电脑的。
AI智能五子棋Python代码
08-01
这个代码是智能五子棋代码，使用python实现，可视化界面，有基于规则的算法和基于神经网络的算法，可以实现一定水准的五子棋棋力。
五子棋源代码（带ai）
04-21
用mfc编的图形界面五子棋，带ai，上传的是VC6工程的源文件，大家可以参考一下
五子棋AI源码
12-21
基于VC的五子棋人机对弈程序，具体实现可参考http://blog.csdn.net/ilsunny/article/details/17116155
智能对战五子棋AI（python）
04-11
智能对战五子棋AI（python）
五子棋C语言（支持人人对战、人机对战，含禁手）
01-27
五子棋AI由极大极小搜索+alpha-beta剪枝实现。含禁手，但是禁手写的不完善。 只是一个大二学生的作业，还有很多待提升的地方。 仅供参考，欢迎交流。
c语言五子棋贪心算法,五子棋人机对弈代码——之贪心算法
weixin_30873127的博客
05-23 969
/*五子棋游戏的游戏模块的实现zwdnet2010年3月zwdnet@163.com*/#include #include using namespace std;int X,Y;int colour;int N=15; //棋盘大小typedef struct node{int x;int y;}POINT;vector > board;//五子棋游戏类，进行游戏相关的操作class Ga...
运用博弈树实现五子棋人机对战
qq_52771580的博客
07-22 2096
一、构建博弈树 当轮到机器落子时，程序调用主函数,树的深度n=0，代表以当前局势为整个博弈树根结点，深度为0；同时在棋盘上没有落子的地方依次调用creatNode函数，在creatNode函数内部，n首先加一，n代表当前节点的深度，创建孩子结点（即当n为奇数时在棋盘上没有棋子的所有地方分别假设机器下一个子，当n为偶数时在棋盘上没有棋子的所有地方分别假设玩家下一个子，每个地方假设下子后的局势代表一个孩子节点）。对所有孩子结点依次进行判断，若孩子节点代表的棋局没分出胜负且深度没有达到指定深度，...
C语言五子棋高级ai算法
05-31
五子棋是一种比较复杂的游戏，需要设计高效的AI算法来实现自动下棋。以下是一些常用的C语言五子棋AI算法： ...以上是一些常用的C语言五子棋AI算法，开发者可以根据自己的需求选择合适的算法来实现自动下棋功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值