五子棋算法实现

杜思波2008技术大讨论：

前一段时间某个公司给我出了一道作业题，当然，只有做完了这个题目才能够有基本的实习机会，这个题目就是五子棋了。五子棋说起来简单，也比较简单，毕竟现在网上已经有非常成熟的算法了，而如果说五子棋考人面试的话，应该还算是有一定的难度的（虽然思路不是特别难），当然，我在做这个题目的时候，还是发现了很多问题。在博客园上找了一个五子棋的实现，我写的算法基本和他差不多，不过我的AI总没有他那么高，我这就是简单的实现了一下，如下图所示。



在做五子棋这个程序的时候，首先确定一些基本功能，这些功能包括如下。

玩家能够快速开始游戏。

玩家能够更换身份（更换黑棋和白棋）。

玩家能够退出游戏。

其中，玩家能够快速开始游戏，需要考虑玩家当前的身份。例如当玩家为黑棋的时候（玩家先走棋），单击【快速游戏】时玩家能够开始下棋，另外，当玩家为白棋的时候（电脑先走棋），单击【快速游戏】时计算机首先下棋。不仅如此，玩家能够快速更换身份。更换身份后玩家能够进行不同的棋子的选择，从而和电脑进行博弈。
如果玩家希望退出时，可以单击【退出】进行系统退出。

OK，了解了基本的功能后，主要就是算法问题了，这里主要有几个类，这几个类分别为Stones（控制棋子），Boards（控制棋盘以及逻辑），PC（电脑AI的实现），Rules（五子棋规则的实现）。首先也是最重要的，就是Boards类，该类一开始首先需要绘制一个棋盘在窗体中。棋盘是绘制上去的，在Paint方法中实现，示例代码如下所示。




Code
private void Form1_Paint(object sender, PaintEventArgs e)
{
bd.DrawBoard();
}

上述代码使用了Boards的bd类进行棋盘的创建，这里可以看看该类的实现。




Code
public void DrawBoard()
{
Assembly myAssembly = Assembly.GetExecutingAssembly();
Stream myStream = myAssembly.GetManifestResourceStream("FiveStone.board.png");
Bitmap bt = new Bitmap(myStream);
myStream.Close();
mg.DrawImage(bt, 20, 20, bt.Width, bt.Height);

for (int i = 0; i < 15; i++)
{
for (int j = 0; j < 15; j++)
{
if (board[i, j] == 0)
{
stone.DrawStone(i, j, true);
}
if (board[i, j] == 1)
{
stone.DrawStone(i, j, false);
}
}
}
}

由于我们的棋盘是15*15的，那么该函数会在每次重绘的时候进行棋盘中的棋子的绘画。那么棋子怎么表示呢，这里就用-1，0，1进行表示，其中0是白子，而1是黑子，那么-1当然就是没子了，该函数会在每次重绘时进行绘制，从而呈现棋盘上的内容。

在上述代码中，使用了Stones的stone对象，该类的实现如下所示。




Code
public class Stones
{
private Graphics mg;
private Bitmap bs;
private Bitmap ws;

public Stones(Graphics g)
{
Assembly myAssembly = Assembly.GetExecutingAssembly();
Stream bStream = myAssembly.GetManifestResourceStream("FiveStone.black.png");
Stream wStream = myAssembly.GetManifestResourceStream("FiveStone.white.png");
bs = new Bitmap(bStream);
ws = new Bitmap(wStream);
bStream.Close();
wStream.Close();
mg = g;
}

public void DrawStone(int x, int y, bool flag)
{
if (flag)
{
mg.DrawImage(bs, x * 40 + 20, y * 40 + 23, bs.Width, bs.Height);
}
else
{
mg.DrawImage(ws, x * 40 + 20, y * 40 + 23, bs.Width, bs.Height);
}
}
}

代码不做过多的解释，这里的高手一定都知道了，这些内容可以在源代码中下载。OK，在了解了基本的绘制棋盘以及绘制棋子（还有棋子状态的描述），那么就应该描述AI了。AI部分的实现，我从网上看到的资料，大多都是用权值进行描述，当然，这个方法虽然最笨也是最容易实现的。当人下子的时候（通过ON_MONTHDOWN方法），可以在相应的数组空间中进行赋值，例如如果人下的是白子，那么相应的数组位置的值应该等于0，反之等于1。那么当人下子了之后，计算机如何知道该怎么下子呢，计算机当然不知道什么是”双三，”冲四，这里必须通过数学的方法进行实现，（可能网上说的不太清除，我详细的讲一下，也会自己进行记录）如下图所示。



如上图所示，当我们首先在中间下了一个黑子（这里是计算机先下，方便说明，因为如果我先下的话，那么计算机很快就下子了。。），那么计算机就应该计算哪里才是最好的地方，当然，这里只有一个子，计算机的计算就可以随便计算，当然，也有一定的规律性。计算机可能在上图中的1、2、3或者周边的其他地方下子，但是为什么要选这个地方下子？计算机就要找到最好的地方，怎么找最好的地方，就是要找到胜利的”可能性，既然知道计算机要找到可能性，那么怎么找可能性？如下图所示。



如上图所示，在最上面一行，其中是一个连子的可能性。其中占用五个子，那么在最上面一行的可能性有11种（自己数，上图中是一种可能性，依次右移，有11种），这里有15行，那么就是11*15种可能性。同理，从上到下的可能性也是11*15种可能性，而侧边（即左上右下，右上左下的方向），也具有可能性，上图中也描述了，这个可能性希望大家能够自己数一数。

OK，知道了可能性以后，就需要了解计算机怎么判断落子点，上图中在中间下了一个白子，既然下了一个白子，那么周边也是有可能性的。注意，计算机会通过可能性计算你下子周边的可能性，例如上面下了一个白子，周边的连子（即能够形成5个子连子的可能性），都是有的，并且应该相等。当然，在初期，这个相等的值比较多。然后里该位置越远，可能性就越少，计算机就越不会在那个位置下子，例如左下角，大家都知道中间这个点和左下角这个点练成五子的可能性为0，这里计算机也认为为0，那么就不会在这个地方下子，同样，下了多步后，可能性也会被重新计算，如下图所示。



当下了多步之后，例如上面，计算机马上要赢了，那么计算的话，第5个子的位置的权值应该是最高的，即10000，这里可以随意定，越高越好。而其他周边的地方，赢的可能性可能会少一些，可能就是500，同理，在右下边两个黑子那里，由于还是两个黑子，没有构成猥亵，计算机也会认定具备较少的权值，则计算机会下权值最高的点（如果人不堵这个位置），如果人堵了这个点，那么计算就就会继续找权值最高的点（当然，这个时候权值就可能不是上图中所描述的了）。

既然了解了基本原理之后，那么如何计算权值？权值的计算方法比较容易，即从上、下、左上右下、右上左下四个方向寻找连子，如果连子有1个，即可赋值权值100，依次增高，如果连子有4个，那么就应该有最高的权值，即10000。值得注意的是，权值不仅仅包括一个方向，例如”双三或”冲四，在一个点中的不同方向都有多个子的时候，应该加上所有方向的权值。

在计算中，首先需要计算整个棋盘的权值，示例代码如下所示。




Code
public void Down(int[,] board)
{
int[,] q = new int[15, 15];
for (int i = 0; i < 15; i++)
{
for (int j = 0; j < 15; j++)
{
if (board[i, j] != -1)//如果这个位置没有子的话
{
q[i, j] = -1;//权值为-1即可咯
}
else
{
q[i, j] = FindQz(i, j, board);//找权值
}
}
}
ForMax(q);
}

上述代码使用了FindQz方法寻找权值，示例代码如下所示。




Code
public int FindQz(int x,int y,int[,] board)
{
int qz = 0;
int w1 = 10000000;
int w2 = 50000;
int w3 = 10000;
int w4 = 5000;
int w5 = 1000;
int w6 = 500;
int w7 = 100;
int w8 = 50;
int w9 = -100000000;
int[] move = new int[4];
if (mifis)
{
board[x, y] = 0;
}
else
{
board[x, y] = 1;
}
move[0] = Rules.X1(x, y, board);
move[1] = Rules.X2(x, y, board);
move[2] = Rules.X3(x, y, board);
move[3] = Rules.X4(x, y, board);
if (x == 7 && y == 7)
{
qz += 1;
}

for (int i = 0; i < 4; i++)
{
if (Abs(move[i]) == 5)
{
qz += w1;
}
else if (move[i] == 4)
{
qz += w3;
}
else if (move[i] == 3)
{
qz += w5;
}
else if (move[i] == 2)
{
qz += w7;
}

if (mifis)
{
if (Rules.Fails(move, board[x, y]))
{
qz += w9;
}
}
}

if (mifis)
{
board[x, y] = 1;
}
else
{
board[x, y] = 0;
}

move[0] = Rules.X1(x, y, board);
move[1] = Rules.X2(x, y, board);
move[2] = Rules.X3(x, y, board);
move[3] = Rules.X4(x, y, board);

for (int i = 0; i < 4; i++)
{
if (Abs(move[i]) == 5)
{
qz += w2;
}
else if (move[i] == 4)
{
qz += w4;
}
else if (move[i] == 3)
{
qz += w6;
}
else if (move[i] == 2)
{
qz += w8;
}
}
board[x, y] = -1;
return qz;
}

上述代码就不详细解释了，如果有不会的朋友可以逐步运行并查看局部变量的值。其中，Rules中包括计算四个方向的连子的方法，其中一个方法的代码如下所示。




Code
//左右方向
public static int X1(int x, int y, int[,] board)
{
int flag=0;
int count=1;
int i = x + 1;
while(i<15)
{
if (board[x, y] == board[i, y])
{
count++;
i++;
}
else
{
break;
}
}

if (i == 15)
{
flag++;
}
else
{
if (board[i, y] != -1)
{
flag++;
}
}

i = x - 1;
while (i > 0)
{
if (board[x, y] == board[i, y])
{
count++;
i--;
}
else
{
break;
}
}

if (i == -1)
{
flag++;
}
else
{
if (board[i, y] != -1)
{
flag++;
}
}

if (flag == 2)
{
return -count;
}
else
{
if (flag == 1 && count == 3)
{
return -count;
}
else
{
return count;
}
}
}

需要找四个方向，就需要四个方法进行权值的计算，同样在代码中可以看到，这里就不重复张贴。计算了整个棋盘的的权值之后，还需要找到最大的权值点，示例代码如下所示。




Code
public void ForMax(int[,] q)
{
int max=0;
for (int i = 0; i < 15; i++)
{
for (int j = 0; j < 15; j++)
{
if (q[i, j] > max)
{
X = i;
Y = j;
max = q[i, j];
}
}
}
}

找到了最大的权值后，计算机就知道在该点是最好的下子点，即如果计算机在这个位置下子，那么玩家的胜利率就会降低。OK，既然了解了基本的算法及其思路之后，大家应该会写了，这里我归纳一下我做的时候遇到的一些难点。

绘制的时候描点非常难，主要是鼠标点在棋盘中，那个棋子是不是下在那个位置，有可能有点点误差就会下偏，这里要看精确度。

算法实现的时候，进行移动，判断的时候需要不少变量，特别是人机交换的时候，让计算机知道自己下子的类型。

当然，这个算法还是基本能够完成所需要的任务的了。但是这个算法还是有误差的，如下图所示。



当下子，快胜利时，有可能双三，那么计算机可能在计算权值的时候，会遇到以上的情况，即都是10000，那么计算机可能会找到一个位置（可能是随机，看具体怎样实现）进行下子，但是这个点并不是制胜点。如上图，这里就可能需要再次比较相同的最大权值的部分进行分析。

另外，在计算权值的时候，可以使用矩阵转置，稀疏矩阵进行描述，这里就不再详细的编写算法了。最后说一句，由于是面试题，所以不能够使用现有的类进行实现，这里我手动实现了一个堆栈和一些方法，具体可以参考代码。