C语言AI五子棋（大一新生）

已于 2024-01-04 18:18:28 修改
阅读量6k 收藏 141
点赞数 29
文章标签： 算法 c++ c语言 游戏程序
于 2022-08-04 20:37:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63670969/article/details/125832296
版权

该游戏为C语言所编写的基于easy-x图形库的程序，有基本C语言知识即可理解。该游戏用极大极小搜索实现AI执棋，棋力与一般人相当。运行需提前安装好easy-x图形库，文末有完整源码。

代码运行结果

在这里插入图片描述

主体实现思想

//开局
void begin(struct point p[25][25])
{
	board();   //棋盘图形背景加载
	while (1)
	{
		if (/*按下鼠标左键*/)
		{
			if (/*鼠标坐标在悔棋区域*/)
			{
				//悔棋
			}
			if (/*鼠标坐标在重开区域*/)
			{
				//重开
			}
			if (/*鼠标坐标在投降区域*/)
			{
				//投降
			}
			if (/*鼠标坐标在退出区域*/)
			{
				//退出
			}
			if (/*鼠标坐标在棋盘上*/)    //玩家执棋
			{
				fillcircle(m.x, m.y, 20);   //在该位置画红圆
				p[i][j].state = -1;    //修改该位置的状态

			/*判断胜负*/

			robot(p);   //电脑执棋，在某位置画白圆

			/*判断胜负*/
			}
		}
	}
}

电脑AI执棋方法

首先，我们先来认识一下极大极小搜索。在该算法中，我们需要定义一个评估函数，该评估函数能够给出当前局面对于电脑的优势程度，并以具体数字呈现，数字越大该局面对电脑越有利，越小则对玩家越有利。如下图所示，假设当前局面为p1并且轮到电脑方下棋，p3为p1走两步后产生的所有局面的优势分。p1时轮到电脑方下棋，电脑希望能从p2中找到优势分最大的那一步，但是，此时p2的分数又是未知的，因此我们需要先确定p2的分数。p2轮到玩家下棋，他肯定是希望从p3中选择分数最小的那一步，当然p3的分数是由评估函数确定出来的。我们可以以此类推，确定要搜索的深度，最底层的分数由评估函数得出，然后依次往上推。
p2为玩家执棋，从p3中选最小值，分别为7，5，4。
p1为电脑执棋，从p2中选最大值，为7。
在这里插入图片描述
极大极小搜索伪代码如下：

//电脑执棋
int robot(struct point p[25][25])
{
	for (i = MIN; i < MAX; i++)       //寻找最佳落子点
	{
		for (j = MIN; j < MAX; j++)
		{
			if (p[i][j].state == 0)      //该点为空
			{
				p[i][j].state = 1;    //假设电脑下在这里
				p[i][j].n_value = deduction(p, 1, 1, A, B);    //获取下一步分数
				p[i][j].state = 0;    //撤回
				if (p[i][j].n_value > v)    //v初始值为无穷小
				{
					v = p[i][j].n_value;    //找最大值
					x = i;
					y = j;     //获取坐标
				}
			}
		}
	}
	/*执行坐标x,y */
	return 0;
}

//递归推演 
double deduction(struct point p[25][25], int sex, int depth, long double a, long double b)
{
	if (depth == 0 || end(p) != 0)   //达到深度或棋局结束
	{
		return assess(p);       //递归出口，返回评估函数的分数
	}

	else if (sex % 2 == 1)     //玩家回合
	{
		for (m = MIN; m < MAX; m++)
		{
			for (n = MIN; n < MAX; n++)
			{
				if (p[m][n].state == 0)   //为空
				{
					p[m][n].state = -1;    //假设棋下在这个地方
					va = deduction(p, sex + 1, depth - 1, a, b);   //获取下一步分数
					p[m][n].state = 0;      //撤回
					if (va < b)    //找最小值
					{
						b = va;
					}
				}
			}
		}
		return b; //返回分数
	}
	else if (sex % 2 == 0)     //电脑回合
	{
		for (m = MIN; m < MAX; m++)
		{
			for (n = MIN; n < MAX; n++)
			{
				if (p[m][n].state == 0 && t != 0)     //为空
				{
					p[m][n].state = 1;     //棋下在这个地方
					va = deduction(p, sex + 1, depth - 1, a, b);    //获取下一步分数
					p[m][n].state = 0;     //撤回
					if (va > a)    //找最大值
					{
						a = va;
					}
				}
			}
		}
		return a;//返回分数
	}
}

至此，电脑已经可以找出“最好”的棋位了，但是由于博弈树呈指数增长，计算量过大，因此需要对算法进行优化，以加深搜索深度。我们可进行对博弈树α-β剪枝。看下图，假设我们已经在p21从p31中选了最小值7，在p22求分数时我们又在p32中发现了5，这时，我们可以对p22进行剪枝，即跳出p22的搜索循环。因为我们在p32中发现了5，因此p22的分数肯定不大于5，又因为p21的分数为7>5,而p1是要从p2中找最大值的，因此肯定不会是p22中的分数，因此可以对p22进行剪枝。找到p33中的4时也是一样，因为p21的值7>4,所以发现p33的4时，可对p23进行剪枝跳出p23的搜索循环.
在这里插入图片描述我们还可以对一些不必要的点进行剪枝，比如那些周围没有一个子的点，算法很简单，对位置周围进行搜索，全为空时剪掉即可。加了剪枝的代码如下：

//电脑执棋
int robot(struct point p[25][25])
{
	int i, j, x = 0, y = 0,m, n, t = 0;
	long double v = -999999999999999999;    //10^18
	for (i = MIN; i < MAX; i++)        //寻找最佳落子点
	{
		for (j = MIN; j < MAX; j++)
		{
			if (p[i][j].state == 0 )      //为空
			{
				t = 0;
				for (m = -1; m < 2; m++) {
					for (n = -1; n < 2; n++) {
						if (p[i + m][j + n].state != 0) {
							t++;     //偏僻点剪枝
						}
					}
				}
				if (t != 0)   //不偏僻
				{   
					p[i][j].state = 1;    //假设电脑下在这里
					p[i][j].n_value = deduction(p, 1, 1, A, B);
					p[i][j].state = 0;    //撤回
					if (p[i][j].n_value > v)
					{
						v = p[i][j].n_value;    //找最大值
						x = i;
						y = j;     //获取坐标
					}
				}
			}
		}
	}
	setfillcolor(WHITE); //填充颜色
	fillcircle((x + 1 - MIN) * 50, (y + 1 - MIN) * 50, 20);//画圆，下这一步
	xx = x;
	yy = y;    //为悔棋坐标做记录
	p[x][y].state = 1;     //修改状态
	return 0;
}

//递归推演 
double deduction(struct point p[25][25], int sex, int depth, long double a, long double b)
{
	int m, n,i, j, t = 0,br=0;
	long double va = 0;
	if (depth == 0 || end(p) != 0)   //达到深度或棋局结束
	{
		return assess(p);       //递归出口，返回分数
	}
	else if (sex % 2 == 1)     //玩家回合
	{
		for (m = MIN; m < MAX; m++)
		{
			if (br == 1) {   //b剪枝
				break;
			}
			for (n = MIN; n < MAX; n++)
			{
				if (p[m][n].state == 0 )   //为空
				{
					if (num < 40) {
						t = 0;
						for (i = -1; i < 2; i++) {
							for (j = -1; j < 2; j++) {
								if (p[i + m][j + n].state != 0) {
									t++;     //偏僻点剪枝
								}
							}
						}
					}
					else {
						t = 1;
					}
					if (t == 0)   //偏僻
					{
						va = B;
					}
					else {
						p[m][n].state = -1;    //棋下在这个地方
						va = deduction(p, sex + 1, depth - 1, a, b);
						p[m][n].state = 0;      //撤回
					}
					if (va < b)    //找最小值
					{
						b = va;
					}
					if (b < a)   
					{
						break;    //b剪枝
						br = 1;
					}
				}
			}
		}
		return b; //返回分数
	}
	else if (sex % 2 == 0)     //电脑回合
	{
		for (m = MIN; m < MAX; m++)
		{
			if (br == 1) {   //a剪枝
				break;
			}
			for (n = MIN; n < MAX; n++)
			{
				if (p[m][n].state == 0 )     //为空
				{
					if (num < 40) {
						t = 0;
						for (i = -1; i < 2; i++) {
							for (j = -1; j < 2; j++) {
								if (p[i + m][j + n].state != 0) {
									t++;     //偏僻点剪枝
								}
							}
						}
					}
					else {
						t = 1;
					}
					if (t == 0)   //偏僻
					{
						va = A;
					}
					else {
						p[m][n].state = 1;     //棋下在这个地方
						va = deduction(p, sex + 1, depth - 1, a, b);
						p[m][n].state = 0;     //撤回
					}
					if (va > a)    //找最大值
					{
						a = va;
					}
					if (b < a)
					{
						break;    //a剪枝
						br = 1;
					}
				}
			}
		}
		return a;//返回分数
	}
	return 0;
}

想要让电脑具有更高的棋力，还需要有一个好的评估函数。我们可以用if语句对不同的情况进行赋分。笔者所用的是对每个点进行赋分，空点价值为0，红子和白子取相反数，每个点有8个方向的延伸价值，每个方向为5分，被敌方或边界挡住即为0；每两个相同的子连在一起则他们的分数乘一定的倍数，还有距离中心的优势分等等，详见完整代码。此仅做参考，读者可自行设计出更加科学、计算量更少的评估函数。

完整代码以及详细注释

#define _CRT_SECURE_NO_WARNINGS
#include<graphics.h>
#include<Windows.h>
#include<conio.h>
#include <math.h>
#include<time.h>
#include<mmsystem.h>
#include<easyx.h>
#include<iostream>
#include<stdlib.h>

using namespace std;
#define E 10         // E=防守/攻击
#define V 10         //位置初始分以及倍率
#define MIN 5
#define MAX 20
long double A = -999999999999999999;
long double B = 999999999999999999;
int ii = 0, jj = 0, xx = 0, yy = 0;    //记录上一步棋位置
int num = 0;    //对弈次数

void board();	//绘画棋盘
void regret(struct point p[25][25]);		//悔棋
void begin(struct point p[25][25]);  	//开始
int robot(struct point p[25][25]);		//电脑执棋
void over(int x);		//结束界面	
void p_assess(struct point p[25][25]);     //某点价值分评定
double assess(struct point p[25][25]);     //局面优势评估
double deduction(struct point p[25][25], int sex, int depth, long double a, long double b, int x, int y);//递归推演 
int end(struct point p[25][25], int x, int y, int sex);     //胜负代数返回
void initialize(struct point p[25][25]);    //棋盘初始化
void execute(struct point p[25][25], int x, int y);    //下棋

struct point {
	int state;          //位置的状态    玩家-1,   空位置0,   电脑1
	long double value;        //该点价值分
	long double n_value;        //下一步棋下这点时棋盘的总优势分
	int odds;      //是否为必胜点
};

//初始化
void initialize(struct point p[25][25])
{
	int i, j;
	num = 0;
	for (i = 0; i < 25; i++)
	{
		for (j = 0; j < 25; j++)
		{
			p[i][j].state = 0;   //为空
			p[i][j].value = 0;
			p[i][j].n_value = 0;
		}
	}
}
//胜负代数返回
int end(struct point p[25][25], int x, int y, int sex)
{
	int i, s;
	for (s = 0, i = -4; i < 5; i++) {
		if (p[x][y + i].state == sex) {   //左右
			s++;
		}
		else {
			s = 0;
		}
		if (s > 4) {
			return sex;
		}
	}
	for (s = 0, i = -4; i < 5; i++) {    //上下
		if (p[x + i][y].state == sex) {
			s++;
		}
		else {
			s = 0;
		}
		if (s > 4) {
			return sex;
		}
	}
	for (s = 0, i = -4; i < 5; i++) {
		if (p[x - i][y - i].state == sex) {     //斜下
			s++;
		}
		else {
			s = 0;
		}
		if (s > 4) {
			return sex;
		}
	}
	for (s = 0, i = -4; i < 5; i++) {       //斜上
		if (p[x + i][y - i].state == sex) {
			s++;
		}
		else {
			s = 0;
		}
		if (s > 4) {
			return sex;
		}
	}
	return 0;
}
//绘画棋盘
void board()
{
	initgraph(950, 800);//初始化绘图窗口
	setbkcolor(BLACK);//绘图背景色
	cleardevice();//使用当前背景色清空上一个绘图
	setlinecolor(WHITE);//设置当前设备画线颜色
	for (int i = 50; i <= 750; i += 50)//画棋盘
	{
		line(i, 50, i, 750);
		line(50, i, 750, i);
	}

	setlinecolor(RED);//设置当前设备画线颜色
	settextstyle(40, 0, "宋体");
	outtextxy(800, 200, "悔 棋");
	outtextxy(800, 300, "重 来");
	outtextxy(800, 400, "后 手");
	outtextxy(800, 500, "退 出");
	settextcolor(RED); 
	settextstyle(15, 0, "宋体");
	outtextxy(2, 2, "作者：杨秀杰");
}
//下棋
void execute(struct point p[25][25], int x, int y) 
{
	setfillcolor(WHITE); //填充颜色
	fillcircle((x + 1 - MIN) * 50, (y + 1 - MIN) * 50, 20);//画圆，下这一步
	xx = x;
	yy = y;    //为悔棋坐标做记录
	p[x][y].state = 1;     //修改状态
}
//悔棋
void regret(struct point p[25][25])
{
	board();
	setrop2(R2_COPYPEN);  //设置绘制颜色
	setcolor(WHITE);
	p[ii][jj].state = 0;  //将上一步棋清空
	p[xx][yy].state = 0;
	for (int i = MIN; i < MAX; i++) {        //重新绘制棋盘
		for (int j = MIN; j < MAX; j++) {
			if (p[i][j].state == -1) {
				setfillcolor(RED);
				fillcircle((i + 1-MIN) * 50, (j + 1-MIN) * 50, 20);
			}
			if (p[i][j].state == 1) {
				setfillcolor(WHITE);
				fillcircle((i + 1-MIN) * 50, (j + 1-MIN) * 50, 20);
			}
		}
	}
}
//开局
void begin(struct point p[25][25])
{
	MOUSEMSG m; // 定义鼠标消息
	int  x, y, i, j;     
	board();   //图形背景加载
	setlinecolor(WHITE); //设置当前设备画线颜色

	while (1)
	{
		m = GetMouseMsg();//获取鼠标信息
		x = m.x % 50;
		y = m.y % 50;
		setrop2(R2_COPYPEN);	//二元光栅操作码：R2_COPYPEN当前颜色
		if (m.uMsg == WM_LBUTTONDOWN)		//按下鼠标左键
		{
			if (m.x <= 900 && m.y < 250 && m.x >= 800 && m.y > 200)  //悔棋
			{
				regret(p);//悔棋
				continue;
			}
			if (m.x <= 900 && m.y < 350 && m.x >= 800 && m.y > 300)	//重开
			{
				initialize(p);   //初始化
				begin(p);
			}
			if (m.x <= 900 && m.y < 450 && m.x >= 800 && m.y > 400)  //后手
			{
				if (num < 1)
				{
					robot(p);   //电脑执棋
					num++;
				}
			}
			if (m.x <= 900 && m.y < 550 && m.x >= 800 && m.y > 500)  //退出
			{
				closegraph(); // 关闭绘图窗口
				exit(0);    //强制退出
			}

			if (x >= 25)     //玩家执棋
				m.x = m.x - x + 50;
			else
				m.x = m.x - x;
			if (y >= 25)
				m.y = m.y - y + 50;
			else
				m.y = m.y - y;
			i = m.x / 50 - 1+ MIN; //坐标转换
			j = m.y / 50 - 1+ MIN;
			if (i < 20 && j < 20)
			{
				if (p[i][j].state==-1)
					break;
				if (m.x <= 750 && m.y <= 750 && m.x >= 50 && m.y >= 50)
				{
					setfillcolor(RED);//设置当前设备画线颜色
					fillcircle(m.x, m.y, 20); //在该位置画圆下棋
					ii = i;    //为悔棋坐标做记录
					jj = j;
					p[i][j].state = -1;//修改该位置的状态
				}
				if (end(p,ii,jj,-1) != 0)//结束判断
				{
					Sleep(1000);
					over(end(p, ii, jj, -1));//结束界面
				}
				robot(p);   //电脑执棋
				if (end(p, xx, yy, 1) != 0)//结束判断
				{
					Sleep(1000);
					over(end(p,xx,yy,1));//结束界面
				}
				num++;    //对弈次数
			}
		}
	}
}
//结束界面	
void over(int x)
{
	point pp[25][25];       //  5--19	
	initialize(pp);      //初始化
	initgraph(400, 400);
	cleardevice();     //使用当前背景色清空绘图设备
	settextstyle(50, 24, "宋体");
	settextcolor(RED);    //字体颜色
	//if (x == 2)
	//{
	//	outtextxy(100, 50, "平局");
	//}
    if (x == 1)
	{
		outtextxy(100, 50, "电脑获胜");
	}
	else if(x==-1)
	{
		outtextxy(100, 50, "玩家获胜");
	}
	settextcolor(WHITE);
	outtextxy(50, 200, "返回游戏界面");
	outtextxy(80, 300, " 结束游戏");

	while (true)
	{
		MOUSEMSG n;//鼠标信息
		n = GetMouseMsg();
		switch (n.uMsg) {
		case WM_LBUTTONDOWN:
			if (n.x <= 350 && n.x >= 50 && n.y <= 250 && n.y >= 200)
				begin(pp);   //返回游戏界面
			if (n.x <= 300 && n.x >= 80 && n.y <= 350 && n.y >= 300) 
			{
				closegraph(); // 关闭绘图窗口
				exit(0);    //强制退出
			}
		}
	}
}
//局面优势评估
double assess(struct point p[25][25])
{
	int i, j;
	p_assess(p);     //某点价值评定
	long double s_value = 0;
	for (i = MIN; i < MAX; i++)
	{
		for (j = MIN; j < MAX; j++)
		{
			s_value += p[i][j].value;//棋盘总优势分为所有点分数的和
		}
	}
	return s_value;
}
//某点价值评定
void p_assess(struct point p[25][25])
{
	int i, j, k, m, n, x, y;
	for (i = MIN; i < MAX; i++)     //可改进为米字刷新
	{
		for (j = MIN; j < MAX; j++)
		{
			if (p[i][j].state == 0)
			{
				p[i][j].value = 0;      //空位价值为零 
			}
			else     //不为空
			{
				long double v1 = V, v2 = V, v3 = V, v4 = V, v5 = V, v6 = V, v7 = V, v8 = V;    //8个方向每个价值为10
				//****************************************************************************
				for (x = 0, n = j; p[i][j].state != -p[i][n + 1].state && n + 1 < 20 && x < 4; x++, n++)       //右
				{
				}
				if (x < 4)
				{
					v1 = 0;    //被挡住为0
				}
				else {
					for (k = 0, n = j; p[i][j].state == p[i][n + 1].state && k < 5; k++, n++)       //右
					{
						v1 *= V;     //连续分数翻倍
					}
				}
				for (y = 0, n = j; p[i][j].state != -p[i][n - 1].state && n - 1 > 4 && y < 4; y++, n--)      //左
				{
				}
				if (y < 4)
				{
					v2 = 0;    //被挡住为0
				}
				else {
					for (k = 0, n = j; p[i][j].state == p[i][n - 1].state && k < 5; k++, n--)      //左
					{
						v2 *= V;     //连续分数翻倍
					}
				}
				//******************************    以下同上   ***************************************
				for (x = 0, n = i; p[i][j].state != -p[n + 1][j].state && n + 1 < 20 && x < 5; x++, n++)       //上
				{
				}
				if (x < 4)
				{
					v3 = 0;    //被挡住为0
				}
				else {
					for (k = 0, n = i; p[i][j].state == p[n + 1][j].state && k < 5; k++, n++)       //上
					{
						v3 *= V;   //连续分数翻倍
					}
				}
				for (y = 0, n = i; p[i][j].state != -p[n - 1][j].state && n - 1 > 4 && y < 5; y++, n--)       //下
				{
				}
				if (y < 4)
				{
					v4 = 0;   //被挡住为0
				}
				else {
					for (k = 0, n = i; p[i][j].state == p[n - 1][j].state && k < 5; k++, n--)       //下
					{
						v4 *= V;   //连续分数翻倍
					}
				}
				//**********************************   以下同上    **************************************
				for (x = 0, m = i, n = j; p[i][j].state != -p[m - 1][n + 1].state && n + 1 < 20 && m - 1 > 4 && x < 5; x++, m--, n++) //右上
				{
				}
				if (x < 4)
				{
					v5 = 0;   //被挡住为0
				}
				else {
					for (k = 0, m = i, n = j; p[i][j].state == p[m - 1][n + 1].state && k < 5; k++, m--, n++)       //右上
					{
						v5 *= V;    //连续分数翻倍
					}
				}
				for (y = 0, m = i, n = j; p[i][j].state != -p[m + 1][n - 1].state && m + 1 < 20 && n - 1 > 4 && y < 5; y++, m++, n--) //左下
				{
				}
				if (y < 4)
				{
					v6 = 0;    //被挡住为0
				}
				else {
					for (k = 0, m = i, n = j; p[i][j].state == p[m + 1][n - 1].state && k < 5; k++, m++, n--)       //左下
					{
						v6 *= V;    //连续分数翻倍
					}
				}
				//***********************************    以下同上    **************************************
				for (x = 0, m = i, n = j; p[i][j].state != -p[m - 1][n - 1].state && n - 1 > 4 && m - 1 > 4 && x < 5; x++, m--, n--)  //左上
				{
				}
				if (x < 4)
				{
					v7 = 0;    //被挡住为0
				}
				else {
					for (k = 0, m = i, n = j; p[i][j].state == p[m - 1][n - 1].state && k < 5; k++, m--, n--)       //左上
					{
						v7 *= V;    //连续分数翻倍
					}
				}
				for (y = 0, m = i, n = j; p[i][j].state != -p[m + 1][n + 1].state && n + 1 < 20 && m + 1 < 20 && y < 5; y++, m++, n++) //右下
				{
				}
				if (y < 4)
				{
					v8 = 0;    //被挡住为0
				}
				else {
					for (k = 0, m = i, n = j; p[i][j].state == p[m + 1][n + 1].state && k < 5; k++, m++, n++)       //右下
					{
						v8 *= V;     //连续分数翻倍
					}
				}
				//********************************************************************************
				p[i][j].value = v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + 0.1 * (15 - abs(i - 12) - abs(j - 12));    //加上距离中心优势分
				if (p[i][j].state == -1)    //玩家棋子为负分
				{
					p[i][j].value = -p[i][j].value * E;       //E为偏向防守程度
				}
			}
		}
	}
}
//极大极小搜索 
double deduction(struct point p[25][25], int sex, int depth, long double a, long double b,int x,int y)
{
	int m, n,i, j,br=0;
	long double va = 0;
	if (depth == 0 || end(p,x,y,sex) != 0)   //达到深度或棋局结束
	{
		return assess(p);       //递归出口，返回分数
	}
	else if (sex == -1)     //玩家回合
	{
		for (m = MIN; m < MAX; m++)
		{
			if (br == 1) {   //b剪枝
				break;
			}
			for (n = MIN; n < MAX; n++)
			{
				if (p[m][n].state == 0 )   //为空
				{				
					if (p[m - 1][n - 1].state != 0 || p[m - 1][n].state != 0 || p[m - 1][n + 1].state != 0 || p[m][n + 1].state != 0 ||
						p[m + 1][n + 1].state != 0 || p[m + 1][n].state != 0 || p[m + 1][n - 1].state != 0 || p[m][n - 1].state != 0)   //不偏僻
					{
						p[m][n].state = -1;    //棋下在这个地方
						va = deduction(p, -sex, depth - 1, a, b,m,n);
						p[m][n].state = 0;      //撤回
					} 
					else{    //偏僻
						va = B;
					}
					if (va < b)    //找最小值
					{
						b = va;
					}
					if (b < a)   
					{
						break;    //b剪枝
						br = 1;
					}
				}
			}
		}
		return b; //返回分数
	}
	else if (sex == 1)     //电脑回合
	{
		for (m = MIN; m < MAX; m++)
		{
			if (br == 1) {   //a剪枝
				break;
			}
			for (n = MIN; n < MAX; n++)
			{
				if (p[m][n].state == 0 )     //为空
				{					
					if (p[m - 1][n - 1].state != 0 || p[m - 1][n].state != 0 || p[m - 1][n + 1].state != 0 || p[m][n + 1].state != 0 ||
						p[m + 1][n + 1].state != 0 || p[m + 1][n].state != 0 || p[m + 1][n - 1].state != 0 || p[m][n - 1].state != 0)   //不偏僻
					{
						p[m][n].state = 1;     //棋下在这个地方
						va = deduction(p, -sex, depth - 1, a, b,m,n);
						p[m][n].state = 0;     //撤回
					}
					else{  //偏僻
						va = A;
					}
					if (va > a)    //找最大值
					{
						a = va;
					}
					if (b < a)
					{
						break;    //a剪枝
						br = 1;
					}
				}
			}
		}
		return a;//返回分数
	}
	return 0;
}
//电脑执棋
int robot(struct point p[25][25])
{
	int i, j, x = 12, y = 12,m, n;
	long double v = -999999999999999999;    //10^18
	for (i = MIN; i < MAX; i++)        //寻找最佳落子点
	{
		for (j = MIN; j < MAX; j++)
		{
			if (p[i][j].state == 0 )      //为空
			{
				if (p[i - 1][j - 1].state != 0 || p[i - 1][j].state != 0 || p[i - 1][j + 1].state != 0 || p[i][j + 1].state != 0 ||
					p[i + 1][j + 1].state != 0 || p[i + 1][j].state != 0 || p[i + 1][j - 1].state != 0 || p[i][j - 1].state != 0)   //不偏僻
				{
					p[i][j].state = 1;    //假设电脑下在这里
					if (end(p, i, j, 1)==1) 
					{
						execute(p, i, j);    //下棋,执行i,j
						return 0;
					}
					p[i][j].n_value = deduction(p, -1, 2, A, B,i,j);
					p[i][j].state = 0;    //撤回

					if (p[i][j].n_value > v)
					{
						v = p[i][j].n_value;    //找最大值
						x = i;
						y = j;     //获取坐标
					}
				}
			}
		}
	}
	execute(p, x, y);    //下棋
	return 0;
}

int main()
{
	point p[25][25];       //  棋盘大小15*15	边界为5
	initialize(p);      //初始化
	begin(p);   //开局
	return 0;
}
枫千叶
关注
  • 29
    点赞
  • 踩
  • 141
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
使用C++编码的井字游戏：深入理解极小极大算法和Alpha-Beta剪枝的实现和应用
qq_38334677的博客
08-09 268
极小极大算法是一种在游戏理论和决策理论中寻找最优策略的算法。它被广泛应用于包括井字游戏在内的各种零和游戏中。在井字游戏中，我们可以将游戏的所有可能状态表示为一个游戏树，其中每个节点表示一个特定的游戏状态，每个边表示一个可能的移动。极小极大算法通过遍历这个游戏树，找到可以使当前玩家获得最大可能得分的移动。然而，对于复杂的游戏，游戏树可能会非常大，遍历所有的节点可能会非常耗时。这就是我们需要Alpha-Beta剪枝的原因。完整代码请下载资源。
C语言五子棋
℃hao的博客
05-02 8420
目前为止跟着学校进度学习C语言大概半年左右，基础学习只学到了指针，学得非常浅。说实话，起初对C语言的印象———只是一个学习计算机语言的敲门砖，对具体C语言如何应用等，非常迷茫。直到大一下半学期的高级语言设计课程之后，试过dos运行的图形化界面的完整小程序，才发现C语言的魅力。 ok，废话不多说了，下面是我第一节课研究的程序————C语言的五子棋。一个简单的小程序。并非纯原创，是基于网络搜索到的“...
五子棋AI算法和开局定式（斜指13式）破解
baidu_41801770的博客
10-01 6998
五子棋AI算法和开局定式（ 斜指13式 ）破解 先前发了几篇五子棋游戏程序设计的博文，设计了游戏程序，也设计了AI智能奕棋的算法，运行程序检测算法的可行性，完成人机模式游戏功能的设置。这还不够，还要提高算法的实战水平。 对于人机对战的电脑智能应子算法，参阅很多五子棋书籍棋谱和五子棋竞赛的对抗棋谱。我感到白棋的后手防御算法很难取胜，棋界有黑棋高手先手必胜一说。算法么想了很多，既然是人工智能下棋就得按人的思路来算计。棋书阐述有许多思路和棋局解说。如活四冲四，嵌五，活三嵌四，活二嵌三。这些是高级棋手的总结。我
人工智能课设——基于A*算法的五子棋博弈系统（Python实现）
最新发布
qq_64928997的博客
06-11 1123
基于A*算法的五子棋博弈系统A)给出用 A*算法设计实现五子棋博弈的思想与方法。B)设计实现五子棋博弈交互系统。C)对不同的格局，以及不同的初始状态和目标状态，记录 A*算法的落棋求解结果。分析A*算法设计实现五子棋博弈的有效性。
五子棋游戏AI智能算法设计
baidu_41801770的博客
12-04 7704
五子棋游戏C语言AI智能算法设计 近来发现编制五子棋游戏很有趣，尤其是AI智能算法很烧脑。网上介绍有什么贪心算法，剪枝算法，博弈树算法等等，不一而足。 对于人机对战的电脑智能应子算法，参阅很多五子棋书籍棋谱和五子棋竞赛的对抗棋谱。我感到白棋的后手防御算法很难取胜，棋界有黑棋高手先手必胜一说。算法么想了很多，既然是人工智能下棋就得按人的思路来算计。棋书阐述有许多思路和棋局解说。如活四冲四，嵌五，活三嵌四，活二嵌二。这些是高级棋手的总结。我就按此思路用加权计权方法来表现此类各种情况。 下面程序代码写出了
AI版的五子棋小游戏
ym18861512953的博客
01-03 7131
本项目实现的五子棋博弈游戏是双人的、完备信息的五子棋问题。游戏模式可以分为人机对弈和双人对弈两种模式。本程序采用基于启发式max/min算法的alpha-beta剪枝技术来选择出最佳的机器落子位置。除此之外，我们还设置了残局闯关模式，在增加了游戏趣味性的同时给用户们带来了更好的游戏体验。
五子棋简易AI算法
quarkx的博客
10-11 6955
Java实现简易五子棋人机算法
AI五子棋——超强改进版本
小天狼星_布莱克 的博客
08-07 5346
【代码】AI五子棋。
C语言实现五子棋
c7473168的博客
07-19 637
role='O'==role?printf("------------请%c落子------------",role);坐标要合法,该位置不能有棋子否则继续重新落子。3,定义一个变量记录棋子角色黑棋'@'白棋'$'printf("%c赢了",role);定义需要数据是否需要对数据进行初始化。1,清理屏幕,显示棋盘角色。c_board();1,定义字符数组的棋盘15*15。t_board();2,定义变量用于记录落子的位置。//清理屏幕初始化棋盘。//显示棋盘。......
C语言五子棋C语言五子棋
03-25
五子棋c语言C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋...
C语言五子棋代码AI或者人机
01-13
在本项目中，我们关注的是一个使用C语言编写的五子棋游戏，它不仅支持人与人之间的对弈，还具备人工智能（AI）对战功能。C语言是一种基础且强大的编程语言，它以其效率和灵活性著称，尤其适用于编写系统级软件和游戏...
纯C语言实现五子棋
09-03
《纯C语言实现五子棋》 五子棋是一种经典的双人策略游戏，深受玩家喜爱。这篇文章将介绍如何使用C语言编写一个简单的五子棋程序。尽管它没有华丽的图形用户界面，但基础的逻辑实现对于理解C语言编程以及游戏算法...
基于c语言开发的五子棋源码
09-21
基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的...
五子棋简单AI算法（C#版）
Error的博客
06-28 4086
本文只提供AI算法，不提供棋盘，因为棋盘不是我写的，不好拿出来分享，望谅解。当前AI只能计算当前局面下最优的一步，没有深度，水平一般的普通人很轻易就会被其击败，但是有很大的升级空间，可以以此为基础再行添加算法添加深度，以及剪枝等算法。当前AI为黑色时水平较高，为白色时需要修改得分表，得分表会影响AI的决策，得分可以自行修改，此得分表并非最佳得分表，但是经过我的测试貌似还可以。ps：这是AI的核心非常重要得分表如下： AI算法思路讲解： 首先我们需要知道输入和输出，给输入当前棋盘的二维数组，从而让他返
AI人机对战五子棋游戏【Python(pygame)+AI】并实现软件输出
weixin_60182338的博客
07-29 8128
AI人机对战五子棋游戏【Python+AI】并实现软件输出，一篇文章展示五子棋游戏，从Python编程，到实现AI技术，再到最后的可执行程序的封装，详细且具体，代码可运行
Java 五子棋AI 算法及实现 详细解析
weixin_71872462的博客
01-07 3841
连五，活四，冲四，活三，眠三，活二，眠二。①连五：顾名思义，五颗同色棋子连在一起，不需要多讲。②活四：有两个连五点（即有两个点可以形成五），图中白点即为连五点。稍微思考一下就能发现活四出现的时候，如果对方单纯过来防守的话，是已经无法阻止自己连五了。③冲四：有一个连五点，如下面三图，均为冲四棋型。图中白点为连五点。相对比活四来说，冲四的威胁性就小了很多，因为这个时候，对方只要跟着防守在那个唯一的连五点上，冲四就没法形成连五。④活三：可以形成活四的三，如下图，代表两种最基本的活三棋型。
【Unity】五子棋AI博弈算法实讲
Leibnezz的博客
02-21 2132
系统的，分层次的讲解了五子棋AI博弈算法。
如何编写一个五子棋AI（附AI源码）
wangyuhan2010的博客
10-04 2124
三子棋的总局面数约为$549,946$，因此我们先以它为基础开始编写。
五子棋AI算法和开局定式（直指13式）破解
baidu_41801770的博客
09-29 3014
我对算法的思路是：黑棋的进攻点就是白棋的防守点，反之，白棋的进攻点就是黑棋的防守点。若抓到冲四活三，嵌五活三，双活三等棋势的叠加进攻点，权分叠加计权，就能绝杀对方。必杀局有双活三，双冲四，冲四加活三，嵌五加活三，嵌五加冲四，这些必杀局就是必胜法宝。黑棋先手要取胜，从第7手开始和9手11手要保持先手，争外势抢先做活三进攻，之后要保先手，做活三冲四，进攻是决胜的法宝。上图100分为双活三或活三嵌四的棋势，若150分则有三个棋势叠加，250分以上是冲四活三，冲四嵌四，嵌五活三，嵌五嵌四等各类棋势。
c语言ai五子棋 极大极小值算法
07-27
极大极小值算法（Minimax Algorithm）是一种常用于博弈游戏的人工智能算法，可以用于实现五子棋游戏的AI。下面是一个基于C语言的简单实现示例： ```c // 定义棋盘大小 #define SIZE 15 // 定义玩家和AI的标记 #define PLAYER 'X' #define AI 'O' // 定义最大搜索深度 #define MAX_DEPTH 6 // 评估函数，用于评估当前局面得分 int evaluate(char board[SIZE][SIZE]) { // TODO: 根据当前棋盘状态评估得分 return 0; } // 极大极小值搜索算法 int minimax(char board[SIZE][SIZE], int depth, int isMaxPlayer) { // 终止条件：达到设定的搜索深度或者游戏结束 if (depth == MAX_DEPTH || isGameOver(board)) { return evaluate(board); } int bestScore; if (isMaxPlayer) { bestScore = INT_MIN; for (int i = 0; i < SIZE; i++) { for (int j = 0; j < SIZE; j++) { if (board[i][j] == ' ') { board[i][j] = AI; int score = minimax(board, depth + 1, 0); board[i][j] = ' '; bestScore = max(bestScore, score); } } } } else { bestScore = INT_MAX; for (int i = 0; i < SIZE; i++) { for (int j = 0; j < SIZE; j++) { if (board[i][j] == ' ') { board[i][j] = PLAYER; int score = minimax(board, depth + 1, 1); board[i][j] = ' '; bestScore = min(bestScore, score); } } } } return bestScore; } // AI下棋的函数 void makeMove(char board[SIZE][SIZE]) { int bestScore = INT_MIN; int bestRow, bestCol; for (int i = 0; i < SIZE; i++) { for (int j = 0; j < SIZE; j++) { if (board[i][j] == ' ') { board[i][j] = AI; int score = minimax(board, 0, 0); board[i][j] = ' '; if (score > bestScore) { bestScore = score; bestRow = i; bestCol = j; } } } } board[bestRow][bestCol] = AI; } // 判断游戏是否结束 int isGameOver(char board[SIZE][SIZE]) { // TODO: 判断游戏是否结束的逻辑 return 0; } ``` 以上是一个简单的极大极小值算法的实现示例，其中evaluate函数用于评估当前局面得分，isGameOver函数用于判断游戏是否结束。在makeMove函数中，AI会根据当前棋盘状态使用极大极小值算法来选择最佳下棋位置。注意，该示例只是一个基本框架，具体的评估函数和游戏结束判断逻辑需要根据实际需求进行实现。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

枫千叶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值