五子棋ai算法
㈠ 求 用于五子棋AI的 α—β 剪枝搜索算法
int ab(int n,int a,int b)
{
int temp;
if(n<=0)
return (评价函数); /*评价函数*/
for(每一个走法)
{
（产生节点函数）；
temp=-ab(n-1,-b,-a);
(撤消产生的节点函数);
if(temp>a)
a=temp;(此处可保留搜索的最佳位置)
if(a>b)
break;
}
return a;
}
㈡ 求vc简单的五子棋AI算法
我有个简单的思路：
先定义一条线上棋子的各种布局，比如初步定义长度为五个子
◎◎◎◎●
◎◎●◎×
◎●◎××
◎×◎×◎
等等。白圈是自己的子，黑圈是对方的子，叉子是未走的格子。
程序里有个布局表，再定义各个布局的分数，比如连五最99分，连三30分等等。
当机器走时，在空格放入一子，然后扫描每条直线，匹配布局，然后累计得分。
逐个放子，得分最高的那个位置，作为下一步的走法。
不断调整得分表，可以提高程序胜率。
大概是这个意思。抛砖引玉。
㈢ 有谁知道五子棋比较NB的人工智能算法，用VB实现，，急求！！！！
'在窗体上加入以下控件
'image1(0),image1(0) - 黑白棋图片
'image2,image3(0)
'form中的picture图片为棋盘。因无法上传，请自行领会。
Option Explicit
Dim I, J, K, Counter, Firstmoved, Rt, Gen, r, flag As Integer
Dim Grid(225), H(224), V(224), RL(224), LR(224), Tb(2), Order(225) As Integer
Private Sub Form_Initialize()
lblHelp.Top = 0
lblHelp.Left = 0
Image1(0).Top = -1000
Image1(1).Top = -1000
lblHelp.Left = -lblHelp.Width
lblHelp = vbCrLf + vbCrLf + " 游戏帮助" + vbCrLf _
+ vbCrLf + vbCrLf + "●游戏规则:黑方先行,轮流弈子,任一方向先连成五子者胜." _
+ vbCrLf + vbCrLf + vbCrLf + "●操作提示:①可选择[先后]、[难度]和[对手]菜单设置游戏," _
+ vbCrLf + vbCrLf + " 只有按[游戏]->[开始]后才可在棋盘上落子." _
+ vbCrLf + vbCrLf + " ②按[游戏]->[清盘]可重玩并设置游戏." _
+ vbCrLf + vbCrLf + " ③落子后按[动作]菜单下的选择可任意悔棋和恢复." _
+ vbCrLf + vbCrLf + " ④各功能菜单都提供了快捷键(Alt+相应字母)." _
+ vbCrLf + vbCrLf + vbCrLf + "●有什么问题请与本人联系.电子邮件:[email protected]." _
+ vbCrLf + vbCrLf + vbCrLf + "●本页面单击后隐藏."
End Sub
Private Sub Form_Resize()
Me.Height = 5800
Me.Width = 5100
End Sub
Private Sub lblHelp_Click()
lblHelp.Visible = False
End Sub
Private Sub mnuAfter_Click()
Firstmoved = 0
mnuAfter.Checked = True
mnuFirst.Checked = False
End Sub
Private Sub Form_Load()
Dim I As Integer
For I = 1 To 224
Load Image3(I) '加载棋子控件
Image3(I).Top = (I \ 15) * 22 + 5
Image3(I).Left = (I Mod 15) * 22 + 5
Image3(I).Visible = True
Next
Ini
End Sub
'游戏初始化
Sub Ini()
For I = 0 To 224
Image3(I) = Image2
Image3(I).Enabled = False
Grid(I) = 0
V(I) = 0
H(I) = 0
LR(I) = 0
RL(I) = 0
Next I
mnuBack.Enabled = False
Counter = 0
Gen = 0
If mnuAfter.Checked = True Then
Firstmoved = 0
Else
Firstmoved = 1
End If
mnuStart.Enabled = True
End Sub
'一方是否可获胜
Function LineWin(Piece As Integer) As Integer
Dim mun As Integer
LineWin = 225
'五子一线
mun = Piece * 5
For I = 0 To 224
If H(I) = mun Or V(I) = mun Or RL(I) = mun Or LR(I) = mun Then
LineWin = 225 + Piece
Exit Function
End If
Next I
'四子一线
mun = Piece * 4
For I = 0 To 224
If H(I) = mun Then
For K = 0 To 4
If Grid(I + K) = 0 Then LineWin = I + K: Exit Function
Next K
End If
If V(I) = mun Then
For K = 0 To 4
If Grid(I + K * 15) = 0 Then LineWin = I + K * 15: Exit Function
Next K
End If
If RL(I) = mun Then
For K = 0 To 4
If Grid(I + K * 14) = 0 Then LineWin = I + K * 14: Exit Function
Next K
End If
If LR(I) = mun Then
For K = 0 To 4
If Grid(I + K * 16) = 0 Then LineWin = I + K * 16: Exit Function
Next K
End If
Next I
End Function
'计算机走棋
Sub ComputerMove()
Dim ToMove As Integer
If Counter = 0 Then
Randomize
I = Int(Rnd * 7 + 4)
J = Int(Rnd * 7 + 4)
If Grid(I * 15 + J) = 0 Then ToMove = I * 15 + J
Else
If mnuLower.Checked = True Then ToMove = Defend Else ToMove = Attempt
End If
Counter = Counter + 1
If Firstmoved = 0 Then Image3(ToMove) = Image1(0) Else Image3(ToMove) = Image1(1)
Grid(ToMove) = 2
Order(Counter) = ToMove
LineGen ToMove, 6
If LineWin(6) = 231 Then
MsgBox "您输了!"
Ini
Exit Sub
End If
If Counter = 225 Then
MsgBox "和棋"
Ini
Exit Sub
End If
End Sub
'低级模式
Function Defend() As Integer
Rt = LineWin(6)
If Rt < 225 Then Defend = Rt: Exit Function
Rt = LineWin(1)
If Rt < 225 Then Defend = Rt: Exit Function
'查找落子位置
Rt = FindBlank
If Rt < 225 Then Defend = Rt: Exit Function
End Function
'悔棋
Private Sub mnuBack_Click()
mnuComeback.Enabled = True
If (Counter + Firstmoved) Mod 2 = 0 Then Rt = -1 Else Rt = -6
Grid(Order(Counter)) = 0
Image3(Order(Counter)) = Image2
LineGen Order(Counter), Rt
Counter = Counter - 1
If mnuComputer.Checked = True Then
Grid(Order(Counter)) = 0
Image3(Order(Counter)) = Image2
LineGen Order(Counter), -1
Counter = Counter - 1
Else
flag = 1 - flag
End If
r = r + 1
If Counter = 1 And Firstmoved = 0 And mnuComputer.Checked = True Then mnuBack.Enabled = False
If Counter = 0 Then mnuBack.Enabled = False
End Sub
'恢复棋子
Private Sub mnuComeback_Click()
mnuBack.Enabled = True
Counter = Counter + 1
If (Counter + Firstmoved) Mod 2 = 0 Then
Grid(Order(Counter)) = 1
Image3(Order(Counter)) = Image1(1 - Firstmoved)
LineGen Order(Counter), 1
Else
Grid(Order(Counter)) = 2
Image3(Order(Counter)) = Image1(Firstmoved)
LineGen Order(Counter), 6
End If
If mnuComputer.Checked = True Then
Counter = Counter + 1
Grid(Order(Counter)) = 2
Image3(Order(Counter)) = Image1(Firstmoved)
LineGen Order(Counter), 6
Else
flag = 1 - flag
End If
r = r - 1
If r = 0 Then mnuComeback.Enabled = False
End Sub
Private Sub mnuComputer_Click() '对手
mnuComputer.Checked = True '电脑
mnuHuman.Checked = False '棋手
End Sub
Private Sub mnuClear_Click() '清盘
Ini
mnuFirst.Enabled = True
mnuAfter.Enabled = True
mnuLower.Enabled = True
mnuHigher.Enabled = True
mnuComputer.Enabled = True
mnuHuman.Enabled = True
End Sub
Private Sub mnuHuman_Click()
mnuHuman.Checked = True
mnuComputer.Checked = False
End Sub
Private Sub mnuStart_Click() '开始
lblHelp.Visible = False
For I = 0 To 224
Image3(I).Enabled = True
Next I
mnuFirst.Enabled = False
mnuAfter.Enabled = False
mnuLower.Enabled = False
mnuHigher.Enabled = False
mnuComputer.Enabled = False
mnuHuman.Enabled = False
If Firstmoved = 0 And mnuComputer.Checked = True Then ComputerMove
If Firstmoved = 0 And mnuHuman.Checked = True Then flag = 1 Else flag = 0
mnuStart.Enabled = False
End Sub
'玩家走棋
Private Sub image3_Click(Index As Integer)
If Grid(Index) <> 0 Then Exit Sub
Counter = Counter + 1
If Firstmoved = 0 Then
Image3(Index) = Image1(1 - flag)
Else
Image3(Index) = Image1(flag)
End If
Grid(Index) = 1 + flag
Order(Counter) = Index
mnuBack.Enabled = True
mnuComeback.Enabled = False
r = 0
LineGen Index, (1 + flag * 5)
If LineWin(1 + flag * 5) = 226 + flag * 5 Then
If flag = 0 Then MsgBox "您赢了!" Else MsgBox "您输了!"
Ini
Exit Sub
End If
If Counter = 225 Then
MsgBox "和棋"
Ini
Exit Sub
End If
If mnuComputer.Checked = True Then ComputerMove Else flag = 1 - flag
End Sub
'查找可以落子的空位
Function FindBlank() As Integer
Dim wz, fs, lz, RndNum As Integer
fs = -10000
For wz = 0 To 224
If Grid(wz) = 0 Then
Grid(wz) = 2
LineGen wz, 6
Rt = Gen
If Rt > fs Then fs = Rt: lz = wz
Grid(wz) = 0
LineGen wz, -6
End If
Next wz
FindBlank = lz
End Function
'高级模式
Function Attempt() As Integer
Dim wz As Integer
Rt = LineWin(6)
If Rt < 225 Then Attempt = Rt: Exit Function
Rt = LineWin(1)
If Rt < 225 Then Attempt = Rt: Exit Function
'查找落子位置
Rt = linethree(6)
If Rt < 225 Then Attempt = Rt: Exit Function
Rt = linethree(1)
If Rt < 225 Then
Grid(Tb(0)) = 2
LineGen Tb(0), 6
Rt = Gen: wz = Tb(0)
Grid(Tb(0)) = 0
LineGen Tb(0), -6
Grid(Tb(1)) = 2
LineGen Tb(1), 6
If Rt < Gen Then Rt = Gen: wz = Tb(1)
Grid(Tb(1)) = 0
LineGen Tb(1), -6
Grid(Tb(2)) = 2
LineGen Tb(2), 6
If Rt < Gen Then Rt = Gen: wz = Tb(2)
Grid(Tb(2)) = 0
LineGen Tb(2), -6
Attempt = wz
Exit Function
End If
Rt = FindBlank
If Rt < 225 Then Attempt = Rt: Exit Function
End Function
Private Sub mnuFirst_Click() '先后手
Firstmoved = 1
mnuAfter.Checked = False
mnuFirst.Checked = True
End Sub
Private Sub mnuHigher_Click()
mnuLower.Checked = False
mnuHigher.Checked = True
End Sub
Private Sub mnuLower_Click() '难度
mnuLower.Checked = True
mnuHigher.Checked = False
End Sub
'局势评估
Function LineGen(ij, Piece)
Dim b, e, mun As Integer
I = ij \ 15
J = ij Mod 15
'横线影响
b = IIf(J - 4 > 0, J - 4, 0)
e = IIf(J > 10, 10, J)
For K = b To e
mun = H(I * 15 + K)
If mun < 6 Then Gen = Gen + mun * 2 ^ mun
If mun > 5 And mun Mod 6 = 0 Then mun = mun \ 6 - 1: Gen = Gen - mun * 2 ^ mun
H(I * 15 + K) = H(I * 15 + K) + Piece
mun = H(I * 15 + K)
If mun < 6 Then Gen = Gen - mun * 2 ^ mun
If mun > 5 And mun Mod 6 = 0 Then mun = mun \ 6 - 1: Gen = Gen + mun * 2 ^ mun
Next K
'竖线影响
b = IIf(I - 4 > 0, I - 4, 0)
e = IIf(I > 10, 10, I)
For K = b To e
mun = V(K * 15 + J)
If mun < 6 Then Gen = Gen + mun * 2 ^ mun
If mun > 5 And mun Mod 6 = 0 Then mun = mun \ 6 - 1: Gen = Gen - mun * 2 ^ mun
V(K * 15 + J) = V(K * 15 + J) + Piece
mun = V(K * 15 + J)
If mun < 6 Then Gen = Gen - mun * 2 ^ mun
If mun > 5 And mun Mod 6 = 0 Then mun = mun \ 6 - 1: Gen = Gen + mun * 2 ^ mun
Next K
'撇线影响
b = IIf(I - 4 > 0, I - 4, 0)
e = IIf(I > 10, 10, I)
b = IIf(b > J + I - IIf(J + 4 > 14, 14, J + 4), b, J + I - IIf(J + 4 > 14, 14, J + 4))
e = IIf(e > J + I - IIf(J > 4, J, 4), J + I - IIf(J > 4, J, 4), e)
For K = b To e
mun = RL(K * 15 + I + J - K)
If mun < 6 Then Gen = Gen + mun * 2 ^ mun
If mun > 5 And mun Mod 6 = 0 Then mun = mun \ 6 - 1: Gen = Gen - mun * 2 ^ mun
RL(K * 15 + I + J - K) = RL(K * 15 + I + J - K) + Piece
mun = RL(K * 15 + I + J - K)
If mun < 6 Then Gen = Gen - mun * 2 ^ mun
If mun > 5 And mun Mod 6 = 0 Then mun = mun \ 6 - 1: Gen = Gen + mun * 2 ^ mun
Next K
'捺线影响
b = IIf(I - 4 > 0, I - 4, 0)
e = IIf(I > 10, 10, I)
b = IIf(b > I - J + IIf(J - 4 > 0, J - 4, 0), b, I - J + IIf(J - 4 > 0, J - 4, 0))
e = IIf(e > I - J + IIf(J > 10, 10, J), I - J + IIf(J > 10, 10, J), e)
For K = b To e
mun = LR(K * 15 - I + J + K)
If mun < 6 Then Gen = Gen + mun * 2 ^ mun
If mun > 5 And mun Mod 6 = 0 Then mun = mun \ 6 - 1: Gen = Gen - mun * 2 ^ mun
LR(K * 15 - I + J + K) = LR(K * 15 - I + J + K) + Piece
mun = LR(K * 15 - I + J + K)
If mun < 6 Then Gen = Gen - mun * 2 ^ mun
If mun > 5 And mun Mod 6 = 0 Then mun = mun \ 6 - 1: Gen = Gen + mun * 2 ^ mun
Next K
End Function
'是否存在三子一线（可发展成五子联线）
Function linethree(Piece As Integer) As Integer
Dim mun As Integer
linethree = 225
'三子一线
mun = Piece * 3
For I = 0 To 224
If H(I) = mun Then
If Grid(I) = 0 Then
If I Mod 15 < 10 Then
If Grid(I + 5) = 0 Then
For K = 1 To 4
If Grid(I + K) = 0 Then
Tb(0) = I + K
Tb(1) = I
Tb(2) = I + 5
linethree = Tb(0)
Exit Function
End If
Next K
End If
End If
End If
End If
If V(I) = mun Then
If Grid(I) = 0 Then
If (I \ 15) < 10 Then
If Grid(I + 75) = 0 Then
For K = 1 To 4
If Grid(I + K * 15) = 0 Then
Tb(0) = I + K * 15
Tb(1) = I
Tb(2) = I + 75
linethree = Tb(0)
Exit Function
End If
Next K
End If
End If
End If
End If
If RL(I) = mun Then
If Grid(I) = 0 Then
If (I \ 15) < 10 And I Mod 15 > 4 Then
If Grid(I + 70) = 0 Then
For K = 1 To 4
If Grid(I + K * 14) = 0 Then
Tb(0) = I + K * 14
Tb(1) = I
Tb(2) = I + 70
linethree = Tb(0)
Exit Function
End If
Next K
End If
End If
End If
End If
If LR(I) = mun Then
If Grid(I) = 0 Then
If (I \ 15) < 10 And I Mod 15 < 10 Then
If Grid(I + 80) = 0 Then
For K = 1 To 4
If Grid(I + K * 16) = 0 Then
Tb(0) = I + K * 16
Tb(1) = I
Tb(2) = I + 80
linethree = Tb(0)
Exit Function
End If
Next K
End If
End If
End If
End If
Next I
End Function
Private Sub munHelp_Click() '帮助
lblHelp.Visible = True
End Sub
㈣ 求五子棋的人工智能的算法描述~~~
可以采用这样的笨算法，运行起来慢点，但是很简单易懂，而且效果很好。如果能够加以优化，则其实是很好的算法：
1、首先遍历整个棋盘，找到一个可以落子的点，然后假设自己在该点落子，再然后判断如果棋子落到这个点上后会对自己有什么利益，比如会不会形成冲4活三、双活三等等，（事先将冲四活三、双活三等效果定义上利益值，当然，如果是五个子连起来了的话，利益值要被定义成最高，最好是无穷大的），将各种效果的利益值相加，得到己方的利益值。
2、将角色互换一下，重复第一步，得到对方的利益值（其实是递桂算法）。
3、将己方的利益值减去对方的利益值，得到该点的总利益值。
4、整个棋盘所有能落子的点都计算出利益值之后，找出利益值最大的那个点，将棋子落到该点。
当然，这个算法可以有很大程度的优化，比如，如果没有相邻的棋子，可以放弃该点。还有一旦找出可以胜利的点，就不再继续往下计算。。。。
模拟算法：
int liyi(角色, 层次）
{
if(层次=0)
return 0;
for(第一个可以落子的点 到 最后一个可以落子的点）
{
int 利益,最大利益;
//递桂...
利益 = 获取本角色利益值() - liyi(角色=相反角色,层次-1);
if(利益>最大利益)
{
最大利益 = 利益；
保存该点。
}
落子到所保存的点。
}
㈤ 我想了解一下五子棋AI A*算法，可是怎么都看不明白啊~谁能详细讲讲啊
/*源程序太多了，要的话给油箱*/
#DEFINE NROW 15
tmpzth="" && 行状态
tmpztl="" && 列状态
for i=1 to NROW
for j=1 to NROW
tmpzth=tmpzth+Azt(i,j)
tmpztl=tmpztl+Azt(j,i)
endfor
&& 行判断
do case
********** y 连 5 ***********
case "nyyyy" $ tmpzth
thisform.plc_h(i,j,at("nyyyy",tmpzth),0 ,1) && 1 的得出方法 ：at("n","nyyyy")
case "ynyyy" $ tmpzth
thisform.plc_h(i,j,at("ynyyy",tmpzth),1 ,1)
case "yynyy" $ tmpzth
thisform.plc_h(i,j,at("yynyy",tmpzth),2 ,1)
case "yyyny" $ tmpzth
thisform.plc_h(i,j,at("yyyny",tmpzth),3 ,1)
case "yyyyn" $ tmpzth
thisform.plc_h(i,j,at("yyyyn",tmpzth),4 ,1)
********** b 连 5 **********
case "nbbbb" $ tmpzth
thisform.plc_h(i,j,at("nbbbb",tmpzth),0 ,2)
case "bnbbb" $ tmpzth
thisform.plc_h(i,j,at("bnbbb",tmpzth),1 ,2)
case "bbnbb" $ tmpzth
thisform.plc_h(i,j,at("bbnbb",tmpzth),2 ,2)
case "bbbnb" $ tmpzth
thisform.plc_h(i,j,at("bbbnb",tmpzth),3 ,2)
case "bbbbn" $ tmpzth
thisform.plc_h(i,j,at("bbbbn",tmpzth),4 ,2)
********** y 冲 4 ***********
case "nynyyn" $ tmpzth
thisform.plc_h(i,j,at("nynyyn",tmpzth),2 ,3)
case "nyynyn" $ tmpzth
thisform.plc_h(i,j,at("nyynyn",tmpzth),3 ,3)
case "nyyynn" $ tmpzth
thisform.plc_h(i,j,at("nyyynn",tmpzth),4 ,3)
case "nnyyyn" $ tmpzth
thisform.plc_h(i,j,at("nnyyyn",tmpzth),1 ,3)
********* b 冲 4 ************
case "nbnbbn" $ tmpzth
thisform.plc_h(i,j,at("nbnbbn",tmpzth),2 ,5)
case "nbbnbn" $ tmpzth
thisform.plc_h(i,j,at("nbbnbn",tmpzth),3 ,5)
case "nbbbnn" $ tmpzth
thisform.plc_h(i,j,at("nbbbnn",tmpzth),4 ,5)
case "nnbbbn" $ tmpzth
thisform.plc_h(i,j,at("nnbbbn",tmpzth),1 ,5)
********** y 连 4 ***********
case "nnyyyb" $ tmpzth
thisform.plc_h(i,j,at("nnyyyb",tmpzth),1 ,4)
case "nynyyb" $ tmpzth
thisform.plc_h(i,j,at("nynyyb",tmpzth),2 ,4)
case "nyynyb" $ tmpzth
thisform.plc_h(i,j,at("nyynyb",tmpzth),3 ,4)
case "nyyynb" $ tmpzth
thisform.plc_h(i,j,at("nyyynb",tmpzth),1 ,4)
case "byyynn" $ tmpzth
thisform.plc_h(i,j,at("byyynn",tmpzth),4 ,4)
case "byynyn" $ tmpzth
thisform.plc_h(i,j,at("byynyn",tmpzth),3 ,4)
case "bynyyn" $ tmpzth
thisform.plc_h(i,j,at("bynyyn",tmpzth),2 ,4)
case "bnyyyn" $ tmpzth
thisform.plc_h(i,j,at("bnyyyn",tmpzth),1 ,4)
********** b 连 4 ***********
case "nnbbby" $ tmpzth
thisform.plc_h(i,j,at("nnbbby",tmpzth),1 ,9)
case "nbnbby" $ tmpzth
thisform.plc_h(i,j,at("nbnbby",tmpzth),2 ,9)
case "nbbnby" $ tmpzth
thisform.plc_h(i,j,at("nbbnby",tmpzth),3 ,9)
case "nbbbny" $ tmpzth
thisform.plc_h(i,j,at("nbbbny",tmpzth),1 ,9)
case "ybbbnn" $ tmpzth
thisform.plc_h(i,j,at("ybbbnn",tmpzth),4 ,9)
case "ybbnbn" $ tmpzth
thisform.plc_h(i,j,at("ybbnbn",tmpzth),3 ,9)
case "ybnbbn" $ tmpzth
thisform.plc_h(i,j,at("ybnbbn",tmpzth),2 ,9)
case "ynbbbn" $ tmpzth
thisform.plc_h(i,j,at("ynbbbn",tmpzth),1 ,9)
********** y 冲 3 ***********
case "nynynn" $ tmpzth
thisform.plc_h(i,j,at("nynynn",tmpzth),2 ,6)
case "nnyynn" $ tmpzth
thisform.plc_h(i,j,at("nnyynn",tmpzth),4 ,6)
********* b 冲 3 ************
case "nbnbnn" $ tmpzth
thisform.plc_h(i,j,at("nbnbnn",tmpzth),2 ,8)
case "nnbbnn" $ tmpzth
thisform.plc_h(i,j,at("nnbbnn",tmpzth),4 ,8)
********** 1个 ***********
case "nnynnn" $ tmpzth
thisform.plc_h(i,j,at("nnynnn",tmpzth),3, 7)
case "nnnynn" $ tmpzth
thisform.plc_h(i,j,at("nnnynn",tmpzth),2 ,7)
case "nnbnnn" $ tmpzth
thisform.plc_h(i,j,at("nnbnnn",tmpzth),3 ,10)
case "nnnbnn" $ tmpzth
thisform.plc_h(i,j,at("nnnbnn",tmpzth),2 ,10)
endcase
&& 列判断
do case
********** 5个 ***********
case "nyyyy" $ tmpztl
thisform.plc_l(i,j,at("nyyyy",tmpztl),0 ,1) && 1 的得出方法 ：at("n","nyyyy")
case "ynyyy" $ tmpztl
thisform.plc_l(i,j,at("ynyyy",tmpztl),1 ,1)
case "yynyy" $ tmpztl
thisform.plc_l(i,j,at("yynyy",tmpztl),2 ,1)
case "yyyny" $ tmpztl
thisform.plc_l(i,j,at("yyyny",tmpztl),3 ,1)
case "yyyyn" $ tmpztl
thisform.plc_l(i,j,at("yyyyn",tmpztl),4 ,1)
case "nbbbb" $ tmpztl
thisform.plc_l(i,j,at("nbbbb",tmpztl),0 ,2)
case "bnbbb" $ tmpztl
thisform.plc_l(i,j,at("bnbbb",tmpztl),1 ,2)
case "bbnbb" $ tmpztl
thisform.plc_l(i,j,at("bbnbb",tmpztl),2 ,2)
case "bbbnb" $ tmpztl
thisform.plc_l(i,j,at("bbbnb",tmpztl),3 ,2)
case "bbbbn" $ tmpztl
thisform.plc_l(i,j,at("bbbbn",tmpztl),4 ,2)
********** 4个 ***********
case "nynyyn" $ tmpztl
thisform.plc_l(i,j,at("nynyyn",tmpztl),2 ,3)
case "nyynyn" $ tmpztl
thisform.plc_l(i,j,at("nyynyn",tmpztl),3 ,3)
case "nyyynn" $ tmpztl
thisform.plc_l(i,j,at("nyyynn",tmpztl),4 ,3)
case "nnyyyn" $ tmpztl
thisform.plc_l(i,j,at("nnyyyn",tmpztl),1 ,3)
case "nbnbbn" $ tmpztl
thisform.plc_l(i,j,at("nbnbbn",tmpztl),2 ,5)
case "nbbnbn" $ tmpztl
thisform.plc_l(i,j,at("nbbnbn",tmpztl),3 ,5)
case "nbbbnn" $ tmpztl
thisform.plc_l(i,j,at("nbbbnn",tmpztl),4 ,5)
case "nnbbbn" $ tmpztl
thisform.plc_l(i,j,at("nnbbbn",tmpztl),1 ,5)
********** 3个 ***********
case "nnyyyb" $ tmpztl
thisform.plc_l(i,j,at("nnyyyb",tmpztl),1 ,4)
case "nynyyb" $ tmpztl
thisform.plc_l(i,j,at("nynyyb",tmpztl),2 ,4)
case "nyynyb" $ tmpztl
thisform.plc_l(i,j,at("nyynyb",tmpztl),3 ,4)
case "nyyynb" $ tmpztl
thisform.plc_l(i,j,at("nyyynb",tmpztl),1 ,4)
case "byyynn" $ tmpztl
thisform.plc_l(i,j,at("byyynn",tmpztl),4 ,4)
case "byynyn" $ tmpztl
thisform.plc_l(i,j,at("byynyn",tmpztl),3 ,4)
case "bynyyn" $ tmpztl
thisform.plc_l(i,j,at("bynyyn",tmpztl),2 ,4)
case "bnyyyn" $ tmpztl
thisform.plc_l(i,j,at("bnyyyn",tmpztl),1 ,4)
case "nnbbby" $ tmpztl
thisform.plc_l(i,j,at("nnbbby",tmpztl),1 ,9)
case "nbnbby" $ tmpztl
thisform.plc_l(i,j,at("nbnbby",tmpztl),2 ,9)
case "nbbnby" $ tmpztl
thisform.plc_l(i,j,at("nbbnby",tmpztl),3 ,9)
case "nbbbny" $ tmpztl
thisform.plc_l(i,j,at("nbbbny",tmpztl),1 ,9)
case "ybbbnn" $ tmpztl
thisform.plc_l(i,j,at("ybbbnn",tmpztl),4 ,9)
case "ybbnbn" $ tmpztl
thisform.plc_l(i,j,at("ybbnbn",tmpztl),3 ,9)
case "ybnbbn" $ tmpztl
thisform.plc_l(i,j,at("ybnbbn",tmpztl),2 ,9)
case "ynbbbn" $ tmpztl
thisform.plc_l(i,j,at("ynbbbn",tmpztl),1 ,9)
********** 2个 ***********
case "nynynn" $ tmpztl
thisform.plc_l(i,j,at("nynynn",tmpztl),2 ,6)
case "nnyynn" $ tmpztl
thisform.plc_l(i,j,at( "nnyynn",tmpztl),4 ,6)
case "nbnbnn" $ tmpztl
thisform.plc_l(i,j,at("nbnbnn",tmpztl),2 ,8)
case "nnbbnn" $ tmpztl
thisform.plc_l(i,j,at("nnbbnn",tmpztl),4 ,8)
********** 1个 ***********
case "nnynnn" $ tmpztl
thisform.plc_l(i,j,at("nnynnn",tmpztl),3, 7)
case "nnnynn" $ tmpztl
thisform.plc_l(i,j,at("nnnynn",tmpztl),2 ,7)
case "nnbnnn" $ tmpztl
thisform.plc_l(i,j,at("nnbnnn",tmpztl),3 ,10)
case "nnnbnn" $ tmpztl
thisform.plc_l(i,j,at("nnnbnn",tmpztl),2 ,10)
endcase
tmpzth=""
tmpztl=""
endfor
㈥ 求五子棋AI算法，空棋位打分那个value函数，打分规则不用说了额，主要是怎么判断活4，冲4，活3等棋局形式
正常一点的想法：
判断自己有没有马上赢的点；
判断对方马上赢的点；
判断己方活三；
判断敌方活三；
判断己方潜在（双活三、双活四、三叉四、……）；
判断对方潜在（……）。
判断己方潜在活三；
判断敌方潜在活三；
任意落子。
疯狂的：
深搜或宽搜，找出赢的几率最大的点。
㈦ C语言五子棋算法
任何一种棋类游戏其关键是对当前棋局是否有正确的评分,评分越准确则电脑的AI越高。五子棋游戏也是如此，但在打分之前，我们先扫描
整个棋盘，把每个空位从八个方向上的棋型填入数组gStyle(2, 15, 15, 8, 2)，其中第一个下标为1时表示黑棋，为2时表示白棋，第二和第三
个下标表示(x,y)，第四个下标表示8个方向，最后一个下标为1时表示棋子数，为2时表示空格数，如：gStyle(1,2,2,1,1)=3表示与坐标(2,2)在第1个方向上相邻的黑棋棋子数为3
gstyle(1,2,2,1,2)=4表示与坐标(2,2)在第1个方向上的最近的空格数为4
在定义方向时，也应该注意一定的技巧，表示两个相反的方向的数应该差4，在程序中我是这样定义的：
Const DIR_UP = 1
Const DIR_UPRIGHT = 2
Const DIR_RIGHT = 3
Const DIR_RIGHTDOWN = 4
Const DIR_DOWN = 5
Const DIR_DOWNLEFT = 6
Const DIR_LEFT = 7
Const DIR_LEFTUP = 8
这样我们前四个方向可以通过加四得到另一个方向的值。如果你还是不太明白，请看下面的图：
---------
---------
---oo----
-ox*xx---
---------
---------
图中的*点从标为(4,4),（打*的位置是空位）,则:
gStyle(2,4,4,1,1)=1在(4,4)点相邻的上方白棋数为1
gStyle(2,4,4,1,2)=2在(4,4)点的上方距上方白棋最近的空格数为2
gStyle(1,4,4,3,1)=2在(4,4)点相邻的右方黑棋数为2
gStyle(1,4,4,3,2)=1在(4,4)点的右方距右方黑棋最近的空格数为3
...一旦把所有空点的棋型值填完，我们很容易地得出黑棋水平方向上点(4,4)的价值，由一个冲1（我把有界的棋称为冲）和活2（两边无界的
棋称为活）组成的。对于而白棋在垂直方向上点(4,4)的价值是一个活1，而在/方向也是活1所以，只要我们把该点的对于黑棋和白棋的价值算出
来，然后我们就取棋盘上各个空点的这两个值的和的最大一点作为下棋的点。然而，对各种棋型应该取什么值呢？我们可以先作如下假设：
Fn 表示先手n个棋子的活棋型，如：F4表示先手活四
Fn'表示先手n个棋子的冲棋型，如：F4'表示先手冲四
Ln 表示后手n个棋子的活棋型，如：L3表示后手活三
Ln'表示后手n个棋子的冲棋型，如：L3'表示后手冲三
.
.
.
根据在一行中的棋型分析，得到如下关系：
L1'<=F1'<L2'<=F2'<=L1<F1<L2<F2<L3'<=F3'<L4'<F4'=F4
从这个关系包含了进攻和防守的关系（当然，这个关系是由我定的，你可以自己定义这些关系）。对这些关系再进一步细化，如在一个可下
棋的点，其四个方向上都有活三，也比不上一个冲四，所以我们可以又得到4*F3<L4'这个关系，同样，我们还可以得到其它的关系，如：4*F2<L3、4*L3<F3...，这些的关系由于你的定法和我的定法制可能不一样，这样计算机的AI也就不一样，最后我们把分值最小的L1'值定为1，则我们就得
到了下面各种棋型的分值，由C语言表示为：
F[2][5]={{0,2,5,50,16000},{0,10,30,750,16000}};
L[2][5]={{0,1,5,50,3750},{0,10,30,150,4000}};
F数组表示先手，第一个下标为0时表示冲型，第二个下标表示棋子数，则F2'对应F[0][2]L数组表示后手，第一个下标为0时表示冲型，第二
个下标表示棋子数，则L2对应F[1][2]Ok，棋型的分值关系确定好了以后，我们把每一个可下点的四个方向的棋型值相加（包括先手和后手的分
值），最后选择一个最大值，并把这一点作为计算机要下的点就OK了:)。后话：
1、得到最大值也许不止一个点，但在我的程序中只选择第一个最大点，当然你可以用于个随机数来决定
选择那一个最大值点，也可以对这些最大值点再作进一步的分析。
2、在这个算法中我只考虑了周围有棋子的点，而其它点我没有考虑。
3、可以再更进一步，用这个算法来预测以后的几步棋，再选择预测值最好的一步，这样电脑的AI就更高了
4、这个算法没有考虑黑棋的禁手（双3、双四和多于五子的连棋）。因为在平时我下的五子棋是没有这些
禁手的。
㈧ 五子棋人工智能算法讲解
五子棋算法可简可繁,要看你对自己五子棋程序智能的要求, 人机对战的意思就是人和电脑下,也就是说电脑会思考如何下棋....其实这才是五子棋程序的核心.如果只实现人与人对战的话,是一件很简单的事情,无非就是绘制棋盘,然后绘制下棋的效果,再写个下棋合法性判断,胜负判断....大概就搞定了....所以核心其实是人机对战的电脑那部分人工智能.这东西吧,可以研究的很多,不过主要的几个设计要点就是搜索算法和估值算法,这两个是最主要的,还有提高电脑思考销率的方法就有多cpu的计算机多线程思考的设计....通过一些手段让电脑变得更像人类棋手的,例如利用一些遗传算法之类的让电脑具有学习能力,可以在失败中吸取教训,开局库,历史启发之类的一大堆......但是总而言之,这一系列算法的设计没有一个标准,只要能让你的电脑下棋下的更聪明,更快那就是好算法.国内有一个叫王晓春的写过一本叫<<pc游戏编程( 人机博弈)>>的书,这是一本研究人机博弈程序很经典的书,书的后面还附了一个五子棋的程序实例,你可以参考一下.下面是csdn的下载地址,你也可以自己去搜一下.http://download.csdn.net/source/1925326