五子棋估价函数

已于 2024-07-13 19:58:24 修改
阅读量4.6k 收藏 67
点赞数 19
文章标签： 数据结构 c++ AI 估价函数
于 2022-02-19 09:34:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54121864/article/details/123014254
版权
博主分享了自己在实现五子棋人机对战AI过程中，针对估价函数的优化历程。从最初的遍历棋盘评估，到通过限制搜索范围提高速度，再到考虑棋子分布细化评估，逐步提升了AI的运行效率。优化后的算法在保持准确性的同时，显著减少了计算量，尤其在处理边角位置时效果更佳。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

前言

最近，我写了一个五子棋人机对战的AI，但速度一直很慢。其实，我感觉性能的瓶颈并不是极小化极大算法和α-β剪枝有问题，而是估价函数太差。其实，估价函数比极小化极大算法和α-β剪枝这两个算法的难度大多了，具体表现是，我开始跟着这篇博客（讲解的非常详细，虽然α-β剪枝有点错误，评论区有人指出来了，但是其他地方包括估价函数值得借鉴。在此也向作者表示感谢）学习博弈树的时候，极小化极大算法和α-β剪枝，我就只看了一个介绍和节点的数据结构模型，然后就摸索着写出了代码（虽然不知道正确不正确）。而估价函数，我是一点头绪都没有，后来只好把教程上的代码复制上了。后来我仔细研究那些代码，终于明白了。并且昨天考试写完试卷闲着无聊的时候，又想出来了一种能略微提升速度的方法。
我也把这个AI和之前做的双人五子棋结合了，形成一个拥有MFC图形界面的五子棋人机对战程序，点击此处下载。

旧版本估价函数

原来的版本思路基本如下：
遍历棋盘，寻找所有的五个点组成的棋链，对每一个棋链执行以下逻辑：

  1. 如果该棋链中既有白子又有黑子，该棋链估价为0；
  2. 如果该棋链中只有n个一种颜色的白棋（默认计算机为白），若 n ≤ 4 n≤4 n≤4，得 k n k^n kn分；若 n = 5 n=5 n=5，得INT_MAX分并且立即结束整个算法（并非对一个棋链的估价，而是对整个棋盘的估价）。k可以自由调整，我这里是10。
  3. 如果该棋链中只有n个一种颜色的黑棋（默认计算机为白），若 n ≤ 4 n≤4 n≤4，得 − p k n -pk^n −pkn分；若 n = 5 n=5 n=5，得INT_MIN分并且立即结束整个算法（并非对一个棋链的估价，而是对整个棋盘的估价）。p可以自由调整。如果想让计算机优先防守，将p设为一个较大的值，如1.5。

最后，把所有棋链的分数加起来即可。
C++代码如下：

/*
一个节点类的成员函数，State是枚举，有BLACK,WHITE,SPACE；Board是棋盘，State[15][15]类型的。
*/
int Evaluate()const//估价函数
{
	int result = 0;
	static auto EvaluateSome = [](const std::array<State, 5>& v)//假定自己是白方
	{
		//判断颜色并记录棋子个数
		State lastColor = SPACE;
		uint8_t count = 0;
		for (State i : v)
		{
			if (i != SPACE)
			{
				++count;
				if (i != lastColor)
				{
					if (lastColor == SPACE)//遇到的第一个棋子
					{
						lastColor = i;
					}
					else//有不同颜色的棋子
					{
						return 0;
					}
				}
			}
		}
		if (!count)//没有棋子
			return 0;
		if (count == 5)
		{
			return lastColor == WHITE ? INT_MAX : INT_MIN;//一定不要认为-INT_MAX就是INT_MIN！
		}
		const int result = static_cast<int>(std::pow(10, count - 1));
		return lastColor == WHITE ? result : static_cast<int>(-1.1 * result);//对手返回负值，我方返回正值，乘以1.1后优先防守
	};
	for (uint8_t i = 0; i < 15; i++)//分别从四个方向判断
	{
		for (uint8_t j = 0; j < 15; j++)
		{
			if (j + 4 < 15)
			{
				std::array<State, 5>v;
				for (uint8_t k = 0; k < 5; k++)
					v[k] = board[i][j + k];
				const int t = EvaluateSome(v);
				if (t == INT_MAX || t == INT_MIN)//决出胜负直接返回
					return t;
				result += t;
			}
			if (i + 4 < 15)
			{
				std::array<State, 5>v;
				for (uint8_t k = 0; k < 5; k++)
					v[k] = board[i + k][j];
				const int t = EvaluateSome(v);
				if (t == INT_MAX || t == INT_MIN)//决出胜负直接返回
					return t;
				result += t;
			}
			if (i + 4 < 15 && j + 4 < 15)
			{
				std::array<State, 5>v;
				for (uint8_t k = 0; k < 5; k++)
					v[k] = board[i + k][j + k];
				const int t = EvaluateSome(v);
				if (t == INT_MAX || t == INT_MIN)//决出胜负直接返回
					return t;
				result += t;
			}
			if (i + 4 < 15 && j - 4 >= 0)
			{
				std::array<State, 5>v;
				for (uint8_t k = 0; k < 5; k++)
					v[k] = board[i + k][j - k];
				const int t = EvaluateSome(v);
				if (t == INT_MAX || t == INT_MIN)//决出胜负直接返回
					return t;
				result += t;
			}
		}
	}
	return result;
}

这个代码需要把整个棋盘遍历一遍，粗略估计一下，遍历的范围是15×15=225。

新版本估价函数

我突然想到，你下到一个地方，只能影响到周围9×9的范围，我们可以把每一个节点的估价保存下来，然后，创建一个新的节点时，先按照原来的方法估价这9×9的范围，然后估价父节点9×9的范围，用父节点原来的估价分数减去父节点9×9的范围得分，再加上子节点9×9范围的得分，就是子节点的得分。这种算法在最坏情况下（落子地方靠近棋盘中间），需要遍历的范围是9×9×2=162，计算量大大减小。另外，如果落子的地方靠近棋盘边角，使得9×9的范围缩小，那就可以更节省时间，最好情况下（下到棋盘角上）遍历范围只有6×6×2=72。现实情况中，有许多次都是遍历了边角处，所以速度加快了许多。这样还有一个好处，就是最坏情况始终是162，不会因为棋盘的变大而变大，如果棋盘是100×100，这个算法还是遍历162个，而第一种算法遍历100×100=10000个。经过测试，这种方法比原来的速度提高了许多。下面是C++代码：

int Evaluate()const//估价函数
{
	static auto EvaluateSome = [](State board[BOARDSIZE][BOARDSIZE], uint8_t beginX, uint8_t endX, uint8_t beginY, uint8_t endY) {
		static auto EvaluateList = [](const std::array<State, 5>& v)//假定自己是白方
		{
			//判断颜色并记录棋子个数
			State lastColor = SPACE;
			uint8_t count = 0;
			for (State i : v)
			{
				if (i != SPACE)
				{
					++count;
					if (i != lastColor)
					{
						if (lastColor == SPACE)//遇到的第一个棋子
						{
							lastColor = i;
						}
						else//有不同颜色的棋子
						{
							return 0;
						}
					}
				}
			}
			if (!count)//没有棋子
				return 0;
			if (count == 5)
			{
				return lastColor == WHITE ? INT_MAX : INT_MIN;//一定不要认为-INT_MAX就是INT_MIN！
			}
			const int result = static_cast<int>(std::pow(10, count - 1));
			return lastColor == WHITE ? result : -result;//对手返回负值，我方返回正值
		};
		int result = 0;
		for (uint8_t i = beginX; i < endX; i++)//分别从四个方向判断
		{
			for (uint8_t j = beginY; j < endY; j++)
			{
				if (j + 4 < endY)
				{
					std::array<State, 5>v;
					for (uint8_t k = 0; k < 5; k++)
						v[k] = board[i][j + k];
					const int t = EvaluateList(v);
					if (t == INT_MAX || t == INT_MIN)//决出胜负直接返回
						return t;
					result += t;
				}
				if (i + 4 < endX)
				{
					std::array<State, 5>v;
					for (uint8_t k = 0; k < 5; k++)
						v[k] = board[i + k][j];
					const int t = EvaluateList(v);
					if (t == INT_MAX || t == INT_MIN)//决出胜负直接返回
						return t;
					result += t;
				}
				if (i + 4 < endX && j + 4 < endY)
				{
					std::array<State, 5>v;
					for (uint8_t k = 0; k < 5; k++)
						v[k] = board[i + k][j + k];
					const int t = EvaluateList(v);
					if (t == INT_MAX || t == INT_MIN)//决出胜负直接返回
						return t;
					result += t;
				}
				if (i + 4 < endX && j >= 4)
				{
					std::array<State, 5>v;
					for (uint8_t k = 0; k < 5; k++)
						v[k] = board[i + k][j - k];
					const int t = EvaluateList(v);
					if (t == INT_MAX || t == INT_MIN)//决出胜负直接返回
						return t;
					result += t;
				}
			}
		}
		return result;
	};
	uint8_t beginX, endX, beginY, endY;
	if (lastX <= 5)
		beginX = 0;
	else
		beginX = lastX - 5;
	endX = lastX + 5;
	if (endX > BOARDSIZE)
		endX = BOARDSIZE;
	if (lastY <= 5)
		beginY = 0;
	else
		beginY = lastY - 5;
	endY = lastY + 5;
	if (endY > BOARDSIZE)
		endY = BOARDSIZE;
	const int t = EvaluateSome((State(*)[15])board, beginX, endX, beginY, endY);
	if (t == INT_MAX || t == INT_MIN)//决出胜负直接返回
		return t;
	return  t - EvaluateSome((State(*)[15])father->board, beginX, endX, beginY, endY) + father->evaluateValue;
}

第三版估价函数

过了一段时间，我又想出了一种更优的方案，，具体来说，在判断一个棋链的得分（即EvaluateList 函数）时，不再简单地根据棋子的数量确定分数，而是考虑棋子的具体分布，对每一种分布给出一个特定的分数。不难看出，这样没有改变时间复杂度，但使结果相对来说准确了一些。下面是一个棋链中不同分布对应的得分，这里的分数是我估摸着打的，可以进行调整优化。
另外，评论区有大佬指出，并不需要重新计算9*9的区域，只需要计算包含上一步落子点的最多20个棋链就可以，这样也可以大大加快速度。
代码：

int Evaluate()const//估价函数
{
	static const auto EvaluateList = [](const std::array<State, 5>& v)//假定自己是白方
		{
			//判断颜色并记录棋子个数
			State lastColor = SPACE;
			uint8_t bitList = 0;//将棋链以二进制形式表示，如01101
			for (State i : v)
			{
				bitList <<= 1;
				if (i != SPACE)
				{
					if (i != lastColor)
					{
						if (lastColor == SPACE)//遇到的第一个棋子
							lastColor = i;
						else//有不同颜色的棋子
							return 0;
					}
					bitList |= 1;
				}
			}
			static constexpr int results[]
				= { 0,5,5,80,5,60,100,500,5,20,80,500,100,500,8000,100000,5,10,//0-17
				20,600,50,600,500,8000,80,600,500,6000,500,8000,100000,maxEvaluteValue };//18-31
			/*
			* 十进制-二进制-得分
			* 0-00000-0
			* 1-00001-5
			* 2-00010-5
			* 3-00011-80
			* 4-00100-5
			* 5-00101-60
			* 6-00110-100
			* 7-00111-500
			* 8-01000-5
			* 9-01001-20
			* 10-01010-80
			* 11-01011-500
			* 12-01100-100
			* 13-01101-500
			* 14-01110-8000
			* 15-01111-100000
			* 16-10000-5
			* 17-10001-10
			* 18-10010-20
			* 19-10011-600
			* 20-10100-50
			* 21-10101-600
			* 22-10110-500
			* 23-10111-5000
			* 24-11000-80
			* 25-11001-600
			* 26-11010-500
			* 27-11011-6000
			* 28-11100-500
			* 29-11101-5000
			* 30-11110-100000
			* 31-11111-MAX
			*/
			//对手返回负值，我方返回正值
			//乘以1.1是为了偏重防守
			if (bitList == 31)
			{
				return lastColor == WHITE ? maxEvaluteValue : -maxEvaluteValue;
			}
			return lastColor == WHITE ? results[bitList] : -results[bitList] * 11 / 10;
		};
	static const auto EvaluteSome = [](State** board, uint8_t lastX, uint8_t lastY)
		{
			int result = 0;
			for (uint8_t i = 0; i < 5; ++i)
			{
				//横向
				if (lastX + i < boardSize && lastX + i >= 4)
				{
					std::array<State, 5>v;
					for (uint8_t k = 0; k < 5; k++)
						v[k] = board[lastX + i - k][lastY];
					int t = EvaluateList(v);
					if (t == maxEvaluteValue || t == -maxEvaluteValue)//决出胜负直接返回
						return t;
					result += t;
				}
				//纵向
				if (lastY + i < boardSize && lastY + i >= 4)
				{
					std::array<State, 5>v;
					for (uint8_t k = 0; k < 5; k++)
						v[k] = board[lastX][lastY + i - k];
					int t = EvaluateList(v);
					if (t == maxEvaluteValue || t == -maxEvaluteValue)//决出胜负直接返回
						return t;
					result += t;
				}
				//左上-右下
				if (lastX + i < boardSize && lastX + i >= 4 && lastY + i < boardSize && lastY + i >= 4)
				{
					std::array<State, 5>v;
					for (uint8_t k = 0; k < 5; k++)
						v[k] = board[lastX + i - k][lastY + i - k];
					int t = EvaluateList(v);
					if (t == maxEvaluteValue || t == -maxEvaluteValue)//决出胜负直接返回
						return t;
					result += t;
				}
				//左下-右上
				if (lastX + i < boardSize && lastX + i >= 4 && lastY - i + 4 < boardSize && lastY - i >= 0)
				{
					std::array<State, 5>v;
					for (uint8_t k = 0; k < 5; k++)
						v[k] = board[lastX + i - k][lastY - i + k];
					int t = EvaluateList(v);
					if (t == maxEvaluteValue || t == -maxEvaluteValue)//决出胜负直接返回
						return t;
					result += t;
				}
			}
			return result;
		};
	int t = EvaluteSome(board, lastX, lastY);
	if (t == maxEvaluteValue || t == -maxEvaluteValue)//决出胜负直接返回
		return t;
	return t + father->GetEvaluateValue() - EvaluteSome(father->board, lastX, lastY);
}
c语言五子棋评估函数,局面评估函数——简介
weixin_33924688的博客
05-25 2242
《对弈程序基本技术》专题评价函数David Eppstein */文*加州爱尔文大学(UC Irvine)信息与计算机科学系整体考虑在你的程序中，评价函数综合了大量跟具体棋类有关的知识。我们从以下两个基本假设开始：(1)我们能把局面的性质量化成一个数字。例如，这个数字可以是对取胜的概率作出的估计；但是大多数程序不给这个数字以如此确定的含义，因此这仅仅是一个数子而已。(2)我们衡量的这个性质应该跟对...
使用pygame实现的五子棋，状态机， 估值函数
YC的博客
12-20 2191
成果展示 首先展示一下程序的成果，最后的画面会是这个模样： 。。。右边的两颗一黑一白的棋子比较调皮，它会动。 主要功能 主要实现了人机对弈，机机对弈（手动改几行注释就可以了），利用Pygame绘制游戏界面，运用了状态机， 估值函数。 由于状态机的运用，使得所有对象都可以被一个对象管理，方便了程序的扩展，只需要添加状态和创建实体类，就可以增加新的模块与功能。 程序的架构 这个程序文件包...
五子棋估值函数版ai
01-25
以DOS模式实现了五子棋游戏，代码是由c++语言编写，实现了人机对弈
c语言五子棋评估函数,简易五子棋评估函数
weixin_39825941的博客
05-25 843
voidCFiveChessDlg::ComputerDown(){int mode = 0, cur = 0, curX = 0, curY = 0, sum1 = 0, sum2 = 0;int x = 0, y = 0, cx = 0, cy = 0, cPrior = 0, prior = 0, flgL = 0, flgR = 0;for (x = 0; x < 15; x++){...
战就战——与AI对弈五子棋，真的打不过
最新发布
穿梭的编织者
02-20 1001
AI五子棋
Python 五子棋AI实现(2):棋型评估函数实现
热门推荐
marble_xu的博客
05-23 3万+
python 五子棋AI实现（2）：棋型评估函数实现五子棋基本棋型介绍评估方法介绍代码实现 五子棋基本棋型介绍 参考资料：http://game.onegreen.net/wzq/HTML/142336.html 最常见的基本棋型大体有以下几种：连五，活四，冲四，活三，眠三，活二，眠二。 ① 连五：顾名思义，五颗同色棋子连在一起，不需要多讲。 图2-1 ② 活四：有两个连五点（即有两个点可以形成五...
五子棋机器博弈系统评估函数的设计.pdf
09-15
不过，根据标题“五子棋机器博弈系统评估函数的设计.pdf”和描述“五子棋机器博弈系统评估函数的设计.pdf”，我们可以推断出与文档相关的信息。 标题和描述表明了文档的核心内容是关于设计一个五子棋机器博弈系统的...
写一个五子棋的估价函数
04-13
好的，对于五子棋的估价函数，通常采用的是博弈树搜索和启发式算法的结合方式来进行实现。其中，博弈树搜索是通过不断模拟棋局的方式，来预测每一步棋的胜率和收益，从而实现估价的目的。而启发式算法则是通过对棋局...
优化AI五子棋游戏：从估价函数到alpha-beta剪枝技术
6. 估价函数: 在五子棋AI中，估价函数用于评估棋盘的当前状态。估价函数的准确性直接影响到AI的决策质量。通常，估价函数会考虑棋型、棋子的威胁程度、棋子的连通性等因素。 7. 游戏编程: 游戏编程涵盖了创建游戏所...
基于C的α-β剪枝算法实现的AI五子棋游戏
xiqsun0的博客
04-02 2397
源码下载 http://www.byamd.xyz/hui-zong-1/ 对抗问题 对抗问题：顾名思义，博弈双方是带有对抗性质的。博弈的任何一方都希望局面尽量对自己有利，同时局面也应该尽量令对方不利。通常这一类问题可以通过 Minimax 算法解决。 Minimax 算法又名极小化极大算法，是一种找出失败的最大可能性中的最小值的算法。 Minimax 算法常用于棋类等由两方较量的游戏和程序，这类程序由两个游戏者轮流，每次执行一个步骤。 为了执行Minimax 算法，我们可以通过穷举的方式，枚举所有的
五子棋初步以及对五子棋的局面估值
gaboolic的专栏
01-30 6647
我对五子棋还是有一点研究的。 虽然现在技术大不如前了，但理论知识还在。 其实所有棋类游戏，先手都有一个优势。（黑白棋除外，由于黑白棋特殊的胜负判定方式，黑白棋甚至有后手优势） 为什么有先手优势？ 这是因为，无论是五子棋，象棋，跳棋，等等，先手方都先走了一步。 以五子棋为例，先达成五子连珠者胜，由于黑方先走了一步，五子棋几乎是先手必胜的局面。 如果胜负方式改为，如果黑方达成五子连珠之后，
C++五子棋 评分算法类实现
08-05
C++五子棋小程序 通过评分算法找到最佳下棋位置 支持选择先手方
五子棋的基本函数
07-16
在linux下五子棋需要的一些基本的图形界面和按键的获取的实现！
五子棋的简单算法——评分法（人机对抗代码）
weixin_44342683的博客
04-17 1万+
之前搞了个五子棋的算法，我在写好算法之前参考网上很多的五子棋算法像是博弈树算法这些的一开始写起来不太好理解，今天就分享一个简单的五子棋算法——评分法。 评分法 原理： 评分法，有的也叫评分表法，不管叫什么，名字不重要，重要的是思路。我们写棋总是下在对自己优势最大的位置上，但是可以下的位置有很多啊，电脑怎么知道下在哪里最好啊？评分法就是给每个可下的位置评分，电脑通过分数高低来判断下在哪个位置。 方法...
Python 五子棋AI实现(4):启发式评估
marble_xu的博客
06-06 1万+
python 五子棋AI实现（3）：启发式评估启发式评估 启发式评估 影响alpha beta剪枝效率的关键，是要让评分高的位置更早的被搜索到，这样可以更快的进行剪枝。 要实现这一点，就需要对每一个可以下的位置进行评分的预估，让预估分高的位置排在前面。 这边采用的预估评分方法是对于一个空的位置，分布下白棋或黑棋，获取这个点四个方向能够形成的棋型，然后打分。 ...
一种五子棋算法
刘爱贵的专栏
03-29 1万+
学习算法分析设计时练手所写的，主要是自娱。算法采用极大极小剪枝博弈算法，人工智能还凑和，但BUG多多，有时间再改改。设计主要包括：数据结构、估值函数、胜负判断、搜索算法VC实现：http://goc.ac.cn/liuag/html/software_fivechess.html1、数据结构//记录每步棋，可以建立链表用来进行悔棋、后退(本程序没有实现)struct Step{
五子棋估值算法
weixin_30767835的博客
09-21 1583
目录 　　 程序布局 　　 估值算法 　　 完整代码 程序布局 　　首先说明整个五子棋程序的整体布局。（用Java实现） class Chess{ //界面类 　　Player player1 ; 　　Player player2; 　　ChessBox bo...
C语言五子棋评分函数,五子棋评分表算法
weixin_36387422的博客
05-24 1478
最近学了一点QT的绘图，因而乎照着学长的代码绘制了五子棋的小游戏。算法最基础的东西这里就不说了，本身的知识也仅仅比会用多那么一点，下面咱们来讲说这里貌似高大上的人机AI吧。编程评分表算法数组通常状况下棋盘是15*15的。那么应该是572个五元组。而这五元组由黑棋白棋还有空格组成。也就是 3^5 * 572 = 138996; 看着不少吧，实际上是能够分类的。每一个五元组就是一种局势。.net咱们只...
c语言五子棋棋面评分函数,跪求C语言五子棋悔棋部分实现
weixin_42305377的博客
05-24 165
该楼层疑似违规已被系统折叠隐藏此楼查看此楼//将整个棋盘算出并储存到缓冲器，然后调用Display函数显示出来{int i,j;//循环变量wl=0;wp=0;for(j=0;j<=MAXIMUS;j++)//写入出交点左上角的字符，因为需要打印棋盘右下角，所以很以横纵各多一次循环{for(i=0;i<=MAXIMUS;i++){write(getCurse(i,j));//写入左上...
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值