#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
thisformplc_h(i,j,at("nyyyy",tmpzth),0 ,1) && 1 的得出方法 ：at("n","nyyyy")
case "ynyyy" $ tmpzth
thisformplc_h(i,j,at("ynyyy",tmpzth),1 ,1)
case "yynyy" $ tmpzth
thisformplc_h(i,j,at("yynyy",tmpzth),2 ,1)
case "yyyny" $ tmpzth
thisformplc_h(i,j,at("yyyny",tmpzth),3 ,1)
case "yyyyn" $ tmpzth
thisformplc_h(i,j,at("yyyyn",tmpzth),4 ,1)
b 连 5
case "nbbbb" $ tmpzth
thisformplc_h(i,j,at("nbbbb",tmpzth),0 ,2)
case "bnbbb" $ tmpzth
thisformplc_h(i,j,at("bnbbb",tmpzth),1 ,2)
case "bbnbb" $ tmpzth
thisformplc_h(i,j,at("bbnbb",tmpzth),2 ,2)
case "bbbnb" $ tmpzth
thisformplc_h(i,j,at("bbbnb",tmpzth),3 ,2)
case "bbbbn" $ tmpzth
thisformplc_h(i,j,at("bbbbn",tmpzth),4 ,2)
y 冲 4
case "nynyyn" $ tmpzth
thisformplc_h(i,j,at("nynyyn",tmpzth),2 ,3)
case "nyynyn" $ tmpzth
thisformplc_h(i,j,at("nyynyn",tmpzth),3 ,3)
case "nyyynn" $ tmpzth
thisformplc_h(i,j,at("nyyynn",tmpzth),4 ,3)
case "nnyyyn" $ tmpzth
thisformplc_h(i,j,at("nnyyyn",tmpzth),1 ,3)
b 冲 4
case "nbnbbn" $ tmpzth
thisformplc_h(i,j,at("nbnbbn",tmpzth),2 ,5)
case "nbbnbn" $ tmpzth
thisformplc_h(i,j,at("nbbnbn",tmpzth),3 ,5)
case "nbbbnn" $ tmpzth
thisformplc_h(i,j,at("nbbbnn",tmpzth),4 ,5)
case "nnbbbn" $ tmpzth
thisformplc_h(i,j,at("nnbbbn",tmpzth),1 ,5)
y 连 4
case "nnyyyb" $ tmpzth
thisformplc_h(i,j,at("nnyyyb",tmpzth),1 ,4)
case "nynyyb" $ tmpzth
thisformplc_h(i,j,at("nynyyb",tmpzth),2 ,4)
case "nyynyb" $ tmpzth
thisformplc_h(i,j,at("nyynyb",tmpzth),3 ,4)
case "nyyynb" $ tmpzth
thisformplc_h(i,j,at("nyyynb",tmpzth),1 ,4)
case "byyynn" $ tmpzth
thisformplc_h(i,j,at("byyynn",tmpzth),4 ,4)
case "byynyn" $ tmpzth
thisformplc_h(i,j,at("byynyn",tmpzth),3 ,4)
case "bynyyn" $ tmpzth
thisformplc_h(i,j,at("bynyyn",tmpzth),2 ,4)
case "bnyyyn" $ tmpzth
thisformplc_h(i,j,at("bnyyyn",tmpzth),1 ,4)
b 连 4
case "nnbbby" $ tmpzth
thisformplc_h(i,j,at("nnbbby",tmpzth),1 ,9)
case "nbnbby" $ tmpzth
thisformplc_h(i,j,at("nbnbby",tmpzth),2 ,9)
case "nbbnby" $ tmpzth
thisformplc_h(i,j,at("nbbnby",tmpzth),3 ,9)
case "nbbbny" $ tmpzth
thisformplc_h(i,j,at("nbbbny",tmpzth),1 ,9)
case "ybbbnn" $ tmpzth
thisformplc_h(i,j,at("ybbbnn",tmpzth),4 ,9)
case "ybbnbn" $ tmpzth
thisformplc_h(i,j,at("ybbnbn",tmpzth),3 ,9)
case "ybnbbn" $ tmpzth
thisformplc_h(i,j,at("ybnbbn",tmpzth),2 ,9)
case "ynbbbn" $ tmpzth
thisformplc_h(i,j,at("ynbbbn",tmpzth),1 ,9)
y 冲 3
case "nynynn" $ tmpzth
thisformplc_h(i,j,at("nynynn",tmpzth),2 ,6)
case "nnyynn" $ tmpzth
thisformplc_h(i,j,at("nnyynn",tmpzth),4 ,6)
b 冲 3
case "nbnbnn" $ tmpzth
thisformplc_h(i,j,at("nbnbnn",tmpzth),2 ,8)
case "nnbbnn" $ tmpzth
thisformplc_h(i,j,at("nnbbnn",tmpzth),4 ,8)
1个
case "nnynnn" $ tmpzth
thisformplc_h(i,j,at("nnynnn",tmpzth),3, 7)
case "nnnynn" $ tmpzth
thisformplc_h(i,j,at("nnnynn",tmpzth),2 ,7)
case "nnbnnn" $ tmpzth
thisformplc_h(i,j,at("nnbnnn",tmpzth),3 ,10)
case "nnnbnn" $ tmpzth
thisformplc_h(i,j,at("nnnbnn",tmpzth),2 ,10)
endcase
&& 列判断
do case
5个
case "nyyyy" $ tmpztl
thisformplc_l(i,j,at("nyyyy",tmpztl),0 ,1) && 1 的得出方法 ：at("n","nyyyy")
case "ynyyy" $ tmpztl
thisformplc_l(i,j,at("ynyyy",tmpztl),1 ,1)
case "yynyy" $ tmpztl
thisformplc_l(i,j,at("yynyy",tmpztl),2 ,1)
case "yyyny" $ tmpztl
thisformplc_l(i,j,at("yyyny",tmpztl),3 ,1)
case "yyyyn" $ tmpztl
thisformplc_l(i,j,at("yyyyn",tmpztl),4 ,1)
case "nbbbb" $ tmpztl
thisformplc_l(i,j,at("nbbbb",tmpztl),0 ,2)
case "bnbbb" $ tmpztl
thisformplc_l(i,j,at("bnbbb",tmpztl),1 ,2)
case "bbnbb" $ tmpztl
thisformplc_l(i,j,at("bbnbb",tmpztl),2 ,2)
case "bbbnb" $ tmpztl
thisformplc_l(i,j,at("bbbnb",tmpztl),3 ,2)
case "bbbbn" $ tmpztl
thisformplc_l(i,j,at("bbbbn",tmpztl),4 ,2)
4个
case "nynyyn" $ tmpztl
thisformplc_l(i,j,at("nynyyn",tmpztl),2 ,3)
case "nyynyn" $ tmpztl
thisformplc_l(i,j,at("nyynyn",tmpztl),3 ,3)
case "nyyynn" $ tmpztl
thisformplc_l(i,j,at("nyyynn",tmpztl),4 ,3)
case "nnyyyn" $ tmpztl
thisformplc_l(i,j,at("nnyyyn",tmpztl),1 ,3)
case "nbnbbn" $ tmpztl
thisformplc_l(i,j,at("nbnbbn",tmpztl),2 ,5)
case "nbbnbn" $ tmpztl
thisformplc_l(i,j,at("nbbnbn",tmpztl),3 ,5)
case "nbbbnn" $ tmpztl
thisformplc_l(i,j,at("nbbbnn",tmpztl),4 ,5)
case "nnbbbn" $ tmpztl
thisformplc_l(i,j,at("nnbbbn",tmpztl),1 ,5)
3个
case "nnyyyb" $ tmpztl
thisformplc_l(i,j,at("nnyyyb",tmpztl),1 ,4)
case "nynyyb" $ tmpztl
thisformplc_l(i,j,at("nynyyb",tmpztl),2 ,4)
case "nyynyb" $ tmpztl
thisformplc_l(i,j,at("nyynyb",tmpztl),3 ,4)
case "nyyynb" $ tmpztl
thisformplc_l(i,j,at("nyyynb",tmpztl),1 ,4)
case "byyynn" $ tmpztl
thisformplc_l(i,j,at("byyynn",tmpztl),4 ,4)
case "byynyn" $ tmpztl
thisformplc_l(i,j,at("byynyn",tmpztl),3 ,4)
case "bynyyn" $ tmpztl
thisformplc_l(i,j,at("bynyyn",tmpztl),2 ,4)
case "bnyyyn" $ tmpztl
thisformplc_l(i,j,at("bnyyyn",tmpztl),1 ,4)
case "nnbbby" $ tmpztl
thisformplc_l(i,j,at("nnbbby",tmpztl),1 ,9)
case "nbnbby" $ tmpztl
thisformplc_l(i,j,at("nbnbby",tmpztl),2 ,9)
case "nbbnby" $ tmpztl
thisformplc_l(i,j,at("nbbnby",tmpztl),3 ,9)
case "nbbbny" $ tmpztl
thisformplc_l(i,j,at("nbbbny",tmpztl),1 ,9)
case "ybbbnn" $ tmpztl
thisformplc_l(i,j,at("ybbbnn",tmpztl),4 ,9)
case "ybbnbn" $ tmpztl
thisformplc_l(i,j,at("ybbnbn",tmpztl),3 ,9)
case "ybnbbn" $ tmpztl
thisformplc_l(i,j,at("ybnbbn",tmpztl),2 ,9)
case "ynbbbn" $ tmpztl
thisformplc_l(i,j,at("ynbbbn",tmpztl),1 ,9)
2个
case "nynynn" $ tmpztl
thisformplc_l(i,j,at("nynynn",tmpztl),2 ,6)
case "nnyynn" $ tmpztl
thisformplc_l(i,j,at( "nnyynn",tmpztl),4 ,6)
case "nbnbnn" $ tmpztl
thisformplc_l(i,j,at("nbnbnn",tmpztl),2 ,8)
case "nnbbnn" $ tmpztl
thisformplc_l(i,j,at("nnbbnn",tmpztl),4 ,8)
1个
case "nnynnn" $ tmpztl
thisformplc_l(i,j,at("nnynnn",tmpztl),3, 7)
case "nnnynn" $ tmpztl
thisformplc_l(i,j,at("nnnynn",tmpztl),2 ,7)
case "nnbnnn" $ tmpztl
thisformplc_l(i,j,at("nnbnnn",tmpztl),3 ,10)
case "nnnbnn" $ tmpztl
thisformplc_l(i,j,at("nnnbnn",tmpztl),2 ,10)
endcase
tmpzth=""
tmpztl=""
endfor
参考文章： Cocos Creator 实战教程(1)——人机对战五子棋(节点事件相关)
源码： goBang
思考一：作为对手的系统用什么算法下棋？
估值函数、搜索算法和胜负判断等
博弈算法，在极大极小值搜索中应用alpha-beta剪枝
智能五子棋博弈程序的核心算法
智能五子棋中的算法研究
人机版五子棋两种算法概述
思考二：人机博弈的要点
1棋局的状态能够在机器中表示出来，并能让程序知道当时的博弈状态
2合法的走法规则如何在机器中实现，以便不让机器随便乱走而有失公平
3如何让机器从所有的合法走法中选择最佳的走法
4一种判断博弈状态优劣的方法，并能让机器能够做出智能的选择
5一个显示博弈状态的界面，有了这样的界面程序才能用的起来而有意义
思考三：五子棋下棋规矩
五子棋对局，执行黑方指定开局、三手可交换、五手两打的规定。
整个对局过程中黑方有禁手，白方无禁手。
黑方禁手有三三禁手、四四禁手和长连禁手三种
思考四：人机下棋逻辑
系统先下，黑棋落子，交换下子顺序
玩家下，监测胜负（无胜负，交换下子顺序）
系统下（五元组中找最优位置），监测胜负（无胜负，交换下子顺序）
。。。
直到分出胜负（这里未考虑平局）
出现提示窗，告知玩家战局结果，同时可选择“返回菜单”或“再来一局”
具体实现：涉及知识点
官方文档--预制资源
将其改名为Chess拖入下面assets文件夹使其成为预制资源
1在canvas节点上挂载Menu脚本组件
2在按钮事件中，拖拽和选择相应的Target，Component和Handler
初始化棋子节点断点截图
系统为黑棋的评分表：
找最优位置下子
个人想法
这是我学习五子棋游戏开发的记录，后续还会写其他游戏开发，加油！
机器博弈是人工智能领域的重要分支，它的研究对象多以复杂的棋牌类智力游戏为主，已经得到解决的棋类游戏，几乎全部都应归功于机器博弈近半个世纪的发展。计算机解决问题的优势在于能把不易解析的问题，借助于现代计算机的运算速度优势枚举出所有的合理情形而得解;然而，博弈问题的复杂程度决定了它不能过度依赖机器的计算能力。许多待解决的或已经解决的棋类，其状态空间复杂度或博弈树复杂度量级都太过庞大，所以我们需要添加约束，并且采用合理的算法进行优化。
五子棋问题是人工智能中的一个经典问题。当今世界，AlphaGo已经执围棋之牛耳，五子棋领域却鲜少有人问津。本文根据课堂所学知识结合文献、博客，基于两种开发语言实现了一个智能对战的AI五子棋游戏平台。
本文所做工作如下：
（1） 五子棋界面实现；
（2） 智能判定棋盘走势；
（3） 改进了棋盘扫描方式；
（4） 改良了系统评分表评估方式；
（5） 实现了基于点评分表估值找出最佳落子方式。
五子棋AI问题的最大问题是如何实现智能对弈，即当人落子之后，算法如何解读当前的棋盘并且对其进行分析解读，得到电脑方的最佳落子点。其次还有一个问题是如何判断胜利，这可以作为前面棋盘局势判定的一个子问题，也可以看做是一个单独的问题，不过这个问题总体来说较为简单，所以不做详细说明。
五子棋的整体知识构建包含以下部分：
（1） 棋盘局面表示法
（2） 棋局胜利判定
（3） 棋型知识库
（4） 智能博弈流程
对于问题（1），采用数组表示法。棋盘中的各交叉点有三种状态，不妨令 0表示空(未放置棋子) ，-1 表示有黑子 ，1 表示有白子，数组表示法的基本思想是:以交叉点对应的数组索引值来表达物理位置 ，以交叉点对应的元素值表达状态(空、 黑子、 白子)。令 V = {0 ，1 ，-1} ，棋盘 的第 i 个交叉点的状态 Si ∈V ，任何棋局都可以表示成一个 n ×n 的二元组。
对于问题（2）， 采用数组表示法时，想知道任意两个元素 Si 和Sj 是否共线，要通过 i 和 j 之间的数值规律来判断。从这方面看，数组表示法是一种原始、低效的表示方法，但是对于评分表算法来说其性能损失是可以接受的。要判断是否有一方已经胜利，只需要对整个棋盘判定当前落子点的纵、横、正斜、反斜四个方向的最长延伸出四个位置看是否能连成一条同色直线即可。具体的 *** 作可以视为：从落子点出发，向两个方向延伸，如果遇到同色，那么计数器加一，遇到非同色（空白或者异色）则停止在该方向的延伸，一个计数器记下该方向上的两头的连续同色棋子数。等到四个方向都探索完毕，如果四个计数器中有一个计数器达到了5，那么即可判断出已经有五子连珠了，此局结束。
问题（3）棋型知识库主要包括各种既定的棋盘形式，有如下几种：
² 活四 ：有两个连五点（即有两个点可以形成五），图中白点即为连五点。当活四出现的时候，整个局势已经无法阻止连五了，活四的归属方一定能取得胜利；
² 冲四 ：有一个连五点，如下面三图，均为冲四棋型。图中白点为连五点。 相对比活四来说，冲四的威胁性就小了很多，因为这个时候，只要跟着防守在那个唯一的连五点上，冲四就没法形成连五。
² 活三 ：可以形成活四的三，如下图，代表两种最基本的活三棋型。图中白点为活四点。活三棋型是进攻中最常见的一种，因为活三之后，如果对方不以理会，将可以下一手将活三变成活四，而活四是无法防守的。所以，面对活三的时候，需要非常谨慎对待。在没有更好的进攻手段的情况下，必须对其进行防守，以防止其形成可怕的活四棋型。
² 眠三： 只能够形成冲四的三，如下各图，分别代表最基础的六种眠三形状。图中白点代表冲四点。眠三的棋型与活三的棋型相比，危险系数下降不少，因为眠三棋型即使不去防守，下一手它也只能形成冲四，而对于单纯的冲四棋型，是可以很简单的防守住的。
² 活二 ：能够形成活三的二，如下图，是三种基本的活二棋型。图中白点为活三点。
² 眠二 ：能够形成眠三的二。图中四个为最基本的眠二棋型，细心且喜欢思考的同学会根据眠三介绍中的图2-13找到与下列四个基本眠二棋型都不一样的眠二。图中白点为眠三点。
对于上述的棋型，我们主要考虑的是活四、冲四、活三、眠三这几种主要的进攻棋型的防守与构成，整体棋型遵从以下原则：优先考虑数目，同等数目的情况下考虑是活是眠。评分表算法的设计整体偏向于防守。
对于问题（4），当下棋型的评估分析，算法严格遵从以下流程：
当人类方落下一子，算法启动，扫描全局，得到人类棋子的集合和电脑棋子的集合。全局扫描之后，对当前局势进行排序、计算。对每个集合的每个空白点位置打分，打分依据是根据这个点周围四个方向上的同色连续棋子的数量。按照这些最后得到的评分，得出最大值。得到人类方和电脑方的两个最大值之后，进行比较，如果人类方局势较好（分数较高），则算法将下一次落子位置设置为人类方得分最高的点，尽力降低人类方的下一步得分；如果电脑方的分数较高，那么则直接在使得分数最高的点落子即可。
本次课程设计，一共设计了两个版本，一个Java版本，为19X19的棋盘，配备简单的消息提示，基于AWT实现GUI，开发工具IntelliJ IDEA 20181
另一个版本是使用Python设计，核心算法相同，但是受限于源文件，为15X15棋盘，基于pygame实现GUI，开发工具是：JetBrains PyCharm 201824 x64
因为近期时间较为紧迫，所以《人工智能》这门课我选择了较为简单的五子棋问题进行课程设计。在本次课程设计中，我的编码能力、调试能力、算法解读实现能力、函数优化能力等各方面有了长足的进步。在本次的设计过程中也出现了几个问题，下面对这些问题进行一个简单的描述：
（1） 对棋盘局势的判断力不够，因为只是简单的对当前的棋盘局势进行判断，基本等同于一个粗通规则而且天赋不高的五子棋选手。如果对手很细心，而且熟练经营各种布局策略，那么基本这个算法就会被钻研出习惯，从而被轻易针对，而且针对方案百试不爽；
（2） 判断棋局形式的时候对边界的评分算法跟中心区域的评分算法一致，无法有效提前识别边界，降低边界空白点的权重；
（3） 用户图形界面需要改进，另外可以增设PK模式以及选色、选择棋盘大小功能等；
后续可以尝试用博弈树算法尝试与当前算法进行比较。评分表算法牺牲了更高的精度，以求迅速的得出最佳落子点；而博弈树可以通过提前落子进行全局预判进行更全方位的对人类方的围追堵截。
另外，可以通过在课堂上学到的知识，比如BFS、DFS、A算法、决策树算法 等应用于五子棋的智能决策中。
《人工智能》这门课让我对于图、知识表示、智能决策等各个方面有了更好地认识与体验，课堂设计内容充实有趣，让我受益匪浅，希望今后可以更加深入这个方面，并且将课堂上学到的知识应用于实践之中。
#include <stdioh>#include <biosh>
#include <ctypeh>
#include <conioh>
#include <dosh>
#define CROSSRU 0xbf /右上角点/
#define CROSSLU 0xda /左上角点/
#define CROSSLD 0xc0 /左下角点/
#define CROSSRD 0xd9 /右下角点/
#define CROSSL 0xc3 /左边/
#define CROSSR 0xb4 /右边/
#define CROSSU 0xc2 /上边/
#define CROSSD 0xc1 /下边/
#define CROSS 0xc5 /十字交叉点/
/定义棋盘左上角点在屏幕上的位置/
#define MAPXOFT 5
#define MAPYOFT 2
/定义1号玩家的 *** 作键键码/
#define PLAY1UP 0x1157/上移--'W'/
#define PLAY1DOWN 0x1f53/下移--'S'/
#define PLAY1LEFT 0x1e41/左移--'A'/
#define PLAY1RIGHT 0x2044/右移--'D'/
#define PLAY1DO 0x3920/落子--空格键/
/定义2号玩家的 *** 作键键码/
#define PLAY2UP 0x4800/上移--方向键up/
#define PLAY2DOWN 0x5000/下移--方向键down/
#define PLAY2LEFT 0x4b00/左移--方向键left/
#define PLAY2RIGHT 0x4d00/右移--方向键right/
#define PLAY2DO 0x1c0d/落子--回车键Enter/
/若想在游戏中途退出, 可按 Esc 键/
#define ESCAPE 0x011b
/定义棋盘上交叉点的状态, 即该点有无棋子 /
/若有棋子, 还应能指出是哪个玩家的棋子 /
#define CHESSNULL 0 /没有棋子/
#define CHESS1 'O'/一号玩家的棋子/
#define CHESS2 'X'/二号玩家的棋子/
/定义按键类别/
#define KEYEX99v 0/退出键/
#define KEYFALLCHESS 1/落子键/
#define KEYMOVECURSOR 2/光标移动键/
#define KEYINVALID 3/无效键/
/定义符号常量: 真, 假 --- 真为1, 假为0 /
#define TRUE 1
#define FALSE 0
//
/ 定义数据结构 /
/棋盘交叉点坐标的数据结构/
struct point
{
int x,y;
};
或者下面这个：
#include <graphicsh>
#include <stdlibh>
#include <stdioh>
#include <conioh>
#define N 15
#define B 7
#define STOP -10000
#define OK 1
#define NO 0
#define UP 328
#define DOWN 336
#define LEFT 331
#define RIGHT 333
int a[N+1][N+1];
int zx,zy;
int write=1,biaoji=0;
struct zn{
long sum;
int y;
int x;
}w[N+1][N+1],max,max1;
void cbar(int i,int x,int y,int r);
void map(int a[][]);
int getkey();
int key();
void zuobiao(int x,int y,int i);
int tu(int a[][],int write);
int wtu(int a[][],int write);
int zhineng(int a[][]);
int zh5(int y,int x,int a[][]);
long zzh5(int b[][],int i);
main()
{
int i,j;
int gdriver=DETECT;
int gmode;
initgraph(&gdriver,&gmode,"");
zx=(N+1)/2;
zy=(N+1)/2;
for(i=1;i<=N;i++)
for(j=1;j<=N;j++)
a[i][j]=0;
map(a);
i=1;
while(i)
{
int k,n;
k=wtu(a,write);
if(k==STOP) goto end;
map(a);
n=zhineng(a);
if(n==STOP) goto end;
map(a);
}
end:
;
}
int zhineng(int a[N+1][N+1])
{
int i,j;
int k;
maxsum=-1;
for(i=0;i<=N;i++)
for(j=0;j<+N;j++)
{
w[i][j]sum=0;
w[i][j]x=i;
w[i][j]y=j;
}
for(i=1;i<=N-4;i++)
for(j=1;j<=N-4;j++)
{
k=zh5(i,j,a);
if(k==STOP) return (STOP);
}
for(i=1;i<=N;i++)
for(j=1;j<=N;j++)
{
if(maxsum<w[i][j]sum)
{
maxsum=w[i][j]sum;
maxy=i;
maxx=j;
}
else if(maxsum==w[i][j]sum)
{
if(((maxy-zy)(maxy-zy)+(maxx-zx)(maxx-zx))>((i-zy)(i-zy)+(j-zx)(j-zx)))
maxsum=w[i][j]sum;
maxy=i;
maxx=j;
}
}
if(a[maxy][maxx]==0)
{
a[maxy][maxx]=-1;
zy=maxy;
zx=maxx;
}
}
int zh5(int y,int x,int a[N+1][N+1])
{
int i,j;
int b[6][6];
long c[13];
long d[6][6];
long temp;
for(i=y;i<=y+4;i++)
for(j=x;j<=x+4;j++)
b[i+1-y][j+1-x]=a[i][j];
c[1]=b[1][1]+b[1][2]+b[1][3]+b[1][4]+b[1][5];
c[2]=b[2][1]+b[2][2]+b[2][3]+b[2][4]+b[2][5];
c[3]=b[3][1]+b[3][2]+b[3][3]+b[3][4]+b[3][5];
c[4]=b[4][1]+b[4][2]+b[4][3]+b[4][4]+b[4][5];
c[5]=b[5][1]+b[5][2]+b[5][3]+b[5][4]+b[5][5];
c[6]=b[1][1]+b[2][1]+b[3][1]+b[4][1]+b[5][1];
c[7]=b[1][2]+b[2][2]+b[3][2]+b[4][2]+b[5][2];
c[8]=b[1][3]+b[2][3]+b[3][3]+b[4][3]+b[5][3];
c[9]=b[1][4]+b[2][4]+b[3][4]+b[4][4]+b[5][4];
c[10]=b[1][5]+b[2][5]+b[3][5]+b[4][5]+b[5][5];
c[11]=b[1][1]+b[2][2]+b[3][3]+b[4][4]+b[5][5];
c[12]=b[1][5]+b[2][4]+b[3][3]+b[4][2]+b[5][1];
for(i=1;i<=12;i++)
{
switch(c[i])
{
case 5:biaoji=1;return(STOP);
case -5:biaoji=-1;return(STOP);
case -4:c[i]=100000;break;
case 4:c[i]=100000;break;
case -3:c[i]=150;break;
case 3:c[i]=150;break;
case -2:c[i]=120;break;
case 2:c[i]=100;break;
case -1:c[i]=1;break;
case 1:c[i]=1;break;
default: c[i]=0;
}
}
for(i=1;i<=12;i++)
{
if(c[i]==150)
c[i]+=zzh5(b,i);
}
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
d[i][j]=0;
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
{
if(i==j) d[i][j]+=c[11];
if((i+j)==6) d[i][j]+=c[12];
d[i][j]+=c[i]+c[j+5];
}
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
{
if(b[i][j]!=0)
d[i][j]=-2;
}
max1sum=-1;
max1y=0;
max1x=0;
for(i=1;i<=5;i++)
for(j=1;j<=5;j++)
{
if(max1sum<d[i][j])
{
max1sum=d[i][j];
max1y=i;
max1x=j;
w[i+y-1][j+x-1]sum+=max1sum;
}
else if(max1sum==d[i][j])
{
if(((i+y-1-zy)(i+y-1-zy)+(j+x-1-zx)(j+x-1-zx))>((max1y+y-1-zy)(max1y+y-1-zy)+(max1x+x-1-zx)(max1x+x-1-zx)))
{
max1sum=d[i][j];
max1y=i;
max1x=j;
}
}
}
}
long zzh5(int b[6][6],int n)
{
int i,j,k,l,m;
switch(n)
{
case 1:i=b[1][1];j=b[1][2];k=b[1][3];l=b[1][4];m=b[1][5];break;
case 2:i=b[2][1];j=b[2][2];k=b[2][3];l=b[2][4];m=b[2][5];break;
case 3:i=b[3][1];j=b[3][2];k=b[3][3];l=b[3][4];m=b[3][5];break;
case 4:i=b[4][1];j=b[4][2];k=b[4][3];l=b[4][4];m=b[4][5];break;
case 5:i=b[5][1];j=b[5][2];k=b[5][3];l=b[5][4];m=b[5][5];break;
case 6:i=b[1][1];j=b[2][1];k=b[3][1];l=b[4][1];m=b[5][1];break;
case 7:i=b[1][2];j=b[2][2];k=b[3][2];l=b[4][2];m=b[5][2];break;
case 8:i=b[1][3];j=b[2][3];k=b[3][3];l=b[4][3];m=b[5][3];break;
case 9:i=b[1][4];j=b[2][4];k=b[3][4];l=b[4][4];m=b[5][4];break;
case 10:i=b[1][5];j=b[2][5];k=b[3][5];l=b[4][5];m=b[5][5];break;
case 11:i=b[1][1];j=b[2][2];k=b[3][3];l=b[4][4];m=b[5][5];break;
case 12:i=b[1][5];j=b[2][4];k=b[3][3];l=b[4][2];m=b[5][1];break;
}
if((i==0&&j==1&&k==1&&l==1&&m==0))
return (900);
if((i==0&&j==-1&&k==-1&&l==-1&&m==0))
return(1000);
if((i==0&&j==0&&k==1&&l==1&&m==1)||(i==1&&j==1&&k==1&&l==0&&m==0))
return(20);
if((i==0&&j==0&&k==-1&&l==-1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==0&&m==0))
return(20);
if((i==-1&&j==1&&k==1&&l==1&&m==1)||(i==1&&j==-1&&k==1&&l==1&&m==1)||(i==1&&j==1&&k==-1&&l==1&&m==1)||(i==1&&j==1&&k==1&&l==-1&&m==1)||(i==1&&j==1&&k==1&&l==1&&m==-1))
return(-60);
if((i==1&&j==-1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==-1&&m==1))
return(-60);
}
int wtu(int a[N+1][N+1],int write)
{
int i=1;
map(a);
zuobiao(zx,zy,1);
while(i)
{
int k;
k=tu(a,write);
if(k==OK) i=0;
if(k==STOP) return (STOP);
}
}
int getkey()
{
int key,lo,hi;
key=bioskey(0);
lo=key&0x00ff;
hi=(key&0xff00)>>8;
return((lo==0) hi+256:lo);
}
int key()
{
int k;
k=getkey();
switch(k)
{
case 27: return (STOP);
case 13:
case ' ': return (OK);
case 328: return (UP);
case 336: return (DOWN);
case 331: return (LEFT);
case 333: return (RIGHT);
default: return (NO);
}
}
void zuobiao(int x,int y,int i)
{
int r;
if(i!=0)
{
setcolor(GREEN);
for(r=1;r<=5;r++)
circle(75+25x,25+25y,r);
}
else
{
if(a[zy][zx]==1)
{
setcolor(8);
for(r=1;r<=5;r++)
circle(75+25x,25+25y,r);
}
else if(a[zy][zx]==-1)
{
setcolor(WHITE);
for(r=1;r<=5;r++)
circle(75+25x,25+25y,r);
}
else
{
setcolor(B);
for(r=1;r<=5;r++)
circle(75+25x,25+25y,r);
setcolor(RED); line(75+25zx-5,25+25zy,75+25x+5,25+25zy);
line(75+25zx,25+25zy-5,75+25zx,25+25zy+5);
}
}
}
int tu(int a[N+1][N+1],int write)
{
int k;
re:
k=key();
if(k==OK)
{
if(a[zy][zx]==0)
{
a[zy][zx]=write;
}
else
goto re;
}
if(k==STOP) return(STOP);
if(k==NO) goto re;
if(k==UP)
{
int i,j;
if(zy==1) j=zy;
else j=zy-1;
zuobiao(zx,zy,0);
zuobiao(zx,j,1);
zy=j;
goto re;
}
if(k==DOWN)
{
int i,j;
if(zy==N) j=zy;
else j=zy+1;
zuobiao(zx,zy,0);
zuobiao(zx,j,1);
zy=j;
goto re;
}
if(k==LEFT)
{
int i,j;
if(zx==1) i=zx;
else i=zx-1;
zuobiao(zx,zy,0);
zuobiao(i,zy,1);
zx=i;
goto re;
}
if(k==RIGHT)
{
int i,j;
if(zx==N) i=zx;
else i=zx+1;
zuobiao(zx,zy,0);
zuobiao(i,zy,1);
zx=i;
goto re;
}
}
void cbar(int i,int x,int y,int r)
{
if(i!=0)
{
if(i==1)
setcolor(8);
else if(i==-1)
setcolor(WHITE);
for(i=1;i<=r;i++)
{
circle(x,y,i);
}
}
}
void map(int a[N+1][N+1])
{
int i,j;
cleardevice();
setbkcolor(B);
setcolor(RED);
for(i=0;i<N;i++)
{
line(100,50+25i,75+N25,50+25i);
line(100+25i,50,100+25i,25+N25);
}
for(i=1;i<=N;i++)
for(j=1;j<=N;j++)
cbar(a[i][j],75+25j,25+25i,10);
}五子棋算法可简可繁,要看你对自己五子棋程序智能的要求, 人机对战的意思就是人和电脑下,也就是说电脑会思考如何下棋其实这才是五子棋程序的核心如果只实现人与人对战的话,是一件很简单的事情,无非就是绘制棋盘,然后绘制下棋的效果,再写个下棋合法性判断,胜负判断大概就搞定了所以核心其实是人机对战的电脑那部分人工智能这东西吧,可以研究的很多,不过主要的几个设计要点就是搜索算法和估值算法,这两个是最主要的,还有提高电脑思考销率的方法就有多cpu的计算机多线程思考的设计通过一些手段让电脑变得更像人类棋手的,例如利用一些遗传算法之类的让电脑具有学习能力,可以在失败中吸取教训,开局库,历史启发之类的一大堆但是总而言之,这一系列算法的设计没有一个标准,只要能让你的电脑下棋下的更聪明,更快那就是好算法国内有一个叫王晓春的写过一本叫<<pc游戏编程( 人机博弈)>>的书,这是一本研究人机博弈程序很经典的书,书的后面还附了一个五子棋的程序实例,你可以参考一下下面是csdn的下载地址,你也可以自己去搜一下>
玩五子棋的时候，怎样才可以获胜呢，下面我为大家介绍一下关于五子棋的获胜秘诀，欢迎大家阅读。
五子棋获胜秘诀防守。 任何竞技类游戏，进攻可以让你变得很强，但是只有防守才能让你变得非常强。这句话用在五子棋上尤其适合，五子棋看似是摆够五颗棋子就能获胜的进攻型棋类游戏，但它的精髓恰恰在于以防守来带动进攻。真正的五子棋高手都是一个防守专家，在防守中找机会，然后一击致命，而不是只知道进攻的花拳绣腿。
专注。 棋类游戏是非常讲究专注的。所谓棋差一招，在五子棋上这点更明显，五子棋是一个很容易造成杀棋的棋类，有时候走错一步就会让对手占据主动，被牵着鼻子走，无力招架，所以流传着一句五子棋是谁先出谁获胜，那是低水平的借口。只要你专注，细心的防守，就会化被动为主动。
节奏。 高手之间的对决获胜的关键点往往在于对节奏的掌控。在对手疯狂的进攻的时候，不要被对手带乱了自己的节奏，而是平心静气，在被动中找寻致命一击的机会，有时候对手只是雷声大雨点小，瞄准他们的后防，一击就足以致命。
心态。 一个放松的心态是获胜的关键。一个水平高超的棋手一定有一颗强大的心脏，极好的心里素质。喜怒不形于色，从容面对，你才会发挥出自己最好的水平，不至于出现一些低级的失误。
气场。 首先你要相信你能赢，你才有可能赢。不管对手的战绩如何好，不管对手的资历如何丰富，我们都要对自己有信心，在竞技博弈中，气场往往能够扭转比赛的走势，打乱对手的节奏，如果你不能表现得完美，就让对手表现的比自己差，这就是竞技博弈。
Const DIR_UP = 1Const 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
这样我们前四个方向可以通过加四得到另一个方向的值。
改变按钮的背景标志这个棋盘的格子上是黑棋、白棋，把每个空位从八个方向上的棋型填入数组gStyle(2, 15, 15, 8;值定为1，则我们就得
到了下面各种棋型的分值，表示两个相反的方向的数应该差4, 2)，如在一个可下
棋的点,2，如，其中第一个下标为1时表示黑棋，为2时表示白棋，第二和第三
个下标表示(x：
L1;lt;=F1;lt;L2,y)，第四个下标表示8个方向，最后一个下标为1时表示棋子数，不过下面这段材料如果看不懂的话，所以我们可以又得到4F3lt;L4。对于而白棋在垂直方向上点(4,4)的价值是一个活1;=F4
从这个关系包含了进攻和防守的关系（当然，这个关系是由我定的，你可以自己定义这些关系）
一旦把所有空点的棋型值填完，我们很容易地得出黑棋水平方向上点(4;=F3,2，我们先扫描
整个棋盘;表示先手冲四
Ln 表示后手n个棋子的活棋型，如：L3表示后手活三
Ln;表示后手n个棋子的冲棋型,1;对应F[0][2]L数组表示后手，第一个下标为0时表示冲型、4L3lt,1)=3表示与坐标(2,2)在第1个方向上相邻的黑棋棋子数为3
gstyle(1;lt;表示先手n个棋子的冲棋型，如：F4,2，我们还可以得到其它的关系，如：4F2lt;L3,4),（打的位置是空位）;lt,1,2)=4表示与坐标(2，这些的关系由于你的定法和我的定法制可能不一样，这样计算机的AI也就不一样，最后我们把分值最小的L1;L4;lt;F4,2)在第1个方向上的最近的空格数为4
在定义方向时，也应该注意一定的技巧。同时使用一个二维数组记录棋盘棋子的分布界面思路，比如qipan[0][0]=1标示第1行第一列的棋子是黑棋子，乙烯类推。对这些关系再进一步细化。
循环检测是否某行、某列，第二
个下标表示棋子数，则L2对应F[1][2]Ok、某斜线上是否已经有五个颜色相同的棋子。
简单的算法就是判断某行、某列，为2时表示空格数，如：
gStyle(1、某斜线的妻子数目那个最多。通过2个for循环遍历棋盘。
复杂的算法，你看看下面的参考资料，用简单的算法实现了五子棋也是很好的了，^_^
五子棋算法(AI)
任何一种棋类游戏其关键是对当前棋局是否有正确的评分,评分越准确则电脑的AI越高。五子棋游戏也是如此，但在打分之前，然后我们就取棋盘上各个空点的这两个值的和的最大一点作为下棋的点，只要我们把该点的对于黑棋和白棋的价值算出
来;
F数组表示先手;=F2,2，则F2，在程序中我是这样定义的，由C语言表示为，第一个下标为0时表示冲型，第二个下标表示棋子数，由一个冲1（我把有界的棋称为冲）和活2（两边无界的
棋称为活）组成的。如果你还是不太明白。然而，对各种棋型应该取什么值呢：
用按钮数组模拟棋盘,则,4)的价值？我们可以先作如下假设：
Fn 表示先手n个棋子的活棋型，如，请看下面的图：
---------
---------
---oo----
-oxxx---
---------
---------
图中的点从标为(4;lt;这个关系，同样：
F[2][5]=,};
L[2][5]=:
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
:);F3：L3;表示后手冲三
根据在一行中的棋型分析，得到如下关系，其四个方向上都有活三，也比不上一个冲四，我们把每一个可下点的四个方向的棋型值相加（包括先手和后手的分
值），最后选择一个最大值，并把这一点作为计算机要下的点就OK了：F4表示先手活四
Fn，棋型的分值关系确定好了以后;=L1lt;F1lt;L2lt;F2lt;L3,};lt，而在/方向也是活1所以、空
五子棋简介
五子棋又名五子连珠棋，是一项有趣、益智的棋类游戏。五子棋容易上手，老少皆宜，而且趣味横生，引人入胜。它不仅能增强思维能力，提高智力，而且富含哲理，有助于修身养性。以下是我为大家整理的五子棋简介相关内容，仅供参考，希望能够帮助大家。
简介
五子棋是一种两人对弈的纯策略型棋类游戏，是起源于中国古代的传统黑白棋种之一。早在“尧造围棋”之前，可能民间就已有五子棋游戏。发展于日本，流行于欧美。
五子连珠棋五子棋容易上手，老少皆宜，而且趣味横生，引人入胜;不仅能增强思维能力，提高智力，而且富含哲理，有助于修身养性。
五子棋是起源于中国古代的传统黑白棋种之一。现代五子棋日文称之为 “ 连珠 ” ，英译为 “Renju” ，英文称之为 “Gobang” 或 “FIR”(Five in a Row 的缩写 ) ，亦有 “ 连五子 ” 、 “ 五子连 ” 、 “ 串珠 ” 、 “ 五目 ” 、 “ 五目碰 ” 、 “ 五格 ” 等多种称谓。
五子棋不仅能增强思维能力，提高智力，而且富含哲理，有助于修身养性。五子棋既有现代休闲的明显特征 “ 短、平、快 ” ，又有古典哲学的高深学问 “ 阴阳易理 ” ;它既有简单易学的特性，为人民群众所喜闻乐见，又有深奥的技巧和高水平的国际性比赛;它的棋文化源渊流长，具有东方的神秘和西方的直观;既有 “ 场 ” 的概念，亦有 “ 点 ” 的连接。它是中西文化的交流点，是古今哲理的结晶。
传统五子棋
五子连珠棋传统五子棋的棋具与围棋大致相同，棋子分为黑白两色，棋盘为15×15，棋子放置于棋盘线交叉点上。两人对局，各执一色，轮流下一子，先将横、竖或斜线的5个或5个以上同色棋子连成不间断的一排者为胜(正规比赛中黑棋只能连成5个。6-9个一排算禁手，另外黑棋还有33和44禁手。黑棋禁手判负。白棋没有限制)。
因为传统五子棋在落子后不能移动或拿掉，所以也可以用纸和笔来进行游戏。
称谓：
五子棋，日文亦有“连五子、五子连、串珠、五目、五目碰、五格、五石、五法、五联、京棋”等多种称谓，英文则称之为“FIR (Five In A Row的缩写)、Gomoku(日语“五目”的罗马拼音)、Gobang、connect 5、mo-rphion”。捷克语piskvorky，韩语omok……
五子连珠棋许多国家的人对五子棋都有不同的爱称，例如，韩国人把五子棋称为“情侣棋”，暗示情人之间下五子棋有利于增加情感的交流;欧洲人称其为“绅士棋”，代表下五子棋的君子风度胜似绅士;日本人则称其为“中老年棋”，说明五子棋适合中老年人的生理特点和思维方式;美国人喜欢将五子棋称为“商业棋”，也就是说，商人谈生意时可边下棋边谈生意，棋下完了生意也谈成了。
起源：
五子棋相传起源于四千多年前的尧帝时期，比围棋的历史还要悠久，可能早在“尧造围棋”之前，民间就已有五子棋游戏。有关早期五子棋的文史资料与围棋有相似之处，因为古代五子棋的棋具与围棋是完全相同的。在上古的神话传说中有“女娲造人，伏羲做棋”一说，《增山海经》中记载：“休舆之山有石焉，名曰帝台之棋，五色而文状鹑卵。”李善注引三国魏邯郸淳《艺经》中曰：“棋局，纵横各十七道，合二百八十九道，白黑棋子，各一百五十枚”。可见，五子棋颇有渊源。亦有传说，五子棋最初流行于少数民族地区，以后渐渐演变成围棋并在炎黄子孙后代中遍及开来。
在古代，五子棋棋具虽然与围棋相类同，但是下法却是完全不同的。正如《辞海》中所言，五子棋是“棋类游戏，棋具与围棋相同，两人对局，轮流下子，先将五子连成一行者为胜。”。
现代五子棋
随着五子棋的发展，逐步发现先手优势非常大，最后得出“先手必胜”。五子棋要成为竞技运动，核心问题是怎样解决传统五子棋下法中“先手必胜”的问题。
“交换”思维
“交换”思维有个形象的比喻：一个人切蛋糕，一个人选蛋糕。即：一人开局，另一人选择黑方还是白方。此方法最为公平、最有效率，且最为简洁实用。不过此方法使开局者不走已知的必胜，把棋艺的较量演化为对局者开局的博弈，而“先手必胜”依然存在。
如：欧洲的Swap2、Swap1;中国的Swap3、第一手交换规则等。
“禁手”思维
禁止以某种手段取胜。为了平衡先后手之间的差距，削弱先手优势，日本连珠提出“禁手”。后来连珠的发展证明禁手并不能平衡先后手之间的差距，依然是“先手必胜”。
“泡沫”原理
像泡沫一样会破灭。如“吃子”五子棋。连成5个后消失，同时拿掉对方一个棋子，自己再补一子。此原理的的特点是：把五子棋金球制改成了“进球制”，同时也最大效率地利用了棋盘和棋子，带来了全新的思维。问题是怎样计算胜负。
“井字游戏”原理
井字游戏又叫圈叉棋，圈叉棋是和棋，原因是空间很小。
通过缩小棋盘来抑制五子棋先手的优势。如：15路棋盘，13路棋盘等等。问题是多大的棋盘才能是和棋，知道和棋后还能成为竞技运动吗。
“跷跷板”原理
五子棋始终是先手领先一子。如果双方轮流领先一子呢
台湾教授发明的六子棋，就如“跷跷板”一样。先手先下一子，然后双方轮流下两子，先连成6子者胜利。六子棋为第11届奥林匹亚计算机游戏程序竞赛项目，验证其公平性与复杂性。
职业制传统五子棋
由于传统五子棋具有不公平性,而现代五子棋五子棋禁手规则令一部分棋手望而怯步于是产生了职业制传统五子棋,职业制传统五子棋虽然准备麻烦,但胜在简单公平,而且难度增加(复杂程度高于中国象棋,接近围棋),久而习之,思维活跃
规则如下:
1准备19×19棋盘两张
2黑白子数目必须满足
3第一回合先手只能下一手,其馀回合可以下连续两手
4后手每回合均可以下连续两手
5每颗子所投的棋盘没有限制
6只要任意一方在两个棋盘上且同一个回合上连为五子为胜
7若任意一方在两个棋盘上且不同一个回合上连为五子为负
8若任意一方在不足两个棋盘上且同一个回合上连为五子为负
综合效应
“禁手”思维+“交换”思维+“井字游戏”原理=连珠
如：RIF规则、Sakata规则、Yamaguchi规则Tarannikov规则等。
现代五子棋的现状
五子棋、六子棋、连珠已经成为欧洲现代五子棋的组成部分，举行了很多次大大小小的比赛，并且将三种棋的世界锦标赛联合举行。
中国的现代五子棋还处于起步阶段。2003年中国棋院《中国五子棋竞赛规则》参考了RIF规则，同时兼顾发展传统五子棋。
五子棋能开发智力
单机五子棋
五子棋单机[5]是目前最流行的游戏玩法，同时好处也是非常多的，对于实力提高是非常的明显的，下五子棋的实力的提高，最快最便捷的方法不是通过时间的积累，不是通过无数的理论知识奠定，而是给予玩家在下棋的时候，无数虐待才会真正的提高，当大家在下棋的时候，能够有深深的记忆，就是在自己输棋中，五子棋单机游戏中的电脑，就可以给玩家这种记忆，电脑能力是非常强的，能够抓住大家下棋的每一个弱点，所以很多高手玩家都不能够战胜电脑，而新手玩家想要快速提高自己的实力，与五子棋电脑玩家大战几百盘实力必定突飞猛进。
游戏中，大家会有真正的下棋记录，同时是有些教育的意味的，因为每一次下棋不管是输还是赢，都会为大家记录下来，而想要了解自己当时在下五子棋心情如何，就可以通过这些记录来了解，并且这种记录会帮助玩家在下棋的是，有更多实力提高的机会，因为可以找到自己在下五子棋出现的失误，进而改正这种错误，给予自己实力真正提高的机会。
发展历史
日本
据日本史料文献记载，中国古代的五子棋先由中国传到高丽(朝鲜)，然后于公元1688年至1704年日本的元禄时代再从高丽传到日本，最初在皇宫和贵族大家庭中流行，到元禄末期，开始在民间盛行。1899年，对传统五子棋进行规则改良后，经过公开征名，“联珠”这一名称才被正式确定下来。取意于“日月如合璧，五星如联珠”。现写做“连珠”。
欧洲
20世纪初传统五子棋及连珠从日本传入欧洲，五子棋称为“Five In A Row”(缩写为FIR)，同时根据日语的罗马拼音，“五目、五目碰”称为"Gomoku、Gobang"，“连珠”则称之为“Renju”。
1958年以及1979年，瑞典和前苏联分别成立了连珠联盟。1988年，日本、前苏联以及瑞典三个国家的连珠组织在瑞典成立国际连珠联盟(Renju International Federation,简称RIF)
20世纪90年代欧洲一些国家将传统五子棋引入“交换”等规则后，经过发展逐渐形成一系列的Gomoku新规则，中欧一些国家成立了Gomoku组织，并和六子棋共同成立了国际联盟(GCIF)。
21世纪初在举办世界连珠(renju)锦标赛的同时也举办世界Gomoku锦标赛(GT)及六子棋国际公开赛(CT)。
2009年8月在捷克共和国(CzechRepublic)帕尔杜比采市(Pardubice)将举行第11届世界连珠锦标赛和第3届世界Gomoku锦标赛。
中国
长久以来五子棋在中国一直没有得到发展。
2001年，国家体育总局批准中国棋院试办全国性五子棋比赛。
2002年8月2-4日，中国棋院举办了首届全国五子棋个人邀请赛，此后每年举办一次。
2003年，国家体育总局批准了中国棋院审定的《中国五子棋竞赛规则》(试行)(参考资料)和《中国五子棋段级位制》(试行)(参考资料)。
2006年2月，国家体育总局对五子棋正式立项，作为围棋下的一个二级项目。全国各地相继成立了新的五子棋俱乐部。
2007年5月和10月中国棋院先后举办了首届全国五子棋团体锦标赛和首届全国五子棋个人锦标赛。
2008年6月和12月中国棋院先后举办了第二届全国五子棋团体锦标赛和第二届全国五子棋个人锦标赛。
2009年5月28-30日中国棋院举办了第三届全国五子棋团体锦标赛。
2009年11月，首届全国智力运动会将五子棋作为的正式比赛项目(参考资料)。
段级位制
中国五子棋段级位制 (试行) (具体内容见参考资料)
五子棋的段级位对象：参加中国棋院认可的国内外五子棋比赛的五子棋爱好者。
第四条 段位共分九个等级，最高是九段，以下分别是八段、七段、六段、五段、四段、三段、二段、初段。段位以下共分十个等级，最高是一级，以下分别是二级、三级、四级、五级、六级、七级、八级、九级、十级。
第五条 根据中国五子棋爱好者在国内、国际交流中所体现出来的实际水平，在五子棋段级位制度实施初期，对爱好者授予的最高段位暂定为六段。随着中国棋手参与国内外交流机会的增加和技术水平的提高，逐步增加所授予段位的上限，直至九段。
棋盘和棋子与记谱方法
五子连珠棋相传中华民族的祖先轩辕黄帝无意之中画下了十七条横线十条竖线，这无意中的发明造就出了五子棋。早在公元595年古人就用瓷来烧制五子棋盘了。千百年来，人们用各种材质来制造围棋的棋子，如：玻璃、瓷器、玉、玛瑙、铜等等。
古代五子棋棋盘与围棋棋盘是通用的，汉魏时为十七路(17×17)棋盘，至南北朝时即已流行十九路(19×19)棋盘，直至1931年，才出现所谓五子棋专用棋盘，如图所示，为十五路(15×15)棋盘，形状近于正方形，平面上画横竖各15条平行线，线路为黑色，构成225个交叉点，邻近两个交点的距离纵线约为25厘米，横线约为24厘米。棋盘正中一点为“天元”。棋盘两端的横线称端线，棋盘左右最外边的两条纵线称边线。从两条端线和两条边线向正中发展而纵横交叉在第四条线形成的四个点称为“星”。天元和星应在棋盘上用直径约为05厘米的实心小圆点标出。
五子棋棋子亦称“棋石”分黑、白两色，形状为扁圆形，有一面凸起或两面凸起等形状，厚度不超过08厘米，直径为20～23厘米;一副棋子总数为225枚，其中黑子113枚，白子112枚。按质地的不同，可分为玻璃、陶瓷、塑料、智石、磁铁、蛤贝、烧料、水晶、玛瑙、玉石等棋子。
五子棋正规的记谱方法为用“五子棋稿纸”，即专供五子棋爱好者记录对局或着法的稿纸。其上印有正规专用棋盘图形，记录时只要按相应位置在纸上标明行棋的先后，即可反映对局的进行过程。非正规的记谱方法为用格子纸记录，即用单数1、3、5等记录黑方的走法，用双数2、4、6记录白方的走法，同样可反映对局的进行过程。另外还有北京京都五子棋协会为了推广盲人下五子棋，以及正常人下盲棋并背诵五子棋棋谱，专门设计的盲棋记谱法等。
相关术语
对局相关术语
〖黑方〗执黑棋一方的简称。
〖白方〗执白棋一方的简称。
〖胜局〗有一方获胜的对局。
〖和局〗分不出胜负的对局。
〖终局〗对局结束。
〖复盘〗对局双方将本盘对局全过程的再现。
行棋相关术语
〖阳线〗即:直线，棋盘上可见的横纵直线。
〖交叉点〗阳线垂直相交的点，简称“点”。
〖阴线〗即:斜线，由交叉点构成的与阳线成45°夹角的隐形斜线。
〖落子〗棋子直接落于棋盘的空白交叉点上。
〖轮走方〗即“行棋方”，有权利落子的黑方或白方。
〖着〗在对局过程中，行棋方把棋子落在棋盘无子的点上，不论落子的手是否脱离棋子，均被视为一着。
〖回合〗双方各走一着，称为一个回合。
〖开局〗在对局开始阶段形成的布局。
〖连〗同色棋子在一条阳线或阴线上相邻成一排。
〖长连〗五枚以上同色棋子在一条阳线或阴线上相邻成一排。
〖五连〗只有五枚同色棋子在一条阳线或阴线上相邻成一排。
〖成五〗含有五枚同色棋子所形成的连，包括五连和长连。
〖四〗在一条阳线或阴线上连续相邻的5个点上只有四枚同色棋子的棋型。
〖活四〗有两个点可以成五的四。
〖冲四〗只有一个点可以成五的四。
〖死四〗不能成五的四。
〖三〗在一条阳线或阴线上连续相邻的5个点上只有三枚同色棋子的棋型。
〖活三〗再走一着可以形成活四的三。
〖连活三〗即：连的活三(同色棋子在一条阳线或阴线上相邻成一排的活三)。简称“连三”。
〖跳活三〗中间隔有一个空点的活三。简称“跳三”。
〖眠三〗再走一着可以形成冲四的三。
〖死三〗不能成五的三。
〖二〗在一条阳线或阴线上连续相邻的5个点上只有两枚同色棋子的棋型。
〖活二〗再走一着可以形成活三的二。
〖连活二〗即：连的活二(同色棋子在一条阳线或阴线上相邻成一排的活二)。简称“连二”。
〖跳活二〗中间隔有一个空点的活二。简称“跳二”。
〖大跳活二〗中间隔有两个空点的活二。简称“大跳二”。
〖眠二〗再走一着可以形成眠三的二。
〖死二〗不能成五的二。
〖先手〗对方必须应答的着法，相对于先手而言，冲四称为“绝对先手”。
〖三三〗一子落下同时形成两个活三。也称“双三”。
〖四四〗一子落下同时形成两个冲四。也称“双四”。
〖四三〗一子落下同时形成一个冲四和一个活三。
战术相关术语
〖风车轮〗指在一定区域内来回地绕着连续进攻的战术或技巧，就像一个风车轮一直在转着似的，这样的取胜方法也称之为“风车胜”。
〖二头蛇〗指某一方以活三进攻时，无论对方防守于哪一头都难免被蛇头咬伤，因为此时的活三如同二头蛇一样，两头都有厉害的杀着。也称“两头蛇”。
〖一子双杀〗一子落下同时形成两种取胜方法而对方无法同时防守的取胜技巧。
〖一子多杀〗一子落下同时形成两种以上取胜方法而对方无法同时防守的取胜技巧。
〖一子双防〗一子落下同时形成防守两种取胜方法的防守技巧。
〖八卦阵〗以“日”字的一组对角点为棋型，互为马步的防守阵型。构成五子棋八卦阵。
〖VCF〗英文 Victory of Continuous Four 的字头缩写，是利用连续不断地冲四这种绝对先手，直至最终取得胜利的战术技巧。
〖VCT〗英文 Victory of Continuous Threat 的字头缩写，是利用连续不断地活三、冲四、做杀等先手，直至最终取得胜利的战术技巧。
比赛相关术语
〖个人赛〗计算个人成绩的比赛。
〖团体赛〗计算运动队团体成绩的比赛。
〖轮空〗赛制中部分选手直接从中间某轮开始参加比赛，某轮未比赛的安排就叫轮空。
〖节〗一个比较集中的比赛单位时间(如一个上午或一个下午或一个晚上)称一“节”。
〖轮〗参赛的各队(团体赛)或各名棋手(个人赛)普遍出场比赛一次(个别轮空者除外)称一“轮”。
〖次〗团体赛中的同一轮两队之间完成的比赛称为一“次”比赛。
〖场〗两名棋手之间完成的两局制或多局制的一次比赛称为一“场”比赛。
〖局〗两名棋手之间完成的一盘比赛称为一“局”比赛。
残局技巧
从取胜的'途径来分类，五子棋的残局技巧可分为两类：四三取胜和抓禁手取胜。由这两类技巧又可派生出一子双杀、一子多杀、一子杀禁、VCF、VCT等等精妙的入局方式。
一子双杀
所谓“一子双杀”是指对局中出现一方有两个叫杀点（一般是有两个冲四活三点），而对方无法同时防守的情形。对局中，人们往往发现，并非每一步棋都必须是先手（特指活三或冲四）才能赢棋。有时候，某一步棋本身并不是先手，但是，有了这步棋，就出现了两个胜点或两种获胜着法，迫使对方来不及防守或无法防守而获胜，这就是“一子双杀”。可以说，“一子双杀”的技巧是五子棋技术的一层新阶梯，如果掌握了这种技巧，就表明了你的五子棋技术已经有一定的水平。
一子双禁
所谓“一子双禁”是指白方利用禁手的规则，通过一着妙棋使黑方陷入同时面临两个禁手点的困境，黑方将无法同时避免两个禁手点的情形。从另一种意义上说，这是白棋的一子双杀。
一杀一禁
所谓“一杀一禁”是指对局中出现白方有两个取胜点，其中一个为冲四活三叫杀，另一个为抓禁手取胜的棋形。
一子多杀
所谓“一子多杀”是指对局中出现一方有两个以上（如三个、四个或五个）的叫杀点，而对方无法同时防守的情形，其实质也是一子双杀。
必胜
所谓“必胜”是指某一方行至某一手后，针对对方以后的每一个防点都有一套或一套以上的胜法的着，比一子多杀的范围广。
必败
所谓“必败”是指某一方行至某一手后，对方针对这一手拥有一套或一套以上的胜法的着。
VCT
所谓VCT是英文Victory by Continuous Threat的缩写，不断利用冲四、活三、做杀等先手进攻最后取得胜利。
VCF
所谓VCF是英文Victory of Continuous Four的缩写，亦称追四，即以连续不断的冲四取得胜利。VCF是五子棋残局和各种排局中一个非常重要的取胜技术。所以，学习并掌握VCF技术是对于提高五子棋爱好者的棋艺水平来说是十分重要的。五子棋排局是人为排列出来的局面习题。
它虽然不是实战对局的产物，但是，其主题的构思往往接近于实战残局；而且，绝大多数是由字、数、形等图案构成的VCF练习题，给人以美的享受及解谜的魅力。精彩的排局和字谜往往构思精到深奥，变化引人入胜。拟制排局和拆解排局有助于锻炼全局观念和残局中攻击点的选择，培养思考和想像能力，有助于提高棋艺水平。
自由取胜
自由取胜，也就是复合取胜或混合取胜，利用一切手段，无论是活三，冲四，还是做杀，抓禁手等等方法，自由取得最后胜利的技术。最常见的自由取胜包括“风车轮”、“二头蛇”等等。
攻防策略
下五子棋须得法，法中变化有莫测；五子之变如水势，因势避高而趋下。战不过攻守，法不过奇正，奇正之法：往复循环，“不竭如江海，无穷如天地”。
其详法如下：围、击虚、就实、寡众。
（围）由于五子棋源于围棋，故下五子棋若想立于不败之地，须以围棋之法行棋，说白了就是“包饺子”，试想：如果对方的棋子被围住了，左冲右突都不行，前闯后退更不见效，此时他心理极度郁闷，已无斗志，棋还能下好吗只能是输的份了招用于防守。
（击虚）兵法有云：“避实击虚”，下五子棋之精髓也在其理。不过此举贵在进攻，进攻若能攻其空虚之处，且得法，将会以迅雷不及掩耳之势而破竹将对手击败。此招用于进攻。
（就实）老子《道德经》中讲了万物正反两个方面及消长之理，攻守亦不过如此，故有“避实击虚”则就有“就实让虚”。“就实让虚”就是对方往哪里走棋，咱就往哪里走棋，好比随形附影一般。这招要把握好火候，不能过度也不能失度，因为下棋很容易攻守易势（攻之极乃守时，守之极乃攻时；攻中生守，守中生攻），此招用于防守。
（寡众）《孙子·虚实》中曰：“备前则后寡，备后则前寡，备左则右寡，备右则左寡，无所不备，则无所不寡。”此招用在五子棋中则反其道而行，则会收到意想不到的效果，具体招法是“堵了前面则堵后面，堵了后面则堵前面，堵了左边则堵右边，堵了右边则堵左边”，前后左右四面八方都堵，则对方则无路可逃，无棋可下此招和（围）连用。无所不胜，用在防守。
另外，有时在有计算的前提下，连续冲三、冲四（vct、vcf）有可能创造新的进攻机会；反之，一味的VC，只能迟滞败亡的步伐，反而使自己被“围”陷入铁桶阵（一般叫马桶阵）中。除了这些外，八卦阵是防守的无二秘宝，只是明八卦太过明显，因此暗八卦（用部分八卦点做主力，少量杂子作障眼）的功底就成了衡量技术的重要指标。
其他玩法
农村流传的一种玩法，也叫进猪笼、五马飞、九子棋。一方选石块，一方选树棍。每人九子，五子上阵，四子后备，吃对方一子则添加一子，最后9子围对方一子进侧方猪笼为赢。棋盘为四相连米字格，加侧面一田字格“猪笼”，行棋可直线也可斜线，不限制步数，不能跳过棋子。吃子方式有，夹、挑、双夹、双挑，扫四。能看棋2步为熟练，3步为高手。
夹：两子单独夹住一子，同线上两子外不能有其他子。
挑：一子走入两子中间，同线上两子外不能有其他子。
双夹：走为四子对称夹住一子，同线上四子外不能有其他子。
双挑：一子走入对称四子中间，同线上四子外不能有其他子。
扫四：一子走到连续四子两头，同线上四子外不能有其他子。
;欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）