C++五子棋AI

已于 2023-08-01 11:55:02 修改
阅读量2.6k 收藏 28
点赞数 8
文章标签： c++ 人工智能 算法 ai 游戏
于 2022-01-28 20:13:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54121864/article/details/122729176
版权

运用了极小化极大算法，α-β剪枝。经过最近的优化，运行速度提高了许多，在maxDepth为3的情况下（加根节点是4层），开启O2优化并且用Release版本编译，能达到两秒左右搜索完毕。这个版本把maxDepth改为4，搜索时间大概30秒左右。

#pragma once
#include<iostream>
#include<vector>
#include<array>
#include<fstream>
#include<algorithm>
class GameTree
{
public:
	class Node
	{
	public:
		enum State :uint8_t/*节省内存*/ { SPACE, BLACK, WHITE };
	private:
		friend class GameTree;
		static const uint8_t BOARDSIZE = 15;
		int value;//叶节点表示估价函数的结果，MAX节点表示α值，MIN节点表示β值
		int evaluateValue;//估价函数计算的结果，用于优化
		unsigned short depth;//深度
		uint8_t lastX, lastY;//上一次落子的xy坐标
		Node* father;//父亲节点
		std::vector<Node*> children;//子节点
		State **board;//棋盘
		int Evaluate()const//估价函数
		{
			static const auto EvaluateSome = [](State **board, uint8_t beginX, uint8_t endX, uint8_t beginY, uint8_t endY) {
				static const auto EvaluateList = [](const std::array<State, 5>& v)//假定自己是白方
				{
					//判断颜色并记录棋子个数
					State lastColor = SPACE;
					uint8_t bitList = 0;//将棋链以二进制形式表示，如01101
					for (State i : v)
					{
						if (i != lastColor)
						{
							if (lastColor == SPACE)//遇到的第一个棋子
								lastColor = i;
							else//有不同颜色的棋子
								return 0;
						}
						if (i != SPACE)
							bitList = bitList * 2 + 1;
					}
					int result = 0;
					switch (bitList)
					{
					case 0://00000
						result = 0;
						break;
					case 1://00001
					case 2://00010
					case 4://00100
					case 8://01000
					case 16://10000
						result = 5;
						break;
					case 3://00011
					case 24://11000
						result = 80;
						break;
					case 6://00110
					case 12://01100
						result = 100;
						break;
					case 10://01010
						result = 80;
						break;
					case 5://00101
					case 20://10100
						result = 60;
						break;
					case 9://01001
					case 18://10010
						result = 20;
						break;
					case 17://10001
						result = 10;
						break;
					case 7://00111
					case 28://11100
						result = 800;
						break;
					case 14://01110
						result = 1000;
						break;
					case 13://01101
					case 26://11010
					case 11://01011
					case 22://10110
						result = 800;
						break;
					case 19://10011
					case 21://10101
					case 25://11001
						result = 600;
						break;
					case 15://01111
					case 30://11110
						result = 10000;
						break;
					case 29://11101
					case 23://10111
						result = 8000;
						break;
					case 27://11011
						result = 6000;
						break;
					case 31://11111
						return lastColor == WHITE ? INT_MAX : INT_MIN;
					}
					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(board, beginX, endX, beginY, endY);
			if (t == INT_MAX || t == INT_MIN)//决出胜负直接返回
				return t;
			return  t - EvaluateSome(father->board, beginX, endX, beginY, endY) + father->evaluateValue;
		}

	public:
		//非根节点的构造函数
		Node(Node* nf, uint8_t x, uint8_t y) :father(nf), lastX(x), lastY(y), depth(nf->depth + 1), value(0), board(new State* [BOARDSIZE])
		{
			father->children.push_back(this);
			for (int i = 0; i < BOARDSIZE; ++i)
			{
				board[i] = new State[BOARDSIZE];
				memcpy_s(board[i], BOARDSIZE * sizeof(State), father->board[i], BOARDSIZE * sizeof(State));
			}
			board[lastX][lastY] = IsMaxNode() ? BLACK : WHITE;
			evaluateValue = Evaluate();
			for (int i = 0; i < BOARDSIZE; ++i)
			{
				delete[] board[i];
			}
			delete[] board;
			board = nullptr;
		}
		//根节点的构造函数
		Node(int _depth, uint8_t x, uint8_t y) :father(nullptr), depth(_depth), lastX(x), lastY(y), value(0),evaluateValue(0),board(new State*[BOARDSIZE])
		{
			for (int i = 0; i < BOARDSIZE; ++i)
			{
				board[i] = new State[BOARDSIZE];
				memset(board[i], 0, BOARDSIZE * sizeof(State));
			}
			board[x][y] = IsMaxNode() ? BLACK : WHITE;
		}
		inline int GetEvaluateValue()const
		{
			return evaluateValue;
		}
		inline bool IsMaxNode()const//默认计算机后手
		{
			return depth & 1u;//相当于depth%2
		}
		void Search(unsigned short _depth)
		{
			if (_depth == 0 || this->evaluateValue == INT_MAX || this->evaluateValue == INT_MIN)
			{
				this->value = this->evaluateValue;
				return;
			}
			bool created = false;//记录是否new出新的Node，如果没有就不用排序了。
			if (!board)//不是根节点
			{
				board = new State * [BOARDSIZE];
				for (int i = 0; i < BOARDSIZE; ++i)
				{
					board[i] = new State[BOARDSIZE];
					memcpy_s(board[i], BOARDSIZE * sizeof(State), father->board[i], BOARDSIZE * sizeof(State));
				}
				board[lastX][lastY] = IsMaxNode() ? BLACK : WHITE;
			}
			for (uint8_t i = 0; i < BOARDSIZE; i++)
			{
				for (uint8_t j = 0; j < BOARDSIZE; j++)
				{
					if (!board[i][j])
					{
						bool flag = false;
						if (_depth >= 2)//若剩余深度小于2，则下一层肯定没有搜索过
						{
							for (Node* child : this->children)
							{
								if (child->lastX == i && child->lastY == j)//已经被搜索过
								{
									flag = true;
									break;
								}
							}
						}
						if (!flag)
						{
							new Node(this, i, j);
							created = true;
						}
					}
				}
			}
			if (IsMaxNode())
			{
				this->value = INT_MIN;
				if (created)
				{
					std::sort(this->children.begin(), this->children.end(), [](Node* a, Node* b) {
						return a->GetEvaluateValue() > b->GetEvaluateValue();
						});//按照估价从大到小排序，增加剪枝的概率
				}
			}
			else
			{
				this->value = INT_MAX;
				if (created)
				{
					std::sort(this->children.begin(), this->children.end(), [](Node* a, Node* b) {
						return a->GetEvaluateValue() < b->GetEvaluateValue();
						});//按照估价从小到大排序，增加剪枝的概率
				}
			}
			auto ReleaseMemory = [this] {
				if (father)//不是根节点
				{
					for (int i = 0; i < BOARDSIZE; ++i)
					{
						delete[] board[i];
					}
					delete[] board;
					board = nullptr;
				}
			};
			for (Node* child : this->children)
			{
				child->Search(_depth - 1);
				//α - β 剪枝
				if (IsMaxNode())
				{
					if (child->value > this->value)
					{
						this->value = child->value;
						if (this->father && this->value >= this->father->value && this != this->father->children.front())
						{
							ReleaseMemory();
							return;//剪枝
						}
					}
				}
				else//MIN节点
				{
					if (child->value < this->value)
					{
						this->value = child->value;
						if (this->father && this->value <= this->father->value && this != this->father->children.front())
						{
							ReleaseMemory();
							return;//剪枝
						}
					}
				}
			}
			ReleaseMemory();
		}
		void DeleteAllButThis()
		{
			if (!father->board)//父节点不是根节点
				throw std::invalid_argument("this->father必须是根节点！");
			for (Node* n : father->children)
			{
				if (n != this)
					delete n;
			}
			board = new State * [BOARDSIZE];
			for (int i = 0; i < BOARDSIZE; ++i)
			{
				board[i] = new State[BOARDSIZE];
				memcpy_s(board[i], BOARDSIZE * sizeof(State), father->board[i], BOARDSIZE * sizeof(State));
				delete[] father->board[i];
			}
			delete[] father->board;
			board[lastX][lastY] = IsMaxNode() ? BLACK : WHITE;
			free(father);//避免调用析构函数
			father = nullptr;
		}
		inline bool IsFull()const
		{
			return depth == BOARDSIZE * BOARDSIZE;
		}
		inline State GetWinner()const
		{
			if (this->value == INT_MAX)
			{
				return Node::WHITE;
			}
			else if (this->value == INT_MIN)
			{
				return Node::BLACK;
			}
			return Node::SPACE;
		}
		~Node()
		{
			if (board)
			{
				for (int i = 0; i < BOARDSIZE; ++i)
				{
					delete[] board[i];
				}
				delete[] board;
			}
			for (Node* n : children)
			{
				delete n;
			}
		}
	};
private:
	Node* root;
	const unsigned short maxDepth;
public:
	GameTree(unsigned short _maxDepth) : root(nullptr), maxDepth(_maxDepth)
	{
		if (_maxDepth < 2)
			throw std::invalid_argument("最大层数必须大于等于2！");
	}
	std::pair<uint8_t, uint8_t>AIGetNextPos(uint8_t x, uint8_t y)
	{
		if (root)
		{
			for (Node* node : root->children)//进入用户选择的分支
			{
				if (node->lastX == x && node->lastY == y)
				{
					node->DeleteAllButThis();
					root = node;
					break;
				}
			}
		}
		else//第一次开局
		{
			root = new Node(1, x, y);
		}
		root->Search(maxDepth);
		if (root->IsFull())
			return std::make_pair(Node::BOARDSIZE, Node::BOARDSIZE);
		for (Node* node : root->children)//选择分值最大的
		{
			if (node->value == root->value)
			{
				node->DeleteAllButThis();
				root = node;
				break;
			}
		}
		return std::make_pair(root->lastX, root->lastY);
	}
	Node::State GetWinner()const
	{
		return root->GetWinner();
	}
	void Run()
	{
		while (1)
		{
			int x, y;
			do
			{
				std::cout << "输入x,y坐标";
				std::cin >> x >> y;
			} while (x < 0 || y < 0 || x >= 15 || y >= 15 || (root && root->board[x][y] != Node::SPACE));
			if (root)
			{
				for (Node* node : root->children)//进入用户选择的分支
				{
					if (node->lastX == x && node->lastY == y)
					{
						node->DeleteAllButThis();
						root = node;
						break;
					}
				}
			}
			else//第一次开局
			{
				root = new Node(1, x, y);
			}
			system("cls");
			for (int i = 0; i < Node::BOARDSIZE; i++)
			{
				for (int j = 0; j < Node::BOARDSIZE; j++)
				{
					if (root->board[i][j] == Node::SPACE)
						std::cout << "十 ";
					else if (root->board[i][j] == Node::BLACK)
						std::cout << "黑 ";
					else
						std::cout << "白 ";
				}
				std::cout << '\n';
			}
			root->Search(maxDepth);
			if (root->value == INT_MAX)
			{
				std::cout << "电脑胜利！";
				break;
			}
			else if (root->value == INT_MIN)
			{
				std::cout << "玩家胜利！";
				break;
			}
			else if (root->IsFull())//不能用root->value==0判断平局，因为平局一定为0，但为0不一定平局
			{
				std::cout << "平局！";
				break;
			}
			for (Node* node : root->children)//选择分值最大的
			{
				if (node->value == root->value)
				{
					node->DeleteAllButThis();
					root = node;
					break;
				}
			}
			system("cls");
			for (int i = 0; i < Node::BOARDSIZE; i++)
			{
				for (int j = 0; j < Node::BOARDSIZE; j++)
				{
					if (root->board[i][j] == Node::SPACE)
						std::cout << "十 ";
					else if (root->board[i][j] == Node::BLACK)
						std::cout << "黑 ";
					else
						std::cout << "白 ";
				}
				std::cout << '\n';
			}
			if (root->value == INT_MAX)
			{
				std::cout << "电脑胜利！";
				break;
			}
			else if (root->value == INT_MIN)
			{
				std::cout << "玩家胜利！";
				break;
			}
			else if (root->IsFull())//不能用root->value==0判断平局，因为平局一定为0，但为0不一定平局
			{
				std::cout << "平局！";
				break;
			}
		}
	}
	~GameTree()
	{
		delete root;
	}
};
[PE]经典八炮
关注
  • 8
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
c++ 五子棋AI 算法及实现 详细解析
weixin_44062380的博客
05-03 2万+
对于某一个方向上的排成一条直线的棋子，我称其为**棋链**，如下方的图就是一个**棋链**
c语言五子棋最简单的ai,C++简单五子棋的AI设计实现
weixin_42425967的博客
05-23 1366
本文实例为大家分享了C++五子棋的AI设计实现代码，供大家参考，具体内容如下设计思路：通过接口获取信息来确定颜色，通过set_chess函数来确定落点。对每个点位给出两种颜色棋子的打分，分别存在两个15*15的数组里，数组下标代表点的位置。确定最大值所在数组之后，遍历该数组找出所有最大值对应的位置，然后对这些位置统计另一种颜色的棋子的分数，再选取一次最大值，从而确定要落点的位置。打分函数的设计：在...
C++ 实现对战AI五子棋
zhoubancheng的博客
01-04 8808
为了能够快速上手一门语言，我们往往在学习了基本语法后，采用写一个小项目的方式来加深理解语言的语法及运用，本文采用c++去实现对战AI五子棋，采用面向对象开发的一款游戏，里面应用了类和对象以及vector容器等知识。
C++五子棋人机对战
热门推荐
程序员Rock的博客
06-10 4万+
使用C++，开发五子棋人机对战，快速提升C++项目开发能力。
基于博弈树的五子棋 AI 算法及其 C++ 实现
大肥肥熊熊的技术空间
11-27 2万+
基于博弈树的五子棋 AI 算法及其 C++ 实现摘要一   五子棋的游戏规则二   五子棋对弈的算法描述2.1 博弈树搜索算法2.2 α ─ β 剪枝2.3 估价函数 摘要 五子棋是一个风靡全国的棋类游戏，本文研究五子棋的博弈树算法，并编程实现该算法。本文介绍了博弈树的极大极小搜索算法和α-β剪枝优化技术，并提出了自己的估价函数。本文采用C++编程，并用类封装代码，方便外部调用。本文展示了一个人机对弈过程的实例和一个机机对弈过程的实例，实践证明该算
基于C++的人机对弈的五子棋AI程序
毕业作品网站
05-09 2659
实验报告：实验报告要求清晰简洁，重点突出，重点介绍马尔科夫过程实现的策略方法，使用提供的模板，中文撰写，导出为 pdf，长度不超过 6 页，此部分占本次作业总分的 30%。实验报告：清晰简洁，重点突出，重点介绍搜索部分实现的策略及方法，使用提供的模板，中文撰写，导出为 pdf，长度不超过 6 页，此部分占本次作业总分的 30%。AI 从蓝色的起点出发，找到一条到达红色终点的路，灰色格子为陷阱（走到陷阱立刻回到起点），黑色格子为障碍（障碍同边界相同，走到障碍或边界返回上一步所在位置）
C++实现简单五子棋AI
薛崇祥的博客
10-09 4359
使用方法： 输入二维坐标0~14落子，输入-1 -1可以悔棋 #include&amp;amp;amp;lt;bits/stdc++.h&amp;amp;amp;gt; using namespace std; #define bas 15 #define Dep_limit 3 #define inf 0x3f3f3f int score[2][6]={{0,5,25,4000,inf,inf},{0,0,2,50,4000,inf}};//...
C++ AI五子棋
m0_72019193的博客
06-22 264
【代码】C++ AI五子棋。
【C语言】Top K问题【建小堆】
2301_80840905的博客
08-04 475
在我们生活中，经常会遇到TopK问题。建小堆解决
C++ STL copy, move 用法
08-04 225
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
【C++】输入输出
2401_83948390的博客
08-02 527
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
OD C卷 - 中庸行者
weixin_45228198的博客
08-04 187
DFS
c++——map、set底层之AVL树（动图演示旋转）
最新发布
2301_80687320的博客
08-05 767
我们之前学了过二叉搜索树，二这里的AVL也是一种搜索树，当我们二叉搜索树发生偏移时，搜索时间就会边长，就不树logN了，变成N；而AVL就修复了这一点。一、{}// 该节点的左孩子// 该节点的右孩子// 该节点的双亲T _data;int _bf;// 该节点的平衡因子。
3.C_Demo_最大公约数、最小公倍数
Fresh_man111的博客
08-03 294
假设两个数字a和b，求两个数字相除的余数c=a%b，如果余数为0，则b为最大公约数。如果b不为零，a=b,b=c,继续循环计算。两个数的最小公倍数数等于两个数的乘积除以两个数的最大公约数。即：x，y的最小公倍数 min(公倍数)=x*y÷max(公约数)参数a，b：传入的两个数值，两个数都不能为0。参数a，b：传入的两个数值，不能全为0。返回值：0代表错误，正常返回最大公约数。返回值：0代表错误，正常返回最小公倍数。功能：求a，b最大公约数。功能：求a，b最小公倍数。
C++｜设计模式（八）｜⭐️工厂模式？错！是工厂模式群！
糖炒栗子
08-02 889
首先我们按照与 Employee 类相同的方式来创建所有不同项目对应的基类（父类）Project，在这个类中我们还定义了与项目相关的接口 assignTo ，这个接口可以将某个项目指派给对应账户ID的员工，还是相同的方式我们定义 ITProject 与 UIProject 这两个不同项目的子类，并提供 assignTo 接口的不同实现。
【C语言篇】C语言数据类型和变量
2301_79849925的博客
07-27 814
C语⾔提供了丰富的数据类型来描述⽣活中的各种数据。 - 使⽤整型类型来描述整数 - 使⽤字符类型来描述字符 - 使⽤浮点型类型来描述⼩数 所谓“类型”，就是相似的数据所拥有的共同特征，编译器只有知道了数据的类型，才知道怎么操作数据。下⾯盘点⼀下C语⾔提供的各种数据类型，本文主要探讨内置数据类型。
string类的模拟实现(C++)
2302_80190394的博客
08-02 1114
C++ string的功能函数实现
C++——C++11
2303_78442132的博客
08-02 1073
C++11
c++五子棋ai作战如何实现
06-11
实现五子棋AI作战的一种常见方法是使用博弈树和搜索算法，具体实现步骤如下： 1. 在程序中定义一个二维数组表示棋盘，用数字0表示空位，1表示黑棋，2表示白棋。 2. 定义一个函数，接收当前棋盘状态和当前玩家，返回一个估值，即当前状态对当前玩家的优劣程度，例如可以使用评估函数来计算当前状态的估值。 3. 定义一个搜索函数，接收当前棋盘状态、当前玩家、搜索深度等参数，返回一个包含当前最优解的估值和对应的落子坐标。 4. 在搜索函数中，根据当前玩家落子，并递归调用搜索函数来搜索对手所有可能的落子，计算所有结果的估值，返回当前玩家最优解的估值和对应的落子坐标。 5. 在主函数中，循环执行如下步骤： 1）接收用户输入的落子坐标，并将该位置改为当前玩家的棋子数字。 2）判断当前玩家是否获胜，如果获胜则结束游戏。 3）调用搜索函数，获取AI计算的最优解的落子坐标，并将该位置改为AI玩家的棋子数字。 4）判断AI玩家是否获胜，如果获胜则结束游戏。 6. 重复执行5步，直到有一方获胜或者棋盘填满结束游戏。 以上是一种基本的实现思路，具体实现中需要考虑如何实现评估函数、如何选择搜索算法和搜索深度、如何判断胜负等问题。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值