如何编写一个五子棋AI（附AI源码）

已于 2023-10-05 18:13:24 修改
阅读量2.1k 收藏 11
点赞数
文章标签： 人工智能
于 2023-10-04 20:42:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangyuhan2010/article/details/133558562
版权

注:此文章的代码推荐在 小熊猫 c + + \boxed{小熊猫c++} 小熊猫c++​上运行（使用了EGE图形库）

AI的原理

1.三子棋AI的编写

三子棋的总局面数约为 549 , 946 549,946 549,946，因此我们先以它为基础开始编写。

Test1:构建决策树

在这里插入图片描述

注意:节点上方的 [ a / b ] [a/b] [a/b]表示某个决策下一步还有 b b b种可能，还剩下 a a a种未显示

这里，我们先来讨论某个局面下一步的决策。
在这里插入图片描述
源码见文末 T e s t 1 Test 1 Test1 源码
关注左上红下 ( 1 , 3 ) (1,3) (1,3)的节点，可以发现下一步蓝色可以获胜，那么红方必然不能下 ( 1 , 3 ) (1,3) (1,3)。
同理，红下 ( 3 , 2 ) & ( 1 , 2 ) (3,2)\&(1,2) (3,2)&(1,2)同样不行，只能下 ( 3 , 1 ) (3,1) (3,1)。

继续看蓝方，可以发现蓝方也只能下 ( 1 , 3 ) (1,3) (1,3)

于是，我们就得到了三子棋的AI的博弈树，现在来分析具体方法。

Test2:Min-Max算法

在这里插入图片描述
我们将平局定为 5 5 5分，红胜为 10 10 10，红负为 0 0 0分，这样，我们就可以得到每个局面对红方的好处。
设前一步的节点为 u u u,下一步的节点为 v v v
对于每一个蓝点（到蓝色下棋），下一步是红方控制的，当然会选择对自己优的，所以取 V u = max ⁡ { V v } V_u=\max\{V_v\} Vu​=max{Vv​}，比如下图中粉框节点，下一步红方可以取胜，那当然要选取胜了
在这里插入图片描述

对于每一个红点（到红色下棋），下一步是对方控制的，当然会选择对红方劣的，所以取 V u = min ⁡ { V v } V_u=\min\{V_v\} Vu​=min{Vv​}，比如如果有一个节点，下一步蓝方可以取胜，那当然要选取胜（红败）了
这样，我们就得到了所有局面的胜率。
源码见文末 T e s t   2 − 1 Test\ 2-1 Test 2−1 源码，AI下3子棋见 T e s t   2 − 2 Test\ 2-2 Test 2−2 源码
在这里插入图片描述
当然，经过对所有局面的考察，可以发现没有必胜的可能，但是还是有可能在前几步利用对手失误获得必胜（读者可以自行查看程序），如上图。

1.五子棋AI的编写

五子棋的总局面数约为 1 0 50 10^{50} 1050，因此不可能构造完整的决策树。

Test3:对局面进行估分

待续
还是以三子棋为例，把 [ X ] [ X ] [     ] [X][X][\ \ \ ] [X][X][   ]记为 50 50 50分， [     ] [ X ] [     ] [\ \ \ ][X][\ \ \ ] [   ][X][   ]和 [     ] [     ] [ X ] [\ \ \ ][\ \ \ ][X] [   ][   ][X]记为 10 10 10分， [ X ] [ X ] [ X ] [X][X][X] [X][X][X]记为 100 100 100分，就可以在决策树层数较少的情况估算价值。
在这里插入图片描述
有了估值，AI就智慧多了，如果我们把比较有可能的点（这里是选前2个）单独挑出来，其余的点不进行展开，可以发现它已经把较优的点选好了（如上图），就会大大减少节点数。
以下是一次对局：（AI:蓝）
在这里插入图片描述
评价：目光较短浅，但是速度非常快(约0.3s)
源码见 T e s t   3 Test \ 3 Test 3

Test4:α-β剪枝

AI不行，就加深度，时间太长，就加剪枝

在这里插入图片描述
发现 V u = m a x { m i n { a , b } , c } V_u=max\{min\{a,b\},c\} Vu​=max{min{a,b},c}时，如果 a & b a\&b a&b有一个 < c <c <c，那就不用算了， V u V_u Vu​就是 c c c，
同理 V u = m i n { m a x { a , b } , c } V_u=min\{max\{a,b\},c\} Vu​=min{max{a,b},c}，如果 a & b a\&b a&b有一个 > c >c >c， V u V_u Vu​就是 c c c
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
即： m i n ( 7 , m a x ( 10 , ? ) ) = 7 min(7,max(10,?))=7 min(7,max(10,?))=7
在这里插入图片描述
(实测大约剪掉了 3 / 4 3/4 3/4的节点，效率不太高，所以笔者并没有用)

本文中所有源代码

T e s t   1 Test \ 1 Test 1

#include<iostream>
#include<vector>
#include<graphics.h>
using namespace std;
struct BOARD{int a[3][3];int number,win;};
struct SHOW{int x,y;int SON;}node[4020889];
int NODE=1;bool show[4028089];
BOARD tree[4028809];
vector<int>son[4002889];
int mx,my,Dl,LINE[400288][5],LN,Dr,LOCK,Rc=1;
int check(BOARD now)
{
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(now.a[i][j])
			for(int fx=-1;fx<=1;fx++)
				for(int fy=-1;fy<=1;fy++)
					if(fx!=0||fy!=0)
				{
					int bo=now.a[i][j];
					for(int f=1;f<=2;f++)
						if(i+fx*f>=3||j+fy*f>=3||i+fx*f<0||j+fy*f<0||now.a[i][j]!=now.a[i+fx*f][j+fy*f])bo=0;
					if(bo)return bo;
				}
	return 0;
}
int getstep(BOARD now)
{
	int step=0;
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)step+=now.a[i][j];
	if(step==0)step=1;else step=-1;
	return step;
}
void dfs(BOARD now)
{
	tree[now.number]=now;
	if(now.win)
	{
		return;
	}
	int step=getstep(now);
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
		if(!now.a[i][j])
		{
			NODE++;BOARD next=now;next.number=NODE;
			son[now.number].push_back(NODE);
			next.a[i][j]=step;
			next.win=check(next);
			dfs(next);
		}
}
BOARD empty_board()
{
	BOARD empty;
	for(int i=0;i<3;i++)for(int j=0;j<3;j++)empty.a[i][j]=0;empty.number=1;empty.win=0;
	return empty;
}
void print_board(int x,int y,BOARD z)
{
	setcolor(getstep(z)==1?RED:BLUE);
	setfillcolor(WHITE);
	fillrect(x,y,x+100,y+100);
	x+=10;y+=10;
	setcolor(BLACK);
	int t=80/3;
	for(int i=x;i<=x+80;i+=t)line(i,y,i,y+80);
	for(int j=y;j<=y+80;j+=t)line(x,j,x+80,j);
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(z.a[i][j]==1)
			{
				setcolor(BLUE);setlinewidth(2);
				circle(x+i*t+t/2,y+j*t+t/2,t/2-1);setlinewidth(1);
			}
			else if(z.a[i][j]==-1)
			{
				setcolor(RED);
				setlinewidth(3);
				line(x+t*i+2,y+t*j+2,x+t*i+t-2,y+t*j+t-2);
				line(x+t*i+2,y+t*j+t-2,x+t*i+t-2,y+t*j+2);
				setlinewidth(1);
			}
}
void change_board(int x,int y,BOARD &z)
{
	x+=10;y+=10;
	int t=80/3;
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(mx>x+t*i&&mx<x+t*i+t&&my>y+t*j&&my<y+t*j+t)
			{
				if(Dr)z.a[i][j]=getstep(z);
			}
}
void print_line()
{
	setcolor(BLACK);
	for(int i=1;i<=LN;i++)line(node[LINE[i][0]].x+50,node[LINE[i][0]].y+50,node[LINE[i][1]].x+50,node[LINE[i][1]].y+50);
}
void mousedata()
{
	if(Dr==0)LOCK=0;
	Dl=0;Rc=0;
	while(mousemsg())
	{
		mouse_msg m=getmouse();
		if(m.is_move())mx=m.x,my=m.y;
		if(m.is_down()&&m.is_mid())Dl=1;
		if(m.is_down()&&m.is_left())Dr=1;
		if(m.is_up()&&m.is_left())Dr=0;
		if(m.is_down()&&m.is_right())Rc=1;
	}	
}
int main()
{
	initgraph(1000,600);setbkcolor(WHITE);setcolor(BLACK);
	BOARD empty=empty_board();
	while(1)
	{
		dfs(empty);
		setcaption("显示模式（点击右键编辑初始棋盘，中键展开，左键移动）");
		cout<<"TOTAL:"<<NODE<<endl;
		int t=0;
		node[1].y=250;node[1].x=5;show[1]=1;Rc=0;tree[1]=empty;
		while(Rc==0)
		{
			cleardevice();
			print_line();
			for(int i=1;i<=NODE;i++)
				if(show[i])
				{
					print_board(node[i].x,node[i].y,tree[i]);
					outtextxy(node[i].x,node[i].y-20,("["+to_string(son[i].size())+"/"+to_string(node[i].SON+son[i].size())+"]").c_str());
					if(tree[i].win==-1)outtextxy(node[i].x,node[i].y-20,"WIN:RED");
					if(tree[i].win==1)outtextxy(node[i].x,node[i].y-20,"WIN:BLUE");
					if(Dl&&!son[i].empty()&&mx>node[i].x&&mx<node[i].x+100&&my>node[i].y&&my<node[i].y+100)
					{
						show[son[i].back()]=1;node[son[i].back()].x=node[i].x+120;
						node[son[i].back()].y=node[i].y;LINE[++LN][0]=i;LINE[LN][1]=son[i].back();
						son[i].pop_back();node[i].SON++;
					}
					if(Dr&&mx>node[i].x&&mx<node[i].x+100&&my>node[i].y&&my<node[i].y+100)
					{
						if(LOCK==i||LOCK==0)
						{
							node[i].x=mx-50;node[i].y=my-50;
							LOCK=i;
						}
						
					}
				}
			mousedata();
			delay_ms(100);
		}
		setcaption("编辑模式（点击右键开始计算，左键编辑棋盘）");
		Rc=0;
		cleardevice();
		while(Rc==0)
		{
			print_board(5,250,empty);
			change_board(5,250,empty);
			mousedata();
			if(Dl)empty=empty_board();
			delay_ms(100);
		}
		for(int i=1;i<=NODE;i++)
		{
			show[i]=0;tree[i].number=0;tree[i].win=0;
			son[i].clear();node[i].SON=0;
		}
		NODE=1;LN=0;
	}
}

T e s t   2 − 1 Test \ 2-1 Test 2−1

#include<iostream>
#include<vector>
#include<graphics.h>
using namespace std;
struct BOARD{int a[3][3];int number,win,score;};
struct SHOW{int x,y;int SON;}node[4020889];
int NODE=1;bool show[4028089];
BOARD tree[4028809];
vector<int>son[4002889];
int mx,my,Dl,LINE[400288][5],LN,Dr,LOCK,Rc=1;
int check(BOARD now)
{
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(now.a[i][j])
				for(int fx=-1;fx<=1;fx++)
					for(int fy=-1;fy<=1;fy++)
						if(fx!=0||fy!=0)
						{
							int bo=now.a[i][j];
							for(int f=1;f<=2;f++)
								if(i+fx*f>=3||j+fy*f>=3||i+fx*f<0||j+fy*f<0||now.a[i][j]!=now.a[i+fx*f][j+fy*f])bo=0;
							if(bo)return bo;
						}
	return 0;
}
int getstep(BOARD now)
{
	int step=0;
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)step+=now.a[i][j];
	if(step==0)step=1;else step=-1;
	return step;
}
int dfs(BOARD now)
{
	tree[now.number]=now;
	if(now.win)
	{
		tree[now.number].score=now.win==-1?10:0;
		return now.win==-1?10:0;
	}
	int step=getstep(now),ping=1,Min=1e9,Max=-1e9;
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(!now.a[i][j])
			{ping=0;
				NODE++;BOARD next=now;next.number=NODE;
				son[now.number].push_back(NODE);
				next.a[i][j]=step;
				next.win=check(next);
				if(step==1)Min=min(Min,dfs(next));
				else Max=max(Max,dfs(next));
				
			}
	if(ping==1)
	{
		tree[now.number].score=5;
		return 5;
	}
	tree[now.number].score=(step==1?Min:Max);
	return tree[now.number].score;
}
BOARD empty_board()
{
	BOARD empty;
	for(int i=0;i<3;i++)for(int j=0;j<3;j++)empty.a[i][j]=0;empty.number=1;empty.win=0;
	return empty;
}
void print_board(int x,int y,BOARD z)
{
	setcolor(getstep(z)==1?RED:BLUE);
	setfillcolor(WHITE);
	fillrect(x,y,x+100,y+100);
	x+=10;y+=10;
	setcolor(BLACK);
	int t=80/3;
	for(int i=x;i<=x+80;i+=t)line(i,y,i,y+80);
	for(int j=y;j<=y+80;j+=t)line(x,j,x+80,j);
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(z.a[i][j]==1)
			{
				setcolor(BLUE);setlinewidth(2);
				circle(x+i*t+t/2,y+j*t+t/2,t/2-1);setlinewidth(1);
			}
	else if(z.a[i][j]==-1)
	{
		setcolor(RED);
		setlinewidth(3);
		line(x+t*i+2,y+t*j+2,x+t*i+t-2,y+t*j+t-2);
		line(x+t*i+2,y+t*j+t-2,x+t*i+t-2,y+t*j+2);
		setlinewidth(1);
	}
}
void change_board(int x,int y,BOARD &z)
{
	x+=10;y+=10;
	int t=80/3;
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(mx>x+t*i&&mx<x+t*i+t&&my>y+t*j&&my<y+t*j+t)
			{
				if(Dr)z.a[i][j]=getstep(z);
			}
}
void print_line()
{
	setcolor(BLACK);
	for(int i=1;i<=LN;i++)line(node[LINE[i][0]].x+50,node[LINE[i][0]].y+50,node[LINE[i][1]].x+50,node[LINE[i][1]].y+50);
}
void mousedata()
{
	if(Dr==0)LOCK=0;
	Dl=0;Rc=0;
	while(mousemsg())
	{
		mouse_msg m=getmouse();
		if(m.is_move())mx=m.x,my=m.y;
		if(m.is_down()&&m.is_mid())Dl=1;
		if(m.is_down()&&m.is_left())Dr=1;
		if(m.is_up()&&m.is_left())Dr=0;
		if(m.is_down()&&m.is_right())Rc=1;
	}	
}
int main()
{
	initgraph(1000,600);setbkcolor(WHITE);setcolor(BLACK);
	BOARD empty=empty_board();
	while(1)
	{
		dfs(empty);
		setcaption("显示模式（点击右键编辑初始棋盘，中键展开，左键移动）");
		cout<<"TOTAL:"<<NODE<<endl;
		int t=0;
		node[1].y=250;node[1].x=5;show[1]=1;Rc=0;
		while(Rc==0)
		{
			cleardevice();
			print_line();
			for(int i=1;i<=NODE;i++)
				if(show[i])
				{
					print_board(node[i].x,node[i].y,tree[i]);
					outtextxy(node[i].x,node[i].y-20,("["+to_string(son[i].size())+"]"+"Score:"+to_string(tree[i].score)).c_str());
					if(Dl&&!son[i].empty()&&mx>node[i].x&&mx<node[i].x+100&&my>node[i].y&&my<node[i].y+100)
					{
						show[son[i].back()]=1;node[son[i].back()].x=node[i].x+120;
						node[son[i].back()].y=node[i].y;LINE[++LN][0]=i;LINE[LN][1]=son[i].back();
						son[i].pop_back();node[i].SON++;
					}
					if(Dr&&mx>node[i].x&&mx<node[i].x+100&&my>node[i].y&&my<node[i].y+100)
					{
						if(LOCK==i||LOCK==0)
						{
							node[i].x=mx-50;node[i].y=my-50;
							LOCK=i;
						}
						
					}
				}
			mousedata();
			delay_ms(100);
		}
		setcaption("编辑模式（点击右键开始计算，左键编辑棋盘）");
		Rc=0;
		cleardevice();
		while(Rc==0)
		{
			print_board(5,250,empty);
			change_board(5,250,empty);
			mousedata();
			if(Dl)empty=empty_board();
			delay_ms(100);
		}
		for(int i=1;i<=NODE;i++)
		{
			show[i]=0;tree[i].number=0;tree[i].win=0;
			son[i].clear();node[i].SON=0;
		}
		NODE=1;LN=0;
	}
}

T e s t   2 − 2 Test \ 2-2 Test 2−2

#include<iostream>
#include<vector>
#include<graphics.h>
using namespace std;
struct BOARD{int a[3][3];int number,win,score;};
struct SHOW{int x,y;int SON;}node[4020889];
int NODE=1;bool show[4028089];
BOARD tree[4028809];
vector<int>son[4002889];
int mx,my,Dl,LINE[400288][5],LN,Dr,LOCK,Rc=1,PC=0;
int check(BOARD now)
{
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(now.a[i][j])
				for(int fx=-1;fx<=1;fx++)
					for(int fy=-1;fy<=1;fy++)
						if(fx!=0||fy!=0)
						{
							int bo=now.a[i][j];
							for(int f=1;f<=2;f++)
								if(i+fx*f>=3||j+fy*f>=3||i+fx*f<0||j+fy*f<0||now.a[i][j]!=now.a[i+fx*f][j+fy*f])bo=0;
							if(bo)return bo;
						}
	return 0;
}
int getstep(BOARD now)
{
	int step=0;
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)step+=now.a[i][j];
	if(step==0)step=1;else step=-1;
	return step;
}
int dfs(BOARD now)
{
	tree[now.number]=now;
	if(now.win)
	{
		tree[now.number].score=now.win==-1?10:0;
		return now.win==-1?10:0;
	}
	int step=getstep(now),ping=1,Min=1e9,Max=-1e9;
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(!now.a[i][j])
			{ping=0;
				NODE++;BOARD next=now;next.number=NODE;
				son[now.number].push_back(NODE);
				next.a[i][j]=step;
				next.win=check(next);
				if(step==1)Min=min(Min,dfs(next));
				else Max=max(Max,dfs(next));
				
			}
	if(ping==1)
	{
		tree[now.number].score=5;
		return 5;
	}
	tree[now.number].score=(step==1?Min:Max);
	return tree[now.number].score;
}
BOARD empty_board()
{
	BOARD empty;
	for(int i=0;i<3;i++)for(int j=0;j<3;j++)empty.a[i][j]=0;empty.number=1;empty.win=0;
	return empty;
}
void print_board(int x,int y,BOARD z)
{
	setcolor(getstep(z)==1?RED:BLUE);
	setfillcolor(WHITE);
	fillrect(x,y,x+100,y+100);
	x+=10;y+=10;
	setcolor(BLACK);
	int t=80/3;
	for(int i=x;i<=x+80;i+=t)line(i,y,i,y+80);
	for(int j=y;j<=y+80;j+=t)line(x,j,x+80,j);
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(z.a[i][j]==1)
			{
				setcolor(BLUE);setlinewidth(2);
				circle(x+i*t+t/2,y+j*t+t/2,t/2-1);setlinewidth(1);
			}
	else if(z.a[i][j]==-1)
	{
		setcolor(RED);
		setlinewidth(3);
		line(x+t*i+2,y+t*j+2,x+t*i+t-2,y+t*j+t-2);
		line(x+t*i+2,y+t*j+t-2,x+t*i+t-2,y+t*j+2);
		setlinewidth(1);
	}
}
void change_board(int x,int y,BOARD &z)
{
	x+=10;y+=10;
	int t=80/3;
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			if(mx>x+t*i&&mx<x+t*i+t&&my>y+t*j&&my<y+t*j+t)
			{
				if(Dr)z.a[i][j]=1;PC=1;
			}
}
void print_line()
{
	setcolor(BLACK);
	for(int i=1;i<=LN;i++)line(node[LINE[i][0]].x+50,node[LINE[i][0]].y+50,node[LINE[i][1]].x+50,node[LINE[i][1]].y+50);
}
void mousedata()
{
	if(Dr==0)LOCK=0;
	Dl=0;Rc=0;
	while(mousemsg())
	{
		mouse_msg m=getmouse();
		if(m.is_move())mx=m.x,my=m.y;
		if(m.is_down()&&m.is_mid())Dl=1;
		if(m.is_down()&&m.is_left())Dr=1;
		if(m.is_up()&&m.is_left())Dr=0;
		if(m.is_down()&&m.is_right())Rc=1;
	}	
}
int main()
{srand(time(0));
	initgraph(1000,600);setbkcolor(WHITE);setcolor(BLACK);
	BOARD empty=empty_board();
	while(1)
	{
		setcaption("下棋模式（左键下棋，右键确认）");Rc=0;
		while(Rc==0)
		{
			cleardevice();
			print_board(5,250,empty);
			change_board(5,250,empty);
			mousedata();
			delay_ms(50);
		}print_board(5,250,empty);
		for(int i=1;i<=NODE;i++)
		{
			show[i]=0;tree[i].number=0;tree[i].win=0;
			son[i].clear();node[i].SON=0;
		}
		NODE=1;LN=0;empty.number=1;
		dfs(empty);
		setcaption("显示模式（点击右键AI决策，中键展开，左键移动）");
		cout<<"TOTAL:"<<NODE<<endl;
		int t=0;
		node[1].y=250;node[1].x=5;show[1]=1;Rc=0;
		int Min=1e9,Max=-1e9;
		vector<BOARD>CAN;CAN.clear();
		if(son[1].size()==0)exit(0);
		//for(int i=1;i<=10;i++)cout<<son[i].size();
		for(auto i:son[1])
		{//cout<<i<<endl;
			Max=max(Max,tree[i].score);
		}
		Min=Max;
		for(auto i:son[1])if(tree[i].score==Min)CAN.push_back(tree[i]);
		empty=CAN[rand()%CAN.size()];cout<<"[COMPLETE]\n";
		while(Rc==0)
		{
			cleardevice();
			print_line();
			
			for(int i=1;i<=NODE;i++)
				if(show[i])
				{
					print_board(node[i].x,node[i].y,tree[i]);
					outtextxy(node[i].x,node[i].y-20,("["+to_string(son[i].size())+"]"+"Score:"+to_string(tree[i].score)).c_str());
					if(Dl&&!son[i].empty()&&mx>node[i].x&&mx<node[i].x+100&&my>node[i].y&&my<node[i].y+100)
					{
						show[son[i].back()]=1;node[son[i].back()].x=node[i].x+120;
						node[son[i].back()].y=node[i].y;LINE[++LN][0]=i;LINE[LN][1]=son[i].back();
						son[i].pop_back();node[i].SON++;
					}
					if(Dr&&mx>node[i].x&&mx<node[i].x+100&&my>node[i].y&&my<node[i].y+100)
					{
						if(LOCK==i||LOCK==0)
						{
							node[i].x=mx-50;node[i].y=my-50;
							LOCK=i;
						}
						
					}
				}
			mousedata();
			delay_ms(100);
		}
	}
}

T e s t   3 Test \ 3 Test 3

#include<bits/stdc++.h>
#include<graphics.h>
using namespace std;
struct BOARD{int a[10][10];int number,win,score,stepx,stepy;};
struct SHOW{int x,y;int SON;}node[402088];
int NODE=1;bool show[402808];
BOARD tree[402880];
vector<int>son[400288];
int mx,my,Dl,LINE[400288][5],LN,Dr,LOCK,Rc=1;
int cmp(int a,int b)
{
	return tree[a].score<tree[b].score;
}
int check(BOARD now,int x,int y)
{
	for(int i=x;i<=x;i++)
		for(int j=y;j<=y;j++)
			if(now.a[i][j])
				for(int fx=-1;fx<=1;fx++)
					for(int fy=-1;fy<=1;fy++)
						if(fx!=0||fy!=0)
						{
							int bo=now.a[i][j];
							for(int f=1;f<=4;f++)
								if(i+fx*f>=10||j+fy*f>=10||i+fx*f<0||j+fy*f<0||now.a[i][j]!=now.a[i+fx*f][j+fy*f])bo=0;
							if(bo)return bo;
						}
	return 0;
}
int evaluateDirection(const BOARD board, int row, int col, int player) 
{
	int directions[4][2] = {{1, 0}, {0, 1}, {1, 1}, {1, -1}};
	int score = 0;
	for (int i = 0; i < 4; i++) 
	{
		int count = 0,dc=1;
		for (int j = 1; j <= 5; j++) 
		{
			int newRow = row + j * directions[i][0];
			int newCol = col + j * directions[i][1];
			if (newRow < 0 || newRow >= 10 || newCol < 0 || newCol >= 10 ||
				board.a[newRow][newCol] != player)
			{
				if(board.a[newRow][newCol] != 0)dc=2;
				break;
			}
			count++;
		}
		if(board.a[row  -1 * directions[i][0]][col - 1 * directions[i][1]]==-player)dc*=2;
		if (count == 1) {
			score += 1/dc;
		} else if (count == 2) {
			score += 10/dc;
		} else if (count == 3) {
			score += 100/dc;
		} else if (count == 4) {
			score += 900/dc;
		} else if (count == 5) {
			score += 1000/dc;
		}
	}
	
	return score;
}
int evaluateBoard(const BOARD board) 
{
	int score = 0;
	for (int i = 0; i < 10; i++) 
	{
		for (int j = 0; j < 10; j++) 
		{
			if (board.a[i][j] == 1) 
				score += evaluateDirection(board, i, j, 1);
			else if (board.a[i][j] == -1) 
				score -= evaluateDirection(board, i, j, -1);
		}
	}
	return score;
}
int getstep(BOARD now)
{
	int step=0;
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)step+=now.a[i][j];
	if(step==0)step=1;else step=-1;
	return step;
}
int dfs(BOARD now,int k,int Nk)
{//if(rand()%10000==0)cout<<now.number;
	son[now.number].clear();
	int nd=NODE;
	tree[now.number]=now;
	if(now.win)
	{
		tree[now.number].score=now.win==-1?1000:0;
		return now.win==-1?1000:0;
	}
	int step=getstep(now),Min=1e9,Max=-1e9;
	if(k>min(Nk,4))
	{
		tree[now.number].score=-evaluateBoard(now);
		return tree[now.number].score;
	}
	map<int,int>ndx,ndy;
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
			if(!now.a[i][j])
			{
				NODE++;BOARD next=now;next.number=NODE;
				son[now.number].push_back(NODE);
				next.a[i][j]=step;ndx[NODE]=i;ndy[NODE]=j;
				next.win=check(next,i,j);next.stepx=i;next.stepy=j;
				if(step==1)Min=min(Min,dfs(next,k+1,Nk));
				else Max=max(Max,dfs(next,k+1,Nk));
			}
	sort(son[now.number].begin(),son[now.number].end(),cmp);
	if(getstep(tree[now.number])==1)reverse(son[now.number].begin(),son[now.number].end());
	if(k>2)
	{
		Min=1e9,Max=-1e9;NODE=nd;
		vector<int>SON;
		for(int i=0;i<5;i++)
		{
			NODE++;BOARD next=now;next.number=NODE;
			SON.push_back(NODE);
			next.stepx=ndx[son[now.number][i]];next.stepy=ndy[son[now.number][i]];
			next.a[next.stepx][next.stepy]=step;next.win=check(next,next.stepx,next.stepy);
			if(step==1)Min=min(Min,dfs(next,k+1,k+3));
			else Max=max(Max,dfs(next,k+1,k+3));
		}
		son[now.number]=SON;
	}
	
	tree[now.number].score=(step==1?Min:Max);
	return tree[now.number].score;
}
BOARD empty_board()
{
	BOARD empty;
	for(int i=0;i<10;i++)for(int j=0;j<10;j++)empty.a[i][j]=0;empty.number=1;empty.win=0;
	return empty;
}
void print_board_all(int x,int y,BOARD z)
{
	setcolor(getstep(z)==1?RED:BLUE);
	setfillcolor(WHITE);
	fillrect(x,y,x+300,y+300);
	x+=10;y+=10;
	setcolor(BLACK);
	int t=270/10;
	for(int i=x;i<=x+280;i+=t)line(i,y,i,y+280);
	for(int j=y;j<=y+280;j+=t)line(x,j,x+280,j);
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
			if(z.a[i][j]==1)
			{
				setcolor(BLUE);setlinewidth(2);
				circle(x+i*t+t/2,y+j*t+t/2,t/2-1);setlinewidth(1);
			}
	else if(z.a[i][j]==-1)
	{
		setcolor(RED);
		setlinewidth(3);
		line(x+t*i+2,y+t*j+2,x+t*i+t-2,y+t*j+t-2);
		line(x+t*i+2,y+t*j+t-2,x+t*i+t-2,y+t*j+2);
		setlinewidth(1);
	}
}
void print_board_step(int x,int y,BOARD z)
{
	setcolor(getstep(z)==1?RED:BLUE);
	setfillcolor(WHITE);
	fillrect(x,y,x+100,y+40);
	x+=20;y+=10;
	setcolor(BLACK);
	if(z.stepx==0&&z.stepy==0);else
		outtextxy(x,y,("("+to_string(z.stepx+1)+","+to_string(z.stepy+1)+")").c_str());
}
void change_board(int x,int y,BOARD &z)
{
	x+=10;y+=10;
	int t=270/10;
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
			if(mx>x+t*i&&mx<x+t*i+t&&my>y+t*j&&my<y+t*j+t)
			{
				if(Dr)z.a[i][j]=getstep(z);
			}
}
void print_line()
{
	setcolor(BLACK);
	for(int i=1;i<=LN;i++)line(node[LINE[i][0]].x+50,node[LINE[i][0]].y+20,node[LINE[i][1]].x+50,node[LINE[i][1]].y+20);
}
void mousedata()
{
	if(Dr==0)LOCK=0;
	Dl=0;Rc=0;
	while(mousemsg())
	{
		mouse_msg m=getmouse();
		if(m.is_move())mx=m.x,my=m.y;
		if(m.is_down()&&m.is_mid())Dl=1;
		if(m.is_down()&&m.is_left())Dr=1;
		if(m.is_up()&&m.is_left())Dr=0;
		if(m.is_down()&&m.is_right())Rc=1;
	}	
}

int main()
{
	initgraph(1000,600);setbkcolor(WHITE);setcolor(BLACK);
	BOARD empty=empty_board();
	while(1)
	{
		setcaption("游玩模式（点击右键AI开始计算，左键下棋）");
		Rc=0;
		cleardevice();
		while(Rc==0)
		{
			print_board_all(5,250,empty);
			change_board(5,250,empty);
			mousedata();
			if(Dl)empty=empty_board();
			delay_ms(100);
		}
		for(int i=1;i<=NODE;i++)
		{
			show[i]=0;tree[i].number=0;tree[i].win=0;
			son[i].clear();node[i].SON=0;
		}
		NODE=1;LN=0;
		dfs(empty,1,2);
		setcaption("显示模式（点击右键编辑初始棋盘，中键展开，左键移动）");
		cout<<"TOTAL:"<<NODE<<endl;
		int t=0;
		node[1].y=250;node[1].x=5;show[1]=1;Rc=0;int lc=1;
		empty=tree[son[1].back()];empty.number=1;empty.score=0;
		while(Rc==0)
		{
			cleardevice();
			print_line();print_board_all(0,0,tree[lc==0?1:lc]);
			for(int i=NODE;i>=1;i--)
				if(show[i])
				{
					
					print_board_step(node[i].x,node[i].y,tree[i]);
					outtextxy(node[i].x,node[i].y-20,("["+to_string(son[i].size())+"]"+"Score:"+to_string(tree[i].score)).c_str());
					if(Dl&&!son[i].empty()&&mx>node[i].x&&mx<node[i].x+100&&my>node[i].y&&my<node[i].y+100)
					{
						show[son[i].back()]=1;node[son[i].back()].x=node[i].x+120;
						node[son[i].back()].y=node[i].y;LINE[++LN][0]=i;LINE[LN][1]=son[i].back();
						son[i].pop_back();node[i].SON++;
					}
					if(Dr&&mx>node[i].x&&mx<node[i].x+100&&my>node[i].y&&my<node[i].y+40)
					{
						if(LOCK==i||LOCK==0)
						{
							node[i].x=mx-50;node[i].y=my-20;
							LOCK=i;lc=i;
						}
						
					}
				}
			mousedata();
			delay_ms(100);
		}
		
	}
}

五子棋最终 A I ( 我无法评价 ) 五子棋最终AI(我无法评价) 五子棋最终AI(我无法评价)

#include<bits/stdc++.h>
#include<graphics.h>
using namespace std;
struct BOARD{int a[10][10];int number,win,score,stepx,stepy;};
struct SHOW{int x,y;int SON;}node[402088];
int NODE=1;bool show[402808];
BOARD tree[402880];
vector<int>son[400288];
int mx,my,Dl,LINE[400288][5],LN,Dr,LOCK,Rc=1;
int cmp(int a,int b)
{
	return tree[a].score<tree[b].score;
}
int check(BOARD now,int x,int y)
{
	for(int i=x;i<=x;i++)
		for(int j=y;j<=y;j++)
			if(now.a[i][j])
				for(int fx=-1;fx<=1;fx++)
					for(int fy=-1;fy<=1;fy++)
						if(fx!=0||fy!=0)
						{
							int bo=now.a[i][j];
							for(int f=1;f<=4;f++)
								if(i+fx*f>=10||j+fy*f>=10||i+fx*f<0||j+fy*f<0||now.a[i][j]!=now.a[i+fx*f][j+fy*f])bo=0;
							if(bo)return bo;
						}
	return 0;
}
int evaluateDirection(const BOARD board, int row, int col, int player) 
{
	int directions[4][2] = {{1, 0}, {0, 1}, {1, 1}, {1, -1}};
	int score = 0;
	for (int i = 0; i < 4; i++) 
	{
		int count = 0,dc=1;
		for (int j = 1; j <= 5; j++) 
		{
			int newRow = row + j * directions[i][0];
			int newCol = col + j * directions[i][1];
			if (newRow < 0 || newRow >= 10 || newCol < 0 || newCol >= 10 ||
				board.a[newRow][newCol] != player)
			{
				if(board.a[newRow][newCol] != 0)dc=2;
				break;
			}
			count++;
		}
		if(board.a[row  -1 * directions[i][0]][col - 1 * directions[i][1]]==-player)dc*=2;
		if (count == 1) {
			score += 1/dc;
		} else if (count == 2) {
			score += 10/dc;
		} else if (count == 3) {
			score += 100/dc;
		} else if (count == 4) {
			score += 900/dc;
		} else if (count == 5) {
			score += 1000/dc;
		}
	}
	
	return score;
}
int evaluateBoard(const BOARD board) 
{
	int score = 0;
	for (int i = 0; i < 10; i++) 
	{
		for (int j = 0; j < 10; j++) 
		{
			if (board.a[i][j] == 1) 
				score += evaluateDirection(board, i, j, 1);
			else if (board.a[i][j] == -1) 
				score -= evaluateDirection(board, i, j, -1);
		}
	}
	return score;
}
int getstep(BOARD now)
{
	int step=0;
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)step+=now.a[i][j];
	if(step==0)step=1;else step=-1;
	return step;
}
int dfs(BOARD now,int k,int Nk,int alpha,int beta)
{//if(rand()%10000==0)cout<<now.number;
	son[now.number].clear();
	int nd=NODE;
	tree[now.number]=now;
	if(now.win)
	{
		tree[now.number].score=now.win==-1?1000:0;
		return now.win==-1?1000:0;
	}
	int step=getstep(now),Min=1e9,Max=-1e9;
	if(k>min(Nk,6))
	{
		tree[now.number].score=-evaluateBoard(now);
		return tree[now.number].score;
	}
	map<int,int>ndx,ndy;
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
			if(!now.a[i][j])
			{
				NODE++;BOARD next=now;next.number=NODE;
				son[now.number].push_back(NODE);
				next.a[i][j]=step;ndx[NODE]=i;ndy[NODE]=j;
				next.win=check(next,i,j);next.stepx=i;next.stepy=j;
				int t=step==1?dfs(next,k+1,Nk,alpha,Min):dfs(next,k+1,Nk,Max,beta);
				//if(t>beta||t<alpha)return t;
				if(step==1)Min=min(Min,t);
				else Max=max(Max,t);
			}
	sort(son[now.number].begin(),son[now.number].end(),cmp);
	if(getstep(tree[now.number])==1)reverse(son[now.number].begin(),son[now.number].end());
	if(k>2)
	{
		Min=1e9,Max=-1e9;NODE=nd;
		vector<int>SON;
		for(int i=0;i<5;i++)
		{
			NODE++;BOARD next=now;next.number=NODE;
			SON.push_back(NODE);
			next.stepx=ndx[son[now.number][i]];next.stepy=ndy[son[now.number][i]];
			next.a[next.stepx][next.stepy]=step;next.win=check(next,next.stepx,next.stepy);
			int t=step==1?dfs(next,k+1,Nk,alpha,Min):dfs(next,k+1,Nk,Max,beta);
			if(step==1)Min=min(Min,t);
			else Max=max(Max,t);
		}
		son[now.number]=SON;
	}
	
	tree[now.number].score=(step==1?Min:Max);
	return tree[now.number].score;
}
BOARD empty_board()
{
	BOARD empty;
	for(int i=0;i<10;i++)for(int j=0;j<10;j++)empty.a[i][j]=0;empty.number=1;empty.win=0;
	return empty;
}
void print_board_all(int x,int y,BOARD z)
{
	setcolor(getstep(z)==1?RED:BLUE);
	setfillcolor(WHITE);
	fillrect(x,y,x+300,y+300);
	x+=10;y+=10;
	setcolor(BLACK);
	int t=270/10;
	for(int i=x;i<=x+280;i+=t)line(i,y,i,y+280);
	for(int j=y;j<=y+280;j+=t)line(x,j,x+280,j);
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
			if(z.a[i][j]==1)
			{
				setcolor(BLUE);setlinewidth(2);
				circle(x+i*t+t/2,y+j*t+t/2,t/2-1);setlinewidth(1);
			}
	else if(z.a[i][j]==-1)
	{
		setcolor(RED);
		setlinewidth(3);
		line(x+t*i+2,y+t*j+2,x+t*i+t-2,y+t*j+t-2);
		line(x+t*i+2,y+t*j+t-2,x+t*i+t-2,y+t*j+2);
		setlinewidth(1);
	}
}
void print_board_step(int x,int y,BOARD z)
{
	setcolor(getstep(z)==1?RED:BLUE);
	setfillcolor(WHITE);
	fillrect(x,y,x+100,y+40);
	x+=20;y+=10;
	setcolor(BLACK);
	if(z.stepx==0&&z.stepy==0);else
		outtextxy(x,y,("("+to_string(z.stepx+1)+","+to_string(z.stepy+1)+")").c_str());
}
void change_board(int x,int y,BOARD &z)
{
	x+=10;y+=10;
	int t=270/10;
	for(int i=0;i<10;i++)
		for(int j=0;j<10;j++)
			if(mx>x+t*i&&mx<x+t*i+t&&my>y+t*j&&my<y+t*j+t)
			{
				if(Dr)z.a[i][j]=getstep(z);
			}
}
void print_line()
{
	setcolor(BLACK);
	for(int i=1;i<=LN;i++)line(node[LINE[i][0]].x+50,node[LINE[i][0]].y+20,node[LINE[i][1]].x+50,node[LINE[i][1]].y+20);
}
void mousedata()
{
	if(Dr==0)LOCK=0;
	Dl=0;Rc=0;
	while(mousemsg())
	{
		mouse_msg m=getmouse();
		if(m.is_move())mx=m.x,my=m.y;
		if(m.is_down()&&m.is_mid())Dl=1;
		if(m.is_down()&&m.is_left())Dr=1;
		if(m.is_up()&&m.is_left())Dr=0;
		if(m.is_down()&&m.is_right())Rc=1;
	}	
}

int main()
{
	initgraph(1000,600);setbkcolor(WHITE);setcolor(BLACK);
	BOARD empty=empty_board();
	while(1)
	{
		setcaption("游玩模式（点击右键AI开始计算，左键下棋）");
		Rc=0;
		cleardevice();
		while(Rc==0)
		{
			print_board_all(0,0,empty);
			change_board(0,0,empty);
			mousedata();
			if(Dl)empty=empty_board();
			delay_ms(100);
		}
		for(int i=1;i<=NODE;i++)
		{
			show[i]=0;tree[i].number=0;tree[i].win=0;
			son[i].clear();node[i].SON=0;
		}
		NODE=1;LN=0;
		dfs(empty,1,3,-10000,10000);
		setcaption("显示模式（点击右键编辑初始棋盘，中键展开，左键移动）");
		cout<<"TOTAL:"<<NODE<<endl;
		int t=0;
		node[1].y=250;node[1].x=5;show[1]=1;Rc=0;int lc=1;
		empty=tree[son[1].back()];empty.number=1;empty.score=0;
	}
}
wangyuhan2010
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
在线AI智能益智五子棋网站源码
08-15
在线AI智能益智五子棋网站源码是一个利用现代Web技术构建的互动游戏平台，它结合了HTML5、CSS3和JavaScript，为用户提供了一个与人工智能对战的五子棋游戏体验。这个源码的独特之处在于，尽管功能完整，但其核心文件...
基于C++的AI五子棋游戏项目源码
03-20
本资源为基于C++的AI五子棋游戏项目源码，此源码可以直接下载运行。本项目基于C++开发，完成了棋手与AI的对弈，胜负判定，音效播放等等功能，AI下棋能力达到了中级棋手的水平，也可以通过进一步对价值评分的修改来使...
基于博弈树的开源五子棋AI教程[1 位棋盘]
Broken Geeker
12-20 1463
一般而言一组二维数组就可以充分的表示棋盘信息，但是在后续棋盘静态评估的需求中发现，本文需要对棋盘的四个方向上评估出基础棋型。因而从不同角度冗余的描述棋盘信息就是必要的。
最新AIGC系统源码-ChatGPT商业版系统源码，自定义ChatGPT指令Promp提示词，AI绘画系统，AI换脸、多模态识图理解文档分析
CodeRunning的博客
06-25 2517
SparkAi创作系统是一款基于ChatGPT和Midjourney开发的智能问答和绘画系统，提供一站式 AI B/C 端解决方案，涵盖AI大模型提问、AI绘画、文档分析、图像识别和理解、TTS & 语音识别、AI换脸等多项功能。它支持GPTs应用和Prompt自定义预设应用，配备插件系统，并即将推出AI视频生成和AI音乐生成功能。该系统兼容OpenAI-GPT全模型及国内所有AI模型，具备GPT-4大模型支持、联网提问、DALL-E3文本生成图像、GPT4-All联网搜索模型、思维导图、会员套餐、分销系统
基于Python的博弈树搜索人机交互五子棋人工智能实验
毕业作品网站
02-01 1819
需要注意的是，根节点没有父节点，故父节点的α和β值分别设置为负无穷和正无穷。叶子节点不需要向下拓展，而是直接进行打分。打分同时作为该叶子节点的。值即可将叶子节点也视作中间节点，方便统一处理。人工智能实验博弈树搜索 1。人工智能实验博弈树搜索。
基于博弈树的开源五子棋AI教程及源码分享[开篇]
Broken Geeker
12-20 1504
五子棋是一个老少咸宜,复杂度相对较低游戏，本篇教程便是使用传统的博弈树的知识和一些棋类AI的经典算法来实现一个有一定算力AI。AI可以使用QT编写，在6核的家用笔记本在分支因子（搜索窗口的宽度）为10的情况下，6层深度可以在1s内搜索完成，8层深度可以在4s内完成。这里优先给出一个其中使用到的关键技术，
人工智能大作业项目报告和源码——五子棋对战系统 人工智能 java
安卓精品项目源码
06-03 691
对于每一个点击事件，我们将其转化为棋盘之中可视化的黑白棋子交替博弈，通过坐标推算其位置，通过算法提供若干可能的应对方法，最后，通过搜索技术在可能解中迅速找到最优解，并推理出指定的下棋位置。最后，我们完成了分词功能，根据一段五子棋技巧文本，进行分词，并形成一个分词结果的词云图片。当然，本学期所学知识并非仅此而已，例如遗传算法、粒子群算法、蚁群算法等优化算法、知识表示的框架表示法、几类经典的的机器学习模式、模糊推理的过程、通过例题练习，查看神经网络学习结果与反馈机制的关系等，这些都给我们留下了很深的印象；
基于Python和C++实现的人工智能五子棋游戏 课程报告+源码
毕业作品网站
05-13 1275
目录 1监督学习 1 1.1问题描述 1 1.2方法描述 1 1.3步骤描述 1 1.4结果分析 2 2博弈搜索 3 2.1问题描述 3 2.2方法描述 3 2.3原理描述 3 2.4步骤描述 3 2.5结果分析 4 3进化计算 4 3.1问题描述 4 3.2方法描述 4 3.3原理描述 4 3.4步骤描述 4 3.5结果分析 5 4强化学习 5 4.1问题描述 5 4.2方法描述 6 4.3原理描述 6 4.4步骤描述 7 4.5结果分析 8 1监督学习 1.1问题描述 能够用拍照方式识别五子棋下棋过程中
2023 智能AI在线益智五子棋网站源码
01-30 2412
本源码基于Html5 CSS3 JavaScript，index.html已被压缩到仅一行代码实现所有功能，测试正常无外部资源，源码无加密，理论不会和谐可长期使用。
html+css+js写的AI五子棋游戏（附源码）
忧郁的蛋的专栏
11-01 6458
首先在桌面新建一个文本文档，然后把完整代码复制进去，保存并关闭。接着把文件的后缀改为html，双击即可看到游戏界面。本程序是基于html+css+js写的，没学过前端或者没有编辑器的朋友不要着急，只要有电脑就可以完整运行此项目。点击一个格子就可以下棋了，你下完一步AI会自动下，加油！如果不使用一些技巧，还是很难战胜计算机的，快去试试吧。
基于C++的人机对弈的五子棋AI程序
毕业作品网站
05-09 2646
实验报告：实验报告要求清晰简洁，重点突出，重点介绍马尔科夫过程实现的策略方法，使用提供的模板，中文撰写，导出为 pdf，长度不超过 6 页，此部分占本次作业总分的 30%。实验报告：清晰简洁，重点突出，重点介绍搜索部分实现的策略及方法，使用提供的模板，中文撰写，导出为 pdf，长度不超过 6 页，此部分占本次作业总分的 30%。AI 从蓝色的起点出发，找到一条到达红色终点的路，灰色格子为陷阱（走到陷阱立刻回到起点），黑色格子为障碍（障碍同边界相同，走到障碍或边界返回上一步所在位置）
html五子棋游戏（附源码）
热门推荐
皮小孩的博客
01-18 1万+
html+css+js实现五子棋人机对战，有完整源码。
人工智能大作业五子棋源码.zip
06-05
人工智能大作业五子棋源码。共分为四个小问题。 棋盘识别：从对局棋盘图片识别棋局落子情况，识别结果为15*15的棋盘矩阵 博弈算法：五子棋对弈AI，用α-β搜索实现 进化学习：用神经网络作为2中的评估函数，以...
微信小程序五子棋游戏AI实现方法【附demo源码下载】
01-03
五子棋AI篇DEMO 效果图 原理 1. 将棋盘中能够胜利的五子连珠方法遍历一个数组； 2. 当AI持棋时，遍历棋盘中所有棋子的空位； 3. 如果用户落子该位置，给用户该位置的五连珠方式进行加分：1连10分，2连20分，3连40分...
五子棋的脱机的AI源码
02-26
在这个数字化时代，将五子棋与人工智能（AI）结合是常见的实践，让计算机能够与人类玩家进行智能对战。"五子棋的脱机的AI源码"就是这样的一个项目，它允许在本地环境中运行，无需网络连接，提供了JavaScript实现的AI...
2024钉钉杯A题思路详解
最新发布
全栈川川
07-26 1493
2024钉钉杯思路
随机数种子的作用
帆的博客
07-23 1312
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
常见的文心一言的指令
知码客
07-25 1047
文心一言，作为百度研发的预训练语言模型“ERNIE 3.0”的一项功能，能够与人对话互动，回答问题，协助创作，高效便捷地帮助人们获取信息、知识和灵感。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值