C语言实现极小极大搜索算法五子棋

最新推荐文章于 2025-07-07 10:11:24 发布
最新推荐文章于 2025-07-07 10:11:24 发布
阅读量7.1k 收藏 135
点赞数 18
CC 4.0 BY-SA版权
文章标签： C语言 五子棋 极小极大搜索算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44671353/article/details/87893598
本文深入探讨了如何使用极小极大搜索算法结合α-β剪枝优化来实现五子棋的人工智能对战系统。文章详细介绍了算法原理、棋子生成策略、局面评估方法及C语言代码实现。

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

C语言实现极小极大搜索算法五子棋


本人只是一名大二学生，技术有限，代码比较乱，希望指正，这也是我第一次写博客，排版也不好，见谅。

极小极大算法

不管是什么棋类，看似很复杂，但都可以把每一种走法列出来，列出来后，你就可以发现，它就是一颗博弈树。所以我们可以用极小极大搜索算法来实现五子棋。

极小极大算法博弈树的生成，每一层分为MAX层或MIN层，如图（图片来自百度），第0层为当前局面，MAX层生成的走法即为下一层的MIN层，除第0层，其他MAX层为上一层MIN层的走法，MIN层也为上一层MAX层的走法。

在这里插入图片描述
极小极大搜索算法分数的传递，在MAX层中，为了MAX层利益的极大化，会从下一层选择最大的分数，而在MIN层中，为了对手利益的最小化，会从下一层选择分数最小。

分数的传递可以使用递归来实现

int minMax(int co[20][20],int deep,int a,int Alpha,int Beta)
//分数传递,a为1表示白棋，为2表示黑棋,调用时Alpha，Beta赋为NGIF,PTIF
{
	int i,j;
	int c[20][20];
	int minmax;
	int b;
	int n=1;
	Tree tree;
	tree.data=NGIF;
	tree.Alpha=Alpha;
	tree.Beta=Beta;
	tree.X=0;
	tree.Y=0;
	if(a==1)
		b=2;
	else
		b=1;
	if(deep>0)
	{
		for(i=0;i<20;i++)
			for(j=0;j<20;j++)
			{
				if(co[i][j]==0&&jdgen(co,i,j,1)&&tree.Alpha<tree.Beta)//α-β剪枝
				{
					memcpy(c,co,sizeof(int)*400);
					c[i][j]=a;
					minmax=minMax(c,deep-1,b,tree.Alpha,tree.Beta);//递归调用
					if(deep%2==0)
					{
						if(n==1)
						{
							tree.data=minmax;
							n++;
						}
						if(tree.Alpha<minmax)
						{
							tree.Alpha=minmax;
							tree.data=minmax;
							tree.X=i;
							tree.Y=j;
						}
					}
					else
					{
						if(n==1)
						{
							tree.data=minmax;
							n++;
						}
						if(tree.Beta>minmax)
						{
							tree.Beta=minmax;
							tree.data=minmax;
							tree.X=i;
							tree.Y=j;
						}
					}
				}
			}
		for(i=0;i<20;i++)
			for(j=0;j<20;j++)
			{
				if(co[i][j]==0&&jdgen(co,i,j,2)&&tree.Alpha<tree.Beta)//α-β剪枝
				{
					memcpy(c,co,sizeof(int)*400);
					c[i][j]=a;
					minmax=minMax(c,deep-1,b,tree.Alpha,tree.Beta);//递归调用
					if(deep%2==0)
					{
						if(tree.Alpha<minmax)
						{
							tree.Alpha=minmax;
							tree.data=minmax;
							tree.X=i;
							tree.Y=j;
						}
					}
					else
					{
						if(tree.Beta>minmax)
						{
							tree.Beta=minmax;
							tree.data=minmax;
							tree.X=i;
							tree.Y=j;
						}
					}
				}
			}
		X=tree.X;
		Y=tree.Y;
		return tree.data;
	}
	else
	{
		return score(a,co,1);//局面评分
	}
}

α-β剪枝

由五子棋生成的博弈树及其庞大，如果不对它进行优化，它能搜索的层数就及其有限，α-β剪枝能够去掉一些用处不大的走法，以提高运行的速度。

α-β剪枝的实现，博弈树中每一个节点都有一个α和β，初始设置α为负无穷大，β为正无穷大。对于MAX层，为了是自己利益最大化，会从下一层选择最大的分数，当传递上来的分数大于α时，则修改α值为此分数。对于MIN层，为了使对手利益最小化，会从下一层选择最小分数，当分数小于β，则修改β值，当每一个节点要生成下一步棋子时，先判断α与β，如果α>β，则不用在生成下一步的走法，而是返回上一层。

详情可移步 Alpha-Beta剪枝(Alpha Beta Pruning)

棋子生成

棋子生成函数可以生成下一步可走的走法，对于整个棋盘，如果每一个可以落子的地方都要生成棋子，那运行速度将会非常慢，搜索深度会非常有限，这一步也是对程序优化的重要部分。事实上不是每一个空位都要搜索，有一个比较简单的做法，就是只搜索有棋子的邻居空位，即只需搜索两步之内有棋子的空位，如图红色区域。
在这里插入图片描述

int jdgen(int co[20][20],int x,int y,int n)
//判断x，y坐标是否可生成棋子，可以返回1，否则返回0,n为1，判断内侧棋子，为2，判断外侧棋子
{
	int i,j;
	int sum=0;
	if(n==1)
	{
		for(i=x-1;i<x+2;i++)
			for(j=y-1;j<y+2;j++)
				if((i>0&&j>0&&i<20&&j<20)&&(co[i][j]==1||co[i][j]==2))
					sum=1;
	}
	else
	{
		for(i=x-2;i<x+3;i+=2)
			for(j=y-2;j<y+3;j+=2)
				if((i>0&&j>0&&i<20&&j<20)&&(co[i][j]==1||co[i][j]==2))
					sum=1;
	}
	return sum;
}

局面分数评估

极小极大搜索的分数，来自最后一层对局面的评估。这一步我们也采用比较简单的一种做法。评分规则：活一10，活二100，活三1000，活四10000，活五100000。死二10，死三100，死四1000。如果连子两侧没有被堵死，则称为活，如果只堵死一侧，称为死，如果都被堵死，则没有分数。
将机器的棋子进行单独打分，在减去对手棋子单独打分，即为最终局面的分数。

// 评分函数
int score(int a,int co[20][20],int n)   
//评分,a为1表示白棋，为2表示黑棋,n为1避免递归调用出现死循环
{	
	int i,j,k,l;
	int sum=0,su=0;
	for(i=0;i<20;i++)                //点
		for(j=0;j<20;j++)
			if(co[i][j]==a)
			{
				for(k=i-1;k<i+2;k++)
					for(l=j-1;l<j+2;l++)
						su+=co[k][l];
				if(su==a&&i!=0&&i!=19&&j!=0&&j!=19)
					sum+=10;
				su=0;
			}
	su=0;
	for(i=0;i<20;i++)                  //横
		for(j=0;j<21;j++)
		{
			if(co[i][j]==a)
				su++;
			else if(su>1)
			{
				if(co[i][j-su-1]==0&&co[i][j]==0)
				{
					sum+=pow(10,su);
				}
				else if(co[i][j-su-1]!=0&&co[i][j]!=0)
				{
					if(su==5)
						sum+=100000;
				}
				else
				{
					if(su==5)
						sum+=100000;
					else
						sum+=pow(10,su-1);
					
				}
				su=0;
			}
			else
				su=0;
		}
	for(su=0,i=0;i<20;i++)              //竖
		for(j=0;j<21;j++)
		{
			if(co[j][i]==a)
				su++;
			else if(su>1)
			{
				if(co[j-su-1][i]==0&&co[j][i]==0)
				{
					sum+=pow(10,su);
				}
				else if(co[j-su-1][i]!=0&&co[j][i]!=0)
				{
					if(su==5)
						sum+=100000;
				}
				else
				{
					if(su==5)
						sum+=100000;
					else
						sum+=pow(10,su-1);
				}
				su=0;
			}
			else
				su=0;
		}
	for(su=0,i=-19;i<20;i++)              //╱
		for(j=i,k=19;j<20;j++,k--)
			if(j>=0&&j<20&&k>=0&&k<20)
			{
				if(co[j][k]==a)
					su++;
				else if(su>1)
				{
					if(co[j-su-1][k+su+1]==0&&co[j][k]==0)
					{
						sum+=pow(10,su);
					}
					else if(co[j-su-1][k+su+1]!=0&&co[j][k]!=0)
					{
						if(su==5)
							sum+=100000;
					}
					else
					{
						if(su==5)
							sum+=100000;
						else
							sum+=pow(10,su-1);
					}
					su=0;
				}
				else
					su=0;
			}
	for(su=0,i=-19;i<20;i++)                    //╲
		for(j=i,k=0;j<20;j++,k++)
			if(j>=0&&j<20&&k>=0&&k<20)
			{
				if(co[j][k]==a)
					su++;
				else if(su>1)
				{
					if(co[j-su-1][k-su-1]==0&&co[j][k]==0)
					{
						sum+=pow(10,su);
					}
					else if(co[j-su-1][k-su-1]!=0&&co[j][k]!=0)
					{
						if(su==5)
							sum+=100000;
					}
					else
					{
						if(su==5)
							sum+=100000;
						else
						sum+=pow(10,su-1);
					}
					su=0;
				}
				else
					su=0;
			}
	if(n==1&&a==1)
		return sum-score(2,co,2);
	else if(n==1&&a==2)
		return sum-score(1,co,2);
	else if(n==2)
		return sum;
}

程序代码

// wuziqi.c

#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
int coord[20][20];//白棋为1，黑棋为2
extern int* human();
extern int* conputer(int x);

static void gotoxy(int x,int y)
{
	COORD pos={x,y};
	HANDLE hOut=GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleCursorPosition(hOut,pos);
}
static void board(int co[20][20])                   //棋盘:输出棋盘网格
{
	int i,j;
	gotoxy(0,0);puts("┏ ━");
	gotoxy(0,42);puts("┗ ━");
	gotoxy(84,0);puts("┓");
	gotoxy(84,42);puts("┛");
	for(i=1;i<21;i++)         
		for(j=1;j<21;j++)
		{
			gotoxy(j*4,2*i-1);puts("┃");
			gotoxy(j*4,i*2);puts("╋ ━");
		}
	for(i=1;i<22;i++)
	{
		gotoxy(0,i*2-1);puts("┃");
		gotoxy(84,i*2-1);puts("┃");
	}
	for(i=1;i<21;i++)
	{
		gotoxy(i*4,0);puts("┳ ━");
		gotoxy(i*4,42);puts("┻ ━");
		gotoxy(i*4,41);puts("┃");
		gotoxy(2,i*2);puts("━");
		gotoxy(0,i*2);puts("┣");
		gotoxy(84,i*2);puts("┫");
	}
	for(i=0;i<20;i++)
		for(j=0;j<20;j++)
			coord[i][j]=0;
}
static void chess(int x,int y,int a)         
//下棋:a为1表示白棋下，为2表示黑棋下，输入x，y和a后向棋盘输出棋子并对coord赋值
{
	if(a==1&&coord[x][y]==0)
	{
		gotoxy((y+1)*4,(x+1)*2);puts("●");
		coord[x][y]=1;
	}
	else if(a==2&&coord[x][y]==0)
	{
		gotoxy((y+1)*4,(x+1)*2);puts("○");
		coord[x][y]=2;
	}
}
void location(int x,int y)                    // 定位
{
	gotoxy((y+1)*4-2,(x+1)*2-1);puts("┛");
	gotoxy((y+1)*4+2,(x+1)*2-1);puts("┗");
	gotoxy((y+1)*4-2,(x+1)*2+1);puts("┓");
	gotoxy((y+1)*4+2,(x+1)*2+1);puts("┏");
}
void clearlocation(int x,int y)                 //清除定位
{
	gotoxy((y+1)*4-2,(x+1)*2-1);puts("  ");
	gotoxy((y+1)*4+2,(x+1)*2-1);puts("  ");
	gotoxy((y+1)*4-2,(x+1)*2+1);puts("  ");
	gotoxy((y+1)*4+2,(x+1)*2+1);puts("  ");
}
static int overgame(int x,int y,int a)          
//判断输赢:a为1表示白棋胜，2表示黑棋胜，x，y表示当前下子,如果一方获胜返回1，否则返回0
{
	int i,j,sum;
	for(sum=0,j=y-4;j<y+5;j++)//横
	{
		if(sum>4)
			break;
		else if(coord[x][j]!=a)
			sum=0;
		else
			sum++;
	}
	if(sum==5)
	{
		gotoxy(86,1);
		if(a==1)
			puts("白棋胜，按任意键退出");
		else if(a==2)
			puts("黑棋胜，按任意键退出");
		return 1;
	}
	for(sum=0,i=x-4;i<x+5;i++)//竖
	{
		if(sum>4)
			break;
		else if(coord[i][y]!=a)
			sum=0;
		else
			sum++;
	}
	if(sum==5)
	{
		gotoxy(86,1);
		if(a==1)
			puts("白棋胜，按任意键退出");
		else if(a==2)
			puts("黑棋胜，按任意键退出");
		return 1;
	}
	for(sum=0,i=x-4,j=y-4;i<x+5&&j<y+5;i++,j++)//╲
	{
		if(sum>4)
			break;
		else if(coord[i][j]!=a)
			sum=0;
		else
			sum++;
	}
	if(sum==5)
	{
		gotoxy(86,1);
		if(a==1)
			puts("白棋胜，按任意键退出");
		if(a==2)
			puts("黑棋胜，按任意键退出");
		return 1;
	}
	for(sum=0,i=x-4,j=y+4;i<x+5&&j>y-5;i++,j--)//╱
	{
		if(sum>4)
			break;
		else if(coord[i][j]!=a)
			sum=0;
		else
			sum++;
	}
	if(sum==5)
	{
		gotoxy(86,1);
		if(a==1)
			puts("白棋胜，按任意键退出");
		if(a==2)
			puts("黑棋胜，按任意键退出");
		return 1;
	}
	return 0;
}
static void control(int *p,int a)   
//控制p1，p2玩家落子，p1（），p2（）返回值转给p，a为1表示白棋下，为2表示黑棋下
{
	static int x,y;
	chess(p[0],p[1],a);
	location(p[0],p[1]);
	clearlocation(x,y);
	x=p[0];
	y=p[1];
	if(overgame(p[0],p[1],a)==1)
	{
		gotoxy(86,0);
		exit(0);
	}
}
int main()
{
	int x,n;
	printf("输入搜索深度(输入偶数,例:2,4,6,搜索深度越深,程序运行越慢):");
	scanf("%d",&x);
	printf("先手按1,后手按2:");
	scanf("%d",&n);
	gotoxy(0,0);
	puts("                                                                 ");
	gotoxy(0,1);
	puts("                                                    ");
	board(coord);
	while(1)
	{
		if(n==1){
			control(human(),1);
			control(computer(x),2);
		}
		if(n==2){
			control(computer(x),1);
			control(human(),2);
		}
	}
}

// MINMAX.c
#include<math.h>
#include<string.h>
#define PTIF 2147483647//正无穷,Beta
#define NGIF -2147483648//负无穷,Alpha
int X,Y;
extern int coord[20][20];
int score(int a,int co[20][20],int n)   
//评分,a为1表示白棋，为2表示黑棋,n为1避免递归调用出现死循环
{	
	int i,j,k,l;
	int sum=0,su=0;
	for(i=0;i<20;i++)                //点
		for(j=0;j<20;j++)
			if(co[i][j]==a)
			{
				for(k=i-1;k<i+2;k++)
					for(l=j-1;l<j+2;l++)
						su+=co[k][l];
				if(su==a&&i!=0&&i!=19&&j!=0&&j!=19)
					sum+=10;
				su=0;
			}
	su=0;
	for(i=0;i<20;i++)                  //横
		for(j=0;j<21;j++)
		{
			if(co[i][j]==a)
				su++;
			else if(su>1)
			{
				if(co[i][j-su-1]==0&&co[i][j]==0)
				{
					sum+=pow(10,su);
				}
				else if(co[i][j-su-1]!=0&&co[i][j]!=0)
				{
					if(su==5)
						sum+=100000;
				}
				else
				{
					if(su==5)
						sum+=100000;
					else
						sum+=pow(10,su-1);
					
				}
				su=0;
			}
			else
				su=0;
		}
	for(su=0,i=0;i<20;i++)              //竖
		for(j=0;j<21;j++)
		{
			if(co[j][i]==a)
				su++;
			else if(su>1)
			{
				if(co[j-su-1][i]==0&&co[j][i]==0)
				{
					sum+=pow(10,su);
				}
				else if(co[j-su-1][i]!=0&&co[j][i]!=0)
				{
					if(su==5)
						sum+=100000;
				}
				else
				{
					if(su==5)
						sum+=100000;
					else
						sum+=pow(10,su-1);
				}
				su=0;
			}
			else
				su=0;
		}
	for(su=0,i=-19;i<20;i++)              //╱
		for(j=i,k=19;j<20;j++,k--)
			if(j>=0&&j<20&&k>=0&&k<20)
			{
				if(co[j][k]==a)
					su++;
				else if(su>1)
				{
					if(co[j-su-1][k+su+1]==0&&co[j][k]==0)
					{
						sum+=pow(10,su);
					}
					else if(co[j-su-1][k+su+1]!=0&&co[j][k]!=0)
					{
						if(su==5)
							sum+=100000;
					}
					else
					{
						if(su==5)
							sum+=100000;
						else
							sum+=pow(10,su-1);
					}
					su=0;
				}
				else
					su=0;
			}
	for(su=0,i=-19;i<20;i++)                    //╲
		for(j=i,k=0;j<20;j++,k++)
			if(j>=0&&j<20&&k>=0&&k<20)
			{
				if(co[j][k]==a)
					su++;
				else if(su>1)
				{
					if(co[j-su-1][k-su-1]==0&&co[j][k]==0)
					{
						sum+=pow(10,su);
					}
					else if(co[j-su-1][k-su-1]!=0&&co[j][k]!=0)
					{
						if(su==5)
							sum+=100000;
					}
					else
					{
						if(su==5)
							sum+=100000;
						else
						sum+=pow(10,su-1);
					}
					su=0;
				}
				else
					su=0;
			}
	if(n==1&&a==1)
		return sum-score(2,co,2);
	else if(n==1&&a==2)
		return sum-score(1,co,2);
	else if(n==2)
		return sum;
}
int jdgen(int co[20][20],int x,int y,int n)
//判断x，y坐标是否可生成棋子，可以返回1，否则返回0,n为1，判断内侧，为2，判断外侧
{
	int i,j;
	int sum=0;
	if(n==1)
	{
		for(i=x-1;i<x+2;i++)
			for(j=y-1;j<y+2;j++)
				if((i>0&&j>0&&i<20&&j<20)&&(co[i][j]==1||co[i][j]==2))
					sum=1;
	}
	else
	{
		for(i=x-2;i<x+3;i+=2)
			for(j=y-2;j<y+3;j+=2)
				if((i>0&&j>0&&i<20&&j<20)&&(co[i][j]==1||co[i][j]==2))
					sum=1;
	}
	return sum;
}
typedef struct
{
	int data;
	int Alpha;
	int Beta;
	int X;
	int Y;
}Tree;
int minMax(int co[20][20],int deep,int a,int Alpha,int Beta)
//分数传递,a为1表示白棋，为2表示黑棋,调用时Alpha，Beta赋为NGIF,PTIF
{
	int i,j;
	int c[20][20];
	int minmax;
	int b;
	int n=1;
	Tree tree;
	tree.data=NGIF;
	tree.Alpha=Alpha;
	tree.Beta=Beta;
	tree.X=0;
	tree.Y=0;
	if(a==1)
		b=2;
	else
		b=1;
	if(deep>0)
	{
		for(i=0;i<20;i++)
			for(j=0;j<20;j++)
			{
				if(co[i][j]==0&&jdgen(co,i,j,1)&&tree.Alpha<tree.Beta)
				{
					memcpy(c,co,sizeof(int)*400);
					c[i][j]=a;
					minmax=minMax(c,deep-1,b,tree.Alpha,tree.Beta);
					if(deep%2==0)
					{
						if(n==1)
						{
							tree.data=minmax;
							n++;
						}
						if(tree.Alpha<minmax)
						{
							tree.Alpha=minmax;
							tree.data=minmax;
							tree.X=i;
							tree.Y=j;
						}
					}
					else
					{
						if(n==1)
						{
							tree.data=minmax;
							n++;
						}
						if(tree.Beta>minmax)
						{
							tree.Beta=minmax;
							tree.data=minmax;
							tree.X=i;
							tree.Y=j;
						}
					}
				}
			}
		for(i=0;i<20;i++)
			for(j=0;j<20;j++)
			{
				if(co[i][j]==0&&jdgen(co,i,j,2)&&tree.Alpha<tree.Beta)
				{
					memcpy(c,co,sizeof(int)*400);
					c[i][j]=a;
					minmax=minMax(c,deep-1,b,tree.Alpha,tree.Beta);
					if(deep%2==0)
					{
						if(tree.Alpha<minmax)
						{
							tree.Alpha=minmax;
							tree.data=minmax;
							tree.X=i;
							tree.Y=j;
						}
					}
					else
					{
						if(tree.Beta>minmax)
						{
							tree.Beta=minmax;
							tree.data=minmax;
							tree.X=i;
							tree.Y=j;
						}
					}
				}
			}
		X=tree.X;
		Y=tree.Y;
		return tree.data;
	}
	else
	{
		return score(a,co,1);
	}
}
int* computer(int x)
{
	int i,j;
	int *p=(int*)malloc(2*sizeof(int));
	static int n=0;
	if(n==0)
	{
		for(i=0;i<20;i++)
			for(j=0;j<20;j++)
				n+=coord[i][j];
		if(n==0)
		{
			p[0]=9;
			p[1]=9;
			return p;
		}
		n++;
		
	}
	minMax(coord,x,2,NGIF,PTIF);
	p[0]=X;
	p[1]=Y;
	return p;
}

// HUMAN.c
#include<stdio.h>
extern int coord[20][20];
extern void location(int x,int y);
extern void clearlocation(int x,int y);
int* human()           
{
	static int X=9,Y=9;
	char h;
	int *p=(int*)malloc(2*sizeof(int));
	location(X,Y);
	while(1)
	{
		if(kbhit()!=0)
		{
			h=getch();
			clearlocation(X,Y);
			switch(h)
			{
				case 72://上
					if(X>0)
						X--;
					break;
				case 80://下
					if(X<19)
						X++;
					break;
				case 75://左
					if(Y>0)
						Y--;
					break;
				case 77://右
					if(Y<19)
						Y++;
					break;
				case 32://空格
					if(coord[X][Y]==0)
					{
						p[0]=X;
						p[1]=Y;
						return p;
					}
					break;
			}
			location(X,Y);
		}
	}
}
#P-A-S-S#
关注
五子棋（人机）-极大极小值搜索算法
脚踏实地，仰望星空
09-20 1万+
从人落子开始到出现胜负或者和局，之间所落的子，构成了一个解。而解空间就是一个树，解就是这解空间中的一条路径。只不过这个解空间是电脑的选择和人的选择共同构成的（奇数层是电脑（因为轮到电脑落子么），偶数层是人）。 极大极小值搜索算法，来搜索（回溯）这个解空间：它假设人和电脑都是极其聪明的，他们都会选择出最优的一步。 但是搜索整棵树是不现实的，16*16！指数级，所以只回溯n步，即这个AI考虑的是N
五子棋AI第一篇 极大极小值搜索算法（c语言）
feifei316631241的博客
09-26 1万+
由来 最近人工智能很火，经常有各种新闻，作为一个程序员多少要懂一点吧，未来万一用得着呢。有心想去了解一下，奈何能力有限，皮毛都没学会。好吧，既然没法系统学，就不管那么多，就从现在开始动手，一步一步的往前走，遇到什么问题就查什么资料。虽然最后不一定能做成什么，起码做的过程遇到问题解决问题，总能学会点什么。 那就从最简单的五子棋游戏开始好了，用普通的规则实现一个电脑下棋的算法，姑且叫做AI算法。作为一...
五子棋之极大极小算法
10-23
简单的用极大极小算法实现五子棋，水平还可以，可以玩，没有做GUI，命令行坐标来交互
人工智能下五子棋（基于博弈树极大极小值alpha-beta剪枝搜索算法）
06-23
人工智能下五子棋（基于博弈树极大极小值alpha-beta剪枝搜索算法），代码解析链接参见网址：https://blog.youkuaiyun.com/m0_38106923/article/details/93347117
AI策略与路径寻找：五子棋的α-β剪枝极大极小值算法与迷宫问题的A*与IDA*算法实战
最新发布
weixin_33750664的博客
07-07 905
算法与A。
通过alpha-belta剪枝的极大极小值算法实现简单的五子棋+A*算法与IDA*算法解决走迷宫问题
07-05
通过alpha-belta剪枝的极大极小值算法实现简单的五子棋+A*算法与IDA*算法解决走迷宫问题
基于极大极小值算法的五子棋AI实现.rar
12-02
使用javascript编写的在线五子棋程序，主要使用了极大极小值搜索,Alpha Beta剪枝,启发式评估函数,Zobrist缓存,迭代加深等算法
c语言实现五子棋极大极小算法
12-08
以下是C语言实现五子棋极大极小算法的示例代码： ```c #include #include #include #define BOARD_SIZE 15 #define MAX_DEPTH 5 int board[BOARD_SIZE][BOARD_SIZE]; // 棋盘 int player; // 玩家，1表示黑棋...
五子棋博弈树剪枝c语言,五子棋AI博弈树之带Alpha-Beta剪枝的极大极小过程函数...
weixin_29749887的博客
05-25 808
在博弈树的极大极小过程中是对每一个树节点(称它为全局搜索吧)都要计算其估值，然后在这些估值中做出选择。如果搜索比较大的话，全局搜索的方式效率会非常低，因为有一些节点根本不需要搜索。那么怎么加快搜索的速度呢？可以采用Alpha-Beta剪枝方法。Alpha-Beta剪枝方法如下：任何Max节点n的alpha值如果大于或等于它先辈节点的bete值，那么节点n以下的分支就不用搜索了。这是beta剪枝...
五子棋ai：极大极小搜索和α-β剪枝算法的思想和实现(qt和c++)（三）极大极小搜索和α-β剪枝算法
livingsu的博客
02-27 1万+
现在我们来到了五子棋ai的核心环节：极大极小搜索和α-β剪枝算法。这两个东西听上去挺高大上，但我实际中去实现之后才发现，原来也就是那么回事。 一、极大极小搜索 什么是极大极小搜索？我首先要介绍博弈树的概念。博弈树就是己方和敌方进行决策时形成的树状结构，每一个节点的分支表示当前节点可以走的各种可能的位置，每一个叶结点表示一个局面。比如说，从空棋盘开始（根节点），我进行落子，我有1515=255种落子...
利用EasyX图形库实现五子棋程序（C语言课程设计）C语言入门 言简意赅
01-13
EasyX是一个基于Windows API的小巧易用的图形库，它使得C语言进行图形编程变得简单，极大地简化了窗口、图形绘制以及事件处理等任务。 首先，我们要理解C语言基础，这是编写任何程序的基础。C语言是一种结构化编程...
安卓人机对战五子棋 极大极小搜索算法
04-23
安卓实现人机对战五子棋，对战算法是极大极小搜索算法，实现了深度和广度的优化
安卓机器对战五子棋贪心算法VS极大极小搜索算法
04-23
实现安卓五子棋机器对战算法，对战双方的算法是贪心算法和极大极小搜索算法
五子棋大作业（C++实现）
03-04
1、有两种对弈模式：人人对弈模式和人机对弈模式 2、采用黑屏字符输入输出实现UI 3、采用打分方法实现AI 4、棋盘大小为15*15，棋盘将显示相应的行列号（A-O） 5、棋子有两种颜色黑和白，代表着对弈的双方，棋子放在棋盘行列交叉处，惯例黑棋先下。 6、黑白任一方先连成5个棋子形成的直线（横线、竖线、对角线），则该方赢对方输 7、任一方都没连成直线，且棋盘已满时，为和局 8、最后一步下的位置有特殊标记
C语言五子棋算法
cosio的专栏
09-27 3408
作者：unknown 更新时间： 2005-03-13    任何一种棋类游戏其关键是对当前棋局是否有正确的评分,评分越准确则电脑的AI越高。五子棋游戏也是如此，但在打分之前，我们先扫描整个棋盘，把每个空位从八个方向上的棋型填入数组gStyle(2, 15, 15, 8, 2)，其中第一个下标为1时表示黑棋，为2时表示白棋，第二和第三个下标表示(x,y)，第四个下标表示8个方向，最后一个下标为1时
广搜法极大极小搜索（黑白棋片段）
geshengtong的博客
11-21 1311
Problem A 极大极小搜索 时限：1000ms 内存限制：10000K 总时限：3000ms 描述： 搜索n层，第一层取最大值，先输入两个整数n、randseed，用randseed设置随机数种子。 搜索时每层4个分支，能不能想这个分支走用函数canmoveto()判断，内容如下： int canmoveto(int m, int dire) { return(rand(
极大值极小值搜索设计五子棋
可乐林的博客
07-26 5734
极大值极小值搜索设计五子棋 源代码可在这里下载 摘要： 设计一个五子棋对战AI，使用极大值极小值搜索，并使用α-β剪枝减少复杂度。采用启发式函数对整个棋局形式进行评估，并作为极大值极小值搜索的依据。 一、导言 1.1 问题描述： 本次实验要求设计一个五子棋的AI，要求能与人类对战，并具有较好的用户交互界面。 1.2 背景介绍： 五子棋是世界智力运动会竞技项目之一，是一种两人对弈的纯...
五子棋AI进阶：极大极小值搜索
Maisucsdn的博客
09-23 1451
本文将介绍一种提高AI极大极小值算法。Minimax算法 又名极小化极大算法，是一种找出失败的最大可能性中的最小值的算法（即最小化对手的最大得益）。通常以递归形式来实现。Minimax算法常用于棋类等由两方较量的游戏和程序。该算法是一个零总和算法，即一方要在可选的选项中选择将其优势最大化的选择，另一方则选择令对手优势最小化的一个，其输赢的总和为0（有点像能量守恒，就像本身两个玩家都有1点，最后输家要将他的1点给赢家，但整体上还是总共有2点）。
博弈基础——极大极小搜索
热门推荐
大田二十
03-05 2万+
博弈基础
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值