极小化极大算法实现井字棋

最新推荐文章于 2023-11-30 21:47:36 发布
最新推荐文章于 2023-11-30 21:47:36 发布
阅读量4.5k 收藏 57
点赞数 7
文章标签： 算法 深度优先 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54618249/article/details/122391424
版权

Minimax算法

Minimax 算法又叫极小化极大算法，是一种找出失败的最大可能性中的最小值的算法。（维基百科）

alpha-beta 剪枝

Minimax算法中，由于每个节点都是取的极值，所以可以利用这个性质进行剪枝。

以上是简介，下面通过井字棋这个游戏，按照
DFS -> Minimax -> a - b剪枝
这样的顺序进行引导

一、需要解决的问题

井字棋中，我们要做到电脑每一步棋都是下在所有他可以下的位置中对他最有利的位置。
也就是Minimax算法的找出失败的最大可能性中的最小值，换句话也就是找出当前可以做的动作中对自己最有利的动作。

二、DFS -> Minimax

对于井子棋中，当我们考虑这一步应该下在那个位置上的时候，是基于当前局面进行考虑的，所以现在假设当前局面是初始局面，这时候还没有下棋。

那么我们可以下的位置有9个，然后对于我们下的每一种情况，形成一个新的局面，然后到了对方下棋，对于每一个分支在对方看来又有8种情况，又形成很多局面。下面给出部分图示，没有涉及到全部情况：
在这里插入图片描述

那么对于全部的图示，可以形成一颗搜索树，最后的叶子节点就是平局和某一方赢了的全部局面。

那么可以想到，对于上面的图示，是可以用DFS实现的。

虽然DFS可以通过遍历所有情况找到很多条可以使得最后局面达到我方不输或者赢下比赛的路线，但是这是一场博弈，搜索树中牵扯到了对方的下棋位置，对方是不可能配合我们的。

所以我们应该在DFS的同时，求出当前来说我们可以下的所有位置中，对我们最有利的位置，而不是对我们有利的位置中的随便一个位置。

这时候，Minimax算法就能解决这个问题，它在搜索上加上了博弈。
所以
Minimax = 搜索 + 博弈

首先Minimax算法第一步就是规定一下怎样把一个局面映射成一个值，而这个值代表的是对于当前下棋者他到达这个局面的时候的赢面大小。
值越大，赢面越大。
然后我们需要映射的局面只有，最后叶子节点的局面，也就是某一方胜利，或者平局的界面。

以下的规定都是在搜索我方现在应该下棋的位置的基础上：
1.当当前局面为我方胜利的时候，对应的值为空格数 +1
2.当当前局面为对方胜利的时候，对应的值为-(空格数+1)
(因为对方胜利的局面，对于我们来说是极其不利的所以取负数)
3.平局，对应的值为0

当这样规定之后，叶子节点都会对应的一个值。

然后，在上图中可以发现，奇数层是我方在下棋，偶数层是到了对方下棋。

假设现在是在奇数层，并且他的所有子儿子的局面赢面大小值也已经求出来了。
那么奇数层作为我方下棋，并且现在是在搜索我方的位置，所以奇数层的父节点，都会选择各自子儿子节点中的赢面最大的那个局面。

假设现在是偶数层，并且他的所有子儿子的局面赢面大小值也已经求出来了。
由于这个树的根节点是我方下棋的时候，也就是第1层为奇数层，也就代表着，根节点会选择所有子儿子中赢面最大的。那么作为对方肯定会想办法减少我们的赢面值，那么他在每次选择的时候，肯定会选择所有子儿子中赢面最小的，从而达到影响我们最后可以取到的最大值。

那么结论就是:
当为奇数层的时候，选择所有子儿子中的最大值
当为偶数层的时候，选择所有子儿子中的最小值

那么最后我们根节点所有子儿子中最大值对应的那个下法，就是我们在对方极致干扰的情况下，赢面最大的下法。

以上就是Minimax算法的思想
在算法实现的时候，就是DFS的同时，处理奇偶层的取值，和赢面值的返回。

/*

井字棋
OXO
OOO
OOO

X代表玩家,O代表电脑 

从左上角开始编一维下标为0 ~ 8,二维下标为(0,0)~(2,2) 
一维位置转化成2维公式

设t为1维下标,(x,y)为2维下标 
x = t / 3,y = t % 3
t = x * 3 + y; 

*/

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <algorithm>

using namespace std;

char board[3][3];//棋盘
int player;//记录当前是玩家还是电脑在下棋,0代表玩家,1代表电脑  

void init()//初始化棋盘
{
	for(int i = 0;i < 3;i ++)
		for(int j = 0;j < 3;j ++) board[i][j] = '_';	
} 

void draw_board()//画棋盘
{
	system("cls");
	for(int i = 0;i < 3;i ++)
	{
		for(int j = 0;j < 3;j ++)
		printf("%c ",board[i][j]);
		puts("");
	}
} 

int is_Win()//判断谁赢了
{
	for(int i = 0;i < 3;i ++) //判断行列 
	{
		int x = board[i][0] != '_' && board[i][0] == board[i][1] && board[i][1] == board[i][2];//行 
		int y = board[0][i] != '_' && board[0][i] == board[1][i] && board[1][i] == board[2][i];//列
		if(x) return (board[i][0] == 'X' ? 0 : 1);
		if(y) return (board[0][i] == 'X' ? 0 : 1); 
	}
	
	if(board[0][0] == 'X' && board[1][1] == 'X' && board[2][2] == 'X' || board[0][2] == 'X' && board[1][1] == 'X' && board[2][0] == 'X') return 0;
	if(board[0][0] == 'O' && board[1][1] == 'O' && board[2][2] == 'O' || board[0][2] == 'O' && board[1][1] == 'O' && board[2][0] == 'O') return 1;
	
	return -1;
} 

int eval()//评估函数,当电脑赢的时候，评估为空格数+1,玩家赢的时候评估为-空格数-1,平局的时候为0 
{
	int res = 0;
	for(int i = 0;i < 3;i ++)
		for(int j = 0;j < 3;j ++)	
			if(board[i][j] == '_') res ++;
	
	int flag = is_Win();
	if(flag == 1) return res + 1;
	if(flag == 0) return -(res + 1);
	if(flag == -1) return 0;
}

int MinMaxSearch(int &idx,int step)//step用来记录层数,奇数层为电脑操作,偶数层为玩家操作  
{
	int val;//极值
	if(step & 1) val = -100;//奇数层取极大值 
	else val = 100;//偶数层取极小值
	
	if(is_Win() >= 0) return eval(); //有一方赢了 
	
	vector<int> positions;//记录还有那些位置可以下棋
	for(int i = 0;i < 3;i ++)
		for(int j = 0;j < 3;j ++)	
			if(board[i][j] == '_') positions.push_back(i * 3 + j); 
	
	if(positions.size() == 0) return eval();//平局的情况 
	
	for(int i = 0;i < positions.size();i ++)
	{
		int x = positions[i];
		int t = x;
		board[x / 3][x % 3] = (step & 1) ? 'O' : 'X';
		int Sonval = MinMaxSearch(x,step + 1);
		board[t / 3][t % 3] = '_';
		
		if(step & 1) 
		{
			if(val < Sonval)
			{
				val = Sonval;
				if(step == 1) idx = positions[i];
			}
		}
		else 
		{
			if(val > Sonval) 
			{
				val = Sonval;
			}
		}
	}
	return val;
}
/*
int MinMaxSearch(int &idx,int step,int a,int b)//剪枝版本,a代表最大下限,b代表最大上限 
{
	if(is_Win() >= 0) return eval(); //有一方赢了 
	
	vector<int> positions;//记录还有那些位置可以下棋
	for(int i = 0;i < 3;i ++)
		for(int j = 0;j < 3;j ++)	
			if(board[i][j] == '_') positions.push_back(i * 3 + j); 
	
	if(positions.size() == 0) return eval();//平局的情况 
	
	for(int i = 0;i < positions.size();i ++)
	{
		int x = positions[i];
		int t = x;
		board[x / 3][x % 3] = (step & 1) ? 'O' : 'X';
		int Sonval = MinMaxSearch(x,step + 1,a,b);
		board[t / 3][t % 3] = '_';
		
		if(step & 1) 
		{
			if(a < Sonval)
			{
				a = Sonval;
				if(step == 1) idx = positions[i];
				if(a >= b) break;
			}
		}
		else 
		{
			if(b > Sonval) 
			{
				b = Sonval;
				if(a >= b) break;
			}
		}
	}
	if(step & 1) return a;
	else return b;
}
*/
void com_play()
{
	int x;//电脑下的位置
	MinMaxSearch(x,1);
	//MinMaxSearch(x,1,-100,100);//a - b剪枝 
	board[x / 3][x % 3] = 'O';
}

int main()
{
	while(1)
	{
		init();
		system("cls");
		printf("请输入先手,0代表玩家,1代表电脑\n");
		printf("请输入你的选择:");
		scanf("%d",&player);
	
		int i;
		for(i = 1;i <= 9;i ++)
		{
		
			if(player & 1)//电脑下棋 
			{
				com_play();
				draw_board();
			}
			else //玩家下棋
			{
				draw_board();
				printf("请输入需要下的位置,棋盘从左上角开始编号为1~9:");
				printf("请输入你的选择:");
				int x;
				scanf("%d",&x);
				x -= 1;
				if(x < 0 || x > 8 || board[x / 3][x % 3] != '_')
				{
					do
					{
						printf("该位置不能下，请另选一个\n");
						printf("请输入你的选择:");
						scanf("%d",&x);
						x -= 1;
					}while(x < 0 || x > 8 || board[x / 3][x % 3] != '_');
				}
				board[x / 3][x % 3] = 'X';
			} 
			player ^= 1;//改变操作对象 
			
			int Winer = is_Win();//看是否有人赢了
			if(Winer >= 0)
			{
				draw_board();
				if(Winer) printf("电脑赢了\n");
				else printf("你赢了\n");
				break;	
			} 
		}
		if(i >= 9) 
		{
			draw_board();
			printf("平局\n");
		}
		printf("是否继续,1代表继续,0代表不玩了\n");
		int op;
		scanf("%d",&op);
		if(!op) break;
	}
	return 0;	
}

Minimax -> a - b剪枝

可以发现，Minimax算法中遍历了从当前局面开始的所有局面情况，所以当应用到其他情况多的博弈中的时候时间复杂度太高了。

a-b剪枝就是在利用Minimax算法中每一个节点都是对应的是他所有子儿子的极值的这个性质，来进行剪枝的。

当进行Minimax算法的时候，当我们知道所有子儿子的值后，可以得出该父节点的值。
但是如果只知道部分子儿子的节点值的时候， 虽然得不到该节点的准确值，但是可以得到该节点的取值范围

以奇数层为例子，偶数层类似分析
给每个节点设立一个a,b
表示这个节点取值的最大下限和最小上限

当奇数层节点的部分子儿子计算出来后，因为奇数层节点取的是最大值，所以 它的a会发生变化，值为计算出来的子儿子中的最大值。

那么在计算其他子儿子的时候，把a传下去
当a传下去之后，在计算子儿子的时候，就是偶数层了，那么计算出部分子儿子的子儿子后，子儿子的b会更新，当在这个子儿子上出现a>=b后，就可以不用继续计算这个子儿子还没有算出来的子儿子了，因为他的父节点取值>=a,而这个子儿子取值<=b。

/*

井字棋
OXO
OOO
OOO

X代表玩家,O代表电脑 

从左上角开始编一维下标为0 ~ 8,二维下标为(0,0)~(2,2) 
一维位置转化成2维公式

设t为1维下标,(x,y)为2维下标 
x = t / 3,y = t % 3
t = x * 3 + y; 

*/

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <algorithm>

using namespace std;

char board[3][3];//棋盘
int player;//记录当前是玩家还是电脑在下棋,0代表玩家,1代表电脑  

void init()//初始化棋盘
{
	for(int i = 0;i < 3;i ++)
		for(int j = 0;j < 3;j ++) board[i][j] = '_';	
} 

void draw_board()//画棋盘
{
	system("cls");
	for(int i = 0;i < 3;i ++)
	{
		for(int j = 0;j < 3;j ++)
		printf("%c ",board[i][j]);
		puts("");
	}
} 

int is_Win()//判断谁赢了
{
	for(int i = 0;i < 3;i ++) //判断行列 
	{
		int x = board[i][0] != '_' && board[i][0] == board[i][1] && board[i][1] == board[i][2];//行 
		int y = board[0][i] != '_' && board[0][i] == board[1][i] && board[1][i] == board[2][i];//列
		if(x) return (board[i][0] == 'X' ? 0 : 1);
		if(y) return (board[0][i] == 'X' ? 0 : 1); 
	}
	
	if(board[0][0] == 'X' && board[1][1] == 'X' && board[2][2] == 'X' || board[0][2] == 'X' && board[1][1] == 'X' && board[2][0] == 'X') return 0;
	if(board[0][0] == 'O' && board[1][1] == 'O' && board[2][2] == 'O' || board[0][2] == 'O' && board[1][1] == 'O' && board[2][0] == 'O') return 1;
	
	return -1;
} 

int eval()//评估函数,当电脑赢的时候，评估为空格数+1,玩家赢的时候评估为-空格数-1,平局的时候为0 
{
	int res = 0;
	for(int i = 0;i < 3;i ++)
		for(int j = 0;j < 3;j ++)	
			if(board[i][j] == '_') res ++;
	
	int flag = is_Win();
	if(flag == 1) return res + 1;
	if(flag == 0) return -(res + 1);
	if(flag == -1) return 0;
}
/*
int MinMaxSearch(int &idx,int step)//step用来记录层数,奇数层为电脑操作,偶数层为玩家操作  
{
	int val;//极值
	if(step & 1) val = -100;//奇数层取极大值 
	else val = 100;//偶数层取极小值
	
	if(is_Win() >= 0) return eval(); //有一方赢了 
	
	vector<int> positions;//记录还有那些位置可以下棋
	for(int i = 0;i < 3;i ++)
		for(int j = 0;j < 3;j ++)	
			if(board[i][j] == '_') positions.push_back(i * 3 + j); 
	
	if(positions.size() == 0) return eval();//平局的情况 
	
	for(int i = 0;i < positions.size();i ++)
	{
		int x = positions[i];
		int t = x;
		board[x / 3][x % 3] = (step & 1) ? 'O' : 'X';
		int Sonval = MinMaxSearch(x,step + 1);
		board[t / 3][t % 3] = '_';
		
		if(step & 1) 
		{
			if(val < Sonval)
			{
				val = Sonval;
				if(step == 1) idx = positions[i];
			}
		}
		else 
		{
			if(val > Sonval) 
			{
				val = Sonval;
			}
		}
	}
	return val;
}*/

int MinMaxSearch(int &idx,int step,int a,int b)//剪枝版本,a代表最大下限,b代表最大上限 
{
	if(is_Win() >= 0) return eval(); //有一方赢了 
	if(step & 1) a = -100;
	else b = 100;
	
	vector<int> positions;//记录还有那些位置可以下棋
	for(int i = 0;i < 3;i ++)
		for(int j = 0;j < 3;j ++)	
			if(board[i][j] == '_') positions.push_back(i * 3 + j); 
	
	if(positions.size() == 0) return eval();//平局的情况 
	
	for(int i = 0;i < positions.size();i ++)
	{
		int x = positions[i];
		int t = x;
		board[x / 3][x % 3] = (step & 1) ? 'O' : 'X';
		int Sonval = MinMaxSearch(x,step + 1,a,b);
		board[t / 3][t % 3] = '_';
		
		if(step & 1) 
		{
			if(a < Sonval)
			{
				a = Sonval;
				if(step == 1) idx = positions[i];
				if(a >= b) break;
			}
		}
		else 
		{
			if(b > Sonval) 
			{
				b = Sonval;
				if(a >= b) break;
			}
		}
	}
	if(step & 1) return a;
	else return b;
}

void com_play()
{
	int x;//电脑下的位置
//	MinMaxSearch(x,1);
	MinMaxSearch(x,1,-100,100);//a - b剪枝 
	board[x / 3][x % 3] = 'O';
}

int main()
{
	while(1)
	{
		init();
		system("cls");
		printf("请输入先手,0代表玩家,1代表电脑\n");
		printf("请输入你的选择:");
		scanf("%d",&player);
	
		int i;
		for(i = 1;i <= 9;i ++)
		{
		
			if(player & 1)//电脑下棋 
			{
				com_play();
				draw_board();
			}
			else //玩家下棋
			{
				draw_board();
				printf("请输入需要下的位置,棋盘从左上角开始编号为1~9:");
				printf("请输入你的选择:");
				int x;
				scanf("%d",&x);
				x -= 1;
				if(x < 0 || x > 8 || board[x / 3][x % 3] != '_')
				{
					do
					{
						printf("该位置不能下，请另选一个\n");
						printf("请输入你的选择:");
						scanf("%d",&x);
						x -= 1;
					}while(x < 0 || x > 8 || board[x / 3][x % 3] != '_');
				}
				board[x / 3][x % 3] = 'X';
			} 
			player ^= 1;//改变操作对象 
			
			int Winer = is_Win();//看是否有人赢了
			if(Winer >= 0)
			{
				draw_board();
				if(Winer) printf("电脑赢了\n");
				else printf("你赢了\n");
				break;	
			} 
		}
		if(i >= 9) 
		{
			draw_board();
			printf("平局\n");
		}
		printf("是否继续,1代表继续,0代表不玩了\n");
		int op;
		scanf("%d",&op);
		if(!op) break;
	}
	return 0;	
}
xhxhxxh_
关注
井字游戏：Mini使用Minimax算法的井字游戏无与伦比
03-03
为了使传统的Tic Tac Toe游戏无与伦比，有必要创建一种算法，该算法可以计算出计算机可用的所有可能动作，并可以使用该算法来确定最佳动作。 介绍 为了使用AI解决游戏，我们将介绍Game Tree的概念以及Minimax算法。 该算法向前迈出了几步，并将其置于对手的视线中。 它一直保持前进，直到到达棋盘的终端排列（终端状态），导致并列，获胜或失败。 一旦处于最终状态，AI将为获胜分配一个任意的正分数（+10），为失败分配一个负的分数（-10），或为平局分配一个中性分数（0）。 同时，该算法会根据玩家的回合来评估导致最终状态的移动。 轮到AI时，它将选择得分最高的举动，而当轮到AI时，它将选择得分最低的举动。 使用这种策略，Minimax可以避免输给人类玩家。 什么是Minimax？ Minimax （有时是MinMax，MM或鞍点）是人工智能，决策理论，博弈论，统计数据和哲学中使用
极小极大算法实现井字棋AI
01-14
井子棋是棋类中最简单的一种，通常作为算法的练手项目，该资源使用极小极大算法实现了一个井字棋的人机对弈，只需运行资源里的play_to_bot就可以在命令行里与AI对弈了，可以肯定的是你绝对不可能战胜它。虽然实现它比较容易，但是麻雀虽小，五脏俱全，棋类的基本框架类似，你可以在学习这个之后迁移到其他棋类
理解极小极大搜索算法
热门推荐
斌斌(Java)
02-28 1万+
Understanding The Minimax Algorithm-理解极小极大搜索算法          One of the most interesting avenues of computerscience is that of programming a computer to play a game against a humanopponent. Exampl
有趣的代码——井字棋游戏的实现
最新发布
m0_74950144的博客
11-30 1820
前面我们讲解过一个猜数字游戏的实现，想来应该让大家感受到了属于编程的趣味性，并且在实现过程中应该也收获了知识。但猜数字这种简单的游戏肯定满足不了大家对于游戏的高标准、严要求，估计玩不了多久就会没有兴趣了，所以，今天在这里和大家分享一个更好玩，也更有实现难度的小游戏——井字棋！实际上在C语言中，我们根据程序文件的数量，可以将C语言程序分为单文件程序和多文件程序，单文件程序就是所有程序代码都在一个源程序文件中，多文件程序中通常包含一个或多个自定义头文件和一个或多个源程序文件。
极大极小搜索-----不太傻的井字棋
cprimesplus的博客
07-30 3474
1.说明： 这是学极大极小搜索的第二（三）天，昨天因为思路较为混乱，且对评估函数不甚了解，因此自己写出来的AI井字棋宛若ZZ，不过仔细查看了学长的PPT并且钻研了一番，总算对Minimax算法有了比较细致的理解，在参考了一个大神的博客后，我有了新的想法，于是重新打了一遍。 2.我对极大极小搜索的理解： 所谓极大极小搜索，是相对于一个对象而言、考虑两个对象的最佳招法的一种算法。 对于写的AI...
井字棋游戏——极大极小算法实现
07-23
dos环境下的小游戏，本人初学C++，给其他初学者一些提示和帮助，利用的是极大极小算法，人工智能可能有所需要
简单的极大极小算法实现的井字棋程序
01-14
简单的极大极小算法实现的井字棋程序 用于Windows系统下的VC++6.0编译器，在高版本VS上运行可能会出错
【算法】极小极大值搜索算法MinimaxSearch————井字棋的应用
weixin_45781252的博客
11-26 6864
极小极大值搜索算法MinimaxSearch 算法描述 极小极大值搜索算法，MinimaxSearch算法，是一种零和算法，是用来最小化对手的利益，最大化自己的利益的算法。 极小极大之搜索算法常用于棋类游戏等双方较量的游戏和程序，算是一种电脑AI算法。 该算法是一种总零和算法，即双方的利益对立，利益的总和为0。比如在井字棋中，总利益为0，以玩家A的视角看，A取得胜利获得的利益是1，则B在A获得胜利的情况下获得的利益则为-1，反之亦然，双方的利益总和为0。 棋类游戏是双方交替下棋的游戏，每一次落子都代表落子的
井字棋 tictactoe 极大极小算法 α-β剪枝算法【python】
Jing_HJY的博客
11-29 1万+
文章目录一、 实验内容二、 极大极小算法和α-β剪枝算法总结1.极大极小算法2.α-β剪枝三、 实验步骤以及结果1.极大极小算法完成井字棋游戏2.α-β剪枝四、 结果、反思与分析1.极大极小算法运行结果、发现的问题与解决方式2.α-β剪枝运行结果、发现的问题与解决方式3.极大极小算法和α-β剪枝的比较总结 一、 实验内容 实验利用极大极小算法和α-β剪枝算法完成对井字游戏的实现。 大家首先下载对应代码；另外需要安装pygame库；pipinstall pygame 项目中主要包含两个文件 runner.
极小值极大值算法-井字棋
无
08-24 1万+
用极小值极大值算法写的井字棋： #include #include #define COM -1 #define MAN 1 #define STEP 9 #define DRAW 0 #define ROW 3 #define COL 3 #define MAX_NUM 1000; struct Move { int x; int y; }; //棋盘 int boar
minimax:井字棋游戏中极小极大算法的 LISP 实现
06-22
极小极大 井字棋游戏中极小极大算法的 LISP 实现 我为我的 AI 入门课程编写了这段代码。 它使用极小极大算法实现井字棋游戏。 它没有任何类型的图形界面。
基于minmax算法的井字棋AI设计（python）（带UI设计）
10-22
基于minmax算法的井字棋AI设计（python）（带UI设计）
井字棋算法
12-06
关于井字棋的算法，为大家提供，可以在其他地方找找
井字棋（三连棋）的AI实现，C/C++
10-10
井字棋的AI实现（完整包）无界面 创建TicTacToe类，使你可以编写一个完整的三连棋游戏程序。这个类包含一个作为private数据的3*3的二维整数数组。构造函数应将空棋盘初始化为0。允许两个人玩游戏。无论第一个人移动到哪里，都在指定的棋格中放置1，无论第二个人移动到哪里，都在指定的棋格中放置2。每次移动都必须到达一个空格。在每次移动后，确定是否已分胜负，还是出现了平局。此外，必须让玩家决定谁先走说后走。开发一个人机大战游戏。
代码井字棋 tictactoe 极大极小算法 α-β剪枝算法python
11-29
在这个项目中，我们关注的是如何用Python实现井字棋，并应用极大极小算法和α-β剪枝来让计算机自动玩这个游戏。极大极小算法是一种用于二玩家零和游戏中（即一方赢则另一方输）的决策策略，它模拟了对手的最佳响应...
井字棋java
05-26
此外，由于井字棋游戏的搜索空间相对较小，极大极小算法的实现可能不会涉及剪枝优化，但在更复杂的游戏中，剪枝技术（如阿尔法-贝塔剪枝）是必不可少的，以减少搜索的时间复杂度。 最后，由于提到可以轻松将此Java...
基于极大极小分析法的井字棋对弈.doc
09-25
通过上述分析，我们可以看到，基于极大极小分析法的井字棋程序不仅能够实现基本的游戏功能，还能通过智能决策算法提供一定的挑战性。这种技术不仅限于井字棋，还可以应用于更复杂的游戏环境，为开发更加智能的游戏AI...
机器学习-井字棋-极大极小值算法
小王子博客
10-24 6021
游戏规则:双方轮流放子,当某一方的三个子连成一线(行,列,对角)时,该方获胜。 程序设计思想 首先选择先手的玩家，如果选择“X”表示“玩家”先手，如果选择“O”表示“电脑”先手，如果输入错误就会默认“玩家”先手。 我们通过（0-8）的数字表示棋盘上的位置，“玩家”和“电脑”会轮流下棋，如果一方获得胜利，或者平局的时候（棋盘上没有空位置）就结束。当轮到“玩家”下棋，就让玩家自己输入（0-8）的数字，但是要求不能输入棋盘上已经有棋子的位置，否则就让玩家重新输入，如果轮到“电脑”下棋，那么就.
minimax算法（井子棋）
qq_36532060的博客
07-25 1829
minimax算法（以井字棋为例）
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值