五子棋，人机对战，C语言实现。

 

C语言设计一个人机对战的五子棋程序
摘要：五子棋是一种受大众广泛喜爱的游戏，这里介绍五子棋程序的数据结构、评分规则、胜负判断方法，重点分析了搜索算法，并在传统的博弈算法在五子棋应用中进行一些改进，从而使剪枝更有效，运算性能更好。改进包括：不使用closed表；改变棋盘搜索顺序；增加记录最大棋盘信息的指针。实验证明，这几点改进对提高效率有很高帮助。

关键词：五子棋；极大极小值；剪枝；算法改进

近来随着计算机的快速发展，各种棋类游戏被纷纷请进了电脑，使得那些喜爱下棋，又常常苦于没有对手的棋迷们能随时过足棋瘾。而且这类软件个个水平颇高，大有与人脑分庭抗礼之势。其中战胜过国际象棋世界冠军-卡斯帕罗夫的“深蓝”便是最具说服力的代表；其它像围棋的“手淡”、象棋的“将族”等也以其优秀的人工智能深受棋迷喜爱；而我们今天将向大家介绍的是五子棋的算法。 
　　当我们与电脑对战时，您知道这些软件是怎样象人脑一样进行思考的吗？在这里就以此为例和大家一起探讨探讨。

为了使读者对五子棋搜索复杂度有个形象的认识，举一个中国象棋跟五子棋搜索次数的比较（如图）。可以看出同中国象棋相比，五子棋的分支系数大的多，而且胜负条件判断也复杂一些。在极大的分支系数下，搜索程序的最大搜索深度增加1层，耗费的运算时间都将大量增加。因此设计出一个有效的搜索算法是非常重要的。

 

	中国象棋	五子棋
棋子种类	14	2
棋盘大小	9×10	15×15
分支系数	约40	约200
棋子数量	递减	递增
胜负条件	某方将帅丧失	某方五个棋子连成一线

 

文章的组织如下：首先简单介绍用C语言作图的基本方法（Turbo C 2.0环境）以及主循环控制下棋模块，其次介绍设计这个五子棋程序的数据结构，然后介绍了评分算法以及胜负判断，最后重点讨论实现搜索算法。

 

1.         基本的C作图方法及主循环控制模块

 

Turbo C提供了非常丰富的图形函数，所有的图形函数的原型均建立在graphics.h中，在使用图形函数时要确保有显示器图形驱动程序*.BGI，同时将集成开发环境Options/Linker中的Graphics lib选为on，只有这样才能保证正确使用图形函数。

这个程序调用一个EGA、VGA显示器下能独立图形运行的函数。所谓独立图形运行程序，就是在编译和连接时将相应的驱动程序（*.BGI）直接装入到执行程序，从而能在独立的计算机上运行，避免需要重新编译连接才能运行（请查阅参考书1以及源码）。Turbo C进行画点、画线、封闭图形填充以及图形下文本输出只需要调用graphics.h中相关的函数。

主循环控制模块：控制下棋顺序，当轮到某方下子时，负责将程序转到相应的模块中去，主要担当一个调度者的角色。这个五子棋程序是用键盘控制下棋，所以要用到Turbo C中的bios.h。在一个循环块中等待键盘信息，判断键盘所输入的信息是否需要响应，调用相关的代码进行下棋（参考源码中的main函数部分）。

 

2.         五子棋基本数据结构

 

为整个棋盘建立一张表格用以记录棋子信息，使用一个15*15的二维数组 chessman[15][15] (15*15是五子棋棋盘的大小)，数组的每一个元素对应棋盘上的一个交叉点，用“0”表示空位、“1”代表己方棋子、“2”代表对方棋子。这张表也是今后分析的基础。其次要建立一个结构，主要用于搜索过程中，定义如下：

typedef struct five_chess* point;

struct five_chess{

       int x;

       int y;

       int layer;

       int value;

       int score;

       int chess[LENGTH][LENGTH];

       int record[LENGTH][LENGTH];

};

x,y表示在某个位置上扩展出来的新节点，layer是表示第几层扩展，用于控制扩展深度。value表示该点上极大极小值，score表示叶子节点的得分，用于推算父辈节点的value，chess这个二维数组表示扩展出来的棋盘信息，record记录在x、y点上扩展过的节点，如果没有扩展record中对应某个值为0。如果record中没有可以扩展的节点，那么该层扩展结束，返回一个特定值。

数组和一个结构构成了程序的基本数据骨架，今后只要再加入一些辅助变量便可以应付自如了。

 

3.         评分规则以及胜负判断

 

评估一个棋盘的分数，主要通过扫描整个棋盘，对每个点评分。对某个点上评分从四个方向(角度分别为0、45、90、135的四个方向)分别统计，进而累积该点总分，最后得到整个棋盘的分数。实际上对当前的局面按照下面的规则的顺序进行比较，如果满足某一条规则的话，就给该局面打分并保存，然后退出规则的匹配。注意这里的规则是根据一般的下棋规律的一个总结，在实际运行的时候，用户可以添加规则和对评分机制加以修正（源码中选用了其中部分规则）。评分规则如下：

l         判断是否能成5, 如果是机器方的话给予30000分，如果是人方的话给予－30000 分；

l         判断是否能成活4或者是双死4或者是死4活3，如果是机器方的话给予10000分，如果是人方的话给予－10000分

l         判断是否已成双活3，如果是机器方的话给予5000分，如果是人方的话给予－5000 分

l         判断是否成死3活3，如果是机器方的话给予1000分，如果是人方的话给予－1000 分

l         判断是否能成死4，如果是机器方的话给予500分，如果是人方的话给予－500分

l         判断是否能成单活3，如果是机器方的话给予200分，如果是人方的话给予－200分

l         判断是否已成双活2，如果是机器方的话给予100分，如果是人方的话给予－100分

l         判断是否能成死3，如果是机器方的话给予50分，如果是人方的话给予－50分

l         判断是否能成双活2，如果是机器方的话给予10分，如果是人方的话给予－10分

l         判断是否能成活2，如果是机器方的话给予5分，如果是人方的话给予－5分

l         判断是否能成死2，如果是机器方的话给予3分，如果是人方的话给予－3分

   

胜负判断实际上是据当前最后一个落子的情况来判断胜负的。实际上需要从四个位置判断，以该子为出发点的水平，竖直和两条分别为 45度角和135度角的线，目的是看在这四个方向是否最后落子的一方构成连续五个的棋子，如果是的话，就表示该盘棋局已经分出胜负。

 

4.         搜索算法的实现

 

α-β剪枝是在极大极小搜索算法基础上发展起来的，因此先来分析下经典的极大极小搜索过程，如下：

①T:＝（s，MAX），OPEN:＝（s），CLOSED:＝（ ）；开始时树由初始节点构成，OPEN表只含有s。
②LOOP1:IF OPEN＝（ ）THEN GO LOOP2；
③n:＝FIRST（OPEN），REMOVE（n，OPEN），ADD（n，CLOSED）；
④IF n可直接判定为赢、输或平局
THEN f（n）:＝∞∨－∞∨0，GO LOOP1
ELSE EXPAND（n）→{ni}，ADD（{ }，T）
IF d（ni）＜k THEN ADD（{ }，OPEN），GO LOOP1
ELSE计算f（ ），GO LOOP1；nI达到深度k，计算各端节点f值。
⑤LOOP2：IF CLOSED＝NIL THEN GO LOOP3
ELSE :＝FIRST（CLOSED）；
⑥IF（ ∈MAX）∧（f（ ∈MIN）有值）
THEN f（ ）:＝max{f（ ）}，REMOVE（ ，CLOSED）；若MAX所有子节点均有值，则该MAX取其极大值。
IF （ ∈MIN）∧（f（ ∈MAX）有值）
THEN f（ ）:＝min{f（ ）}，REMOVE（ ，CLOSED）；若MIN所有子节点均有值，则该MIN取其极小值。
⑦GO LOOP2；
⑧LOOP3：IF f（s）≠NIL THEN EXIT（END∨M（Move，T））；s有值，则结束或标记走步。

MINIMAX过程是把搜索树的生成和格局估值这两个过程分开来进行，即先生成全部搜索树，然后再进行端节点静态估值和倒推值计算，这显然会导致低效率。为了使生成和估值过程紧密结合，采用有界深度优先策略进行搜索，这样当生成达到规定深度的节点时，就立即计算其静态估值函数，而一旦某个非端节点有条件确定其倒推值时就立即计算赋值。这就是所谓的α-β过程。α-β算法归纳如下：

α剪枝：若任一极小值层节点的β值小于或等于它任一先辈极大值居节点的α值，即α（先辈层）≥β（后继层），则可中止该极小值层中这个MIN节点以下的搜索过程。这个MIN节点最终的倒推值就确定为这个β值

β剪枝：若任一极大值层节点的α值大于或等于它任一先辈极小值层节点的β值，即α（后继层）≥β（先辈层），则可以中止该极大值层中这个MAX节点以下的搜索过程。这个MAX节点的最终倒推值就确定为这个α值。

 

5.         算法的改进

 

这里的算法改进主要是集中于五子棋程序运用上的极大极小、α-β剪枝的改进。这个五子棋的算法流程图如下（以扩展两层为例）：

根据棋盘信息chessman[15][15]建立根结点s0（数据结构：five_chesman）,并把s0压入栈中

扩展s1=top()；判断s1->layer是否等于－1

s1->layer不等于－1，push(s1),扩展s2=top(),查看s2->layer是否－1

s2->layer!=-1，计算此时棋盘得分score，并判断是否要更改上一层的极小值

s2->layer==-1,pop()：判断是否更改极大值，max_chess指向得分最高的棋盘

如果s1->layer=-1,表示搜索结束，返回最大棋盘信息max_chess

 

采用C语言写的代码段如下：

s0=malloc(sizeof(struct five_chess));

for(i=0;i<3000;i++)

close[i]=NULL;

for(i=0;i<LENGTH;i++)

for(j=0;j<LENGTH;j++){

       s0->chess[i][j]=chessman[i][j];

       s0->record[i][j]=chessman[i][j];

}

s0->layer=0;

s0->value=-30000;

s0->score=-30000;

push(s0);

while(is_empty()!=0){

       s0=top();

       s1=expand(s0);

       if(s1->layer==-1){

              pop();

              continue;

       }

       close[num++]=s1;

       s1->value=30000;

       push(s1);

       while(1){

              s2=expand(s1);

              if(s2->layer==-1){

                     s1=top();

                     pop();

                     if(s1->value>top()->value){

                            top()->value=s1->value;

                            max_chess=s1;

                     }

                     break;

              }

              s2->score=score(s2->chess);

              temps=top();

              if(s2->score<temps->value)

                     temps->value=s2->score;

 

这个程序主要特点有：

 

l         没有使用closed表，而改用一个指针指向得分最大的棋盘信息，并且使用一个记录表登记已经扩展过的结点。这样就不需要对closed表进行大量的访问，很大程度上提高了搜索性能。

l         在扩展结点的时候，把棋盘分成三个部分：中间层（坐标5<=x<10,5<=y<10）、第二层（2<=x<12,2<=y<12并且除去中间层的那些点），第三层（0<=x<14,0<=y<14除去中间层和第二层的结点）。把棋盘分成这样三个部分扩展的依据是：越靠近中间位置的结点得分越高，这样先从得分高的结点开始计算，那么剪枝的次数就更多，从而很大程度上提高运算效率。实际上，扩展的最佳算法是以中间结点为中心，采用螺旋式搜索，这样最大程度上提高效率。

l         使用一个记录得分最高的棋盘信息的指针typedef struct five_chess *point，这点改进能节省大量空间。因为扩展过程的结点非常多，如果采用这个改进，那么就可以扩展后删除那些占用空间。此外在返回棋盘信息时，查找某个位置下棋也非常方便。

 

参考文献：

 

[1]. 马少平,朱小燕 .人工智能. 北京：清华大学出版社，2004

[2]. 汪晓平.C语言高级实例解析.北京：清华大学出版社，2002

/*
 * 使用键盘的上下左右键移动棋盘，空格键表示下棋，ESC键退出程序
 */
#include <stdio.h>
#include <stdlib.h>
#include <bios.h>
#include <graphics.h>
#include<malloc.h>
/*
 * 对应键盘键的十六进制数字
 */
#define ESC 0x11b
#define UP 0x4800
#define DOWN 0x5000
#define LEFT 0x4b00
#define RIGHT 0x4d00
#define BLANK 0x3920

#define PLAYER1 1
#define PLAYER2 2
#define COMPUTER 2
#define LENGTH 15
#define SEARCH_DEEP 2
/*
 * 用来在函数can_expand()查找可以扩展的节点步长
 */
#define STEP 1

/************全局变量定义***************/
int             x1 = 240,
                y1 = 240,
                oldx = 240,
                oldy = 240;
int             key_mode;
int             key_net;
int             step_sum = 0;
int             chessman[LENGTH][LENGTH];
int             depth = 2; /* 搜索的深度 */
int             a = 0,
                b = 0;
int             flag_run;
int             win_flag = 0;

typedef struct five_chess *point;
struct five_chess {
    int             x;
    int             y;
    int             layer;
    double          value;
    double          score;
    int             chess[LENGTH][LENGTH];
    int             record[LENGTH][LENGTH];
} A;

int             stack_deep0 = 0;
point           stack_c[10];
point           close[600];

void
push(point s0)
{
    if (stack_deep0 < 10)
 stack_c[stack_deep0++] = s0;
}

point
top()
{
    if (stack_deep0 > 0)
 return stack_c[stack_deep0 - 1];
    /*else return 一个什么样的东西?*/
}

void
pop()
{
    if (stack_deep0 > 0)
 stack_deep0--;
}

int
is_empty()
{
    if (stack_deep0 != 0)
 return 1;
    else
 return 0;
}

 

/************函数的声明**************/
void            five();
void            show();
int             win_or_not(int x0, int y0, int who,
      int chessman[LENGTH][LENGTH], int a);
void            set_chessman();
void            print_result();
/************评价函数部分************/
double          score_row(int i, int j, int chessman[LENGTH][LENGTH]);
double          score_col(int i, int j, int chessman[LENGTH][LENGTH]);
double          score_diag_45(int i, int j, int chessman[LENGTH][LENGTH]);
double          score_diag_135(int i, int j, int chessman[LENGTH][LENGTH]);
double          total_score(int who_running, int chessman[LENGTH][LENGTH]);
double          score(int chessman[LENGTH][LENGTH]);
int             rowdt(int i, int j, int chessman[LENGTH][LENGTH]);
int             coldt(int i, int j, int chessman[LENGTH][LENGTH]);
int             diadt(int i, int j, int chessman[LENGTH][LENGTH]);
int             vdiadt(int i, int j, int chessman[LENGTH][LENGTH]);
int             can_expand(int i, int j, int chessman[LENGTH][LENGTH]);
void          copy(point s1, point s0);

int
POW(int s, int t)
{
    int             sum = s,
                    i;
    if (t <= 0)
 return 1;
    for (i = 0; i < t; i++)
 sum *= sum;
    return sum;

}

/*
 * 定义computer先手
 */
point
expand(point s0)
{
    int             flag;
    int             i,
                    j;
    point           new_chess = (point) malloc(sizeof(struct five_chess));
/*************************这里出错***********************************/
    for (i = 0; i < LENGTH; i++)
 for (j = 0; j < LENGTH; j++)
     new_chess->chess[i][j] = s0->chess[i][j];

    for (i = 0; i < LENGTH; i++)
 for (j = 0; j < LENGTH; j++)
     new_chess->record[i][j] = s0->chess[i][j];

/*************************这里出错***********************************/
    if (s0->layer % 2 == 0)
 flag = COMPUTER;
    else
 flag = PLAYER1;

    for (i = 0; i < LENGTH; i++)
 for (j = 0; j < LENGTH; j++) {

     if (s0->record[i][j])                          /*如果有棋子*/
  continue;
     if (can_expand(i, j, s0->chess) == 0)    /*如果有棋子，而且沿水平，树直，左上—右下，右上—左下，四个方向可以扩展*/
  continue;
     s0->record[i][j] = flag;
     new_chess->chess[i][j] = flag;
     new_chess->layer = s0->layer + 1;
     new_chess->x = i;
     new_chess->y = j;
     new_chess->record[i][j] = flag;
     return new_chess;
 }
    /*
     * for(i=5;i<10;i++) for(j=5;j<10;j++){ if(s0->record[i][j]) continue;
     * if(can_expand(i,j,s0->chess)==0) continue; s0->record[i][j]=flag;
     * new_chess->x=i; new_chess->y=j; new_chess->record[i][j]=flag;
     * new_chess->layer=s0->layer+1; new_chess->chess[i][j]=flag ; return
     * new_chess; } for(i=2;i<12;i++) for(j=2;j<12;j++){
     * if(i>4&&i<10&&j>4&&j<10) continue; if(s0->record[i][j]) continue;
     * if(can_expand(i,j,s0->chess)==0) continue; s0->record[i][j]=flag;
     * new_chess->x=i; new_chess->y=j; new_chess->record[i][j]=flag;
     * new_chess->layer=s0->layer+1; new_chess->chess[i][j]=flag; return
     * new_chess;
     *
     * } for(i=0;i<LENGTH;i++) for(j=0;j<LENGTH;j++){
     * if(i>1&&i<12&&j>1&&j<12) continue; if(s0->record[i][j]) continue;
     * if(can_expand(i,j,s0->chess)==0) continue; s0->record[i][j]=flag;
     * new_chess->chess[i][j]=flag; new_chess->layer=s0->layer+1;
     * new_chess->x=i; new_chess->y=j; new_chess->record[i][j]=flag; return
     * new_chess; }
     */
    new_chess->layer = -1;
    return new_chess;
}

 

void
computer()
{
    int             i,
                    j,
                    k,
                    num = 0;
    int             break_now = 0;
    int             break_then = 0;
    int             go_on = 0;
    point         s0 = NULL,
                    s1 = NULL,
                    s2 = NULL,
                    max_chess = NULL;
    point          temps = NULL,
                    s01;
    /*
     * 堆栈的初始化
     */
    stack_deep0 = 0;
    s0 = malloc(sizeof(struct five_chess));
    for (i = 0; i < 600; i++)                           /*为什么是600*/
 close[i] = NULL;                                  /*close是一个point 数组*/
    close[num++] = s0;
    for (i = 0; i < LENGTH; i++)
 for (j = 0; j < LENGTH; j++) {
     s0->chess[i][j] = chessman[i][j];
     s0->record[i][j] = chessman[i][j];
 }
    s0->layer = 0;
    s0->value = -3000000;
    s0->score = -3000000;
    push(s0);
    while (is_empty() != 0) {                /*看是栈否为空*/
 s01 = top();                                   /*如果不是空*/
 s1 = expand(s01);                         /*从栈顶开始展开*/
 close[num++] = s1;
 if (s1->layer == -1) {
     pop();
     continue;
 }
 go_on =
     win_or_not((s1->x + 1) * 30, (s1->y + 1) * 30, 2, s1->chess,
         1);
 if (go_on == 2) {
     a = (s1->x + 1) * 30;
     b = (s1->y + 1) * 30;
     break_then = 1;
     break;
 }
 go_on =
     win_or_not((s1->x + 1) * 30, (s1->y + 1) * 30, 1, s1->chess,
         1);
 if (go_on == 1) {
     a = (s1->x + 1) * 30;
     b = (s1->y + 1) * 30;
     break_then = 1;
     break;
 }
 s1->value = 30000;
 push(s1);
 while (1) {
     s1 = top();
     s2 = expand(s1);
     if (s2->layer == -1) {
  pop();
  if (s1->value > top()->value) {
      top()->value = s1->value;
      max_chess = s1;
  }
  free(s2);
  break;
     }//end of if
     s2->score = score(s2->chess);
     temps = top();
     if (s2->score < temps->value)
  temps->value = s2->score;
     free(s2);
 }//end of whiile(1)
    }
    if (break_then == 0) {
 for (i = 0; i < LENGTH; i++) {
     for (j = 0; j < LENGTH; j++)
  if (max_chess->chess[i][j] != chessman[i][j]) {
      a = i * 30 + 30;
      b = j * 30 + 30;
      break_now = 1;
      break;
  }
     if (break_now == 1)
  break;
 }
    }
    for (i = 0; i < 600; i++) {
 if (close[i] == NULL)
     continue;
 free(close[i]);
    }

}

/**********************************************************/
void
main()
{
    int             key;
    int             play_with_who = 1;

    printf("1.Play with human/n2.Play with computer/nPlease choice: ");
    scanf("%d", &play_with_who);
 
    five();                           /*显示棋盘*/
    show();

    if (play_with_who == 1) {      /*人与人玩*/
 while (1) {    /*设置人与人玩的界面*/
     settextstyle(0, 0, 2);
     if ((step_sum + 1) % 2) {
  setcolor(1);
  outtextxy(500, 180, "Player2");
  setcolor(4);
  outtextxy(500, 180, "Player1");
     } else {
  setcolor(1);
  outtextxy(500, 180, "Player1");
  setcolor(10);
  outtextxy(500, 180, "Player2");
     }

     if (bioskey(1))
  /*
   * 按了一次键盘那么就true，执行下面代码，这是bios。h
   */
     {
  key = bioskey(0);
  /*
   * 返回一个键盘值，如没有按键，则一直等待
   */
  switch (key) {
  case ESC:
      exit(0);
  case LEFT:
      if (x1 > 30) {
   x1 -= 30;
   show();      /*显示方框*/
      }
      break;
  case UP:
      if (y1 > 30) {
   y1 -= 30;
   show();
      }
      break;
  case RIGHT:
      if (x1 < 450) {
   x1 += 30;
   show();
      }
      break;
  case DOWN:
      if (y1 < 450) {
   y1 += 30;
   show();
      }
      break;
  case BLANK:                  /*按下空格键后放置棋子*/
      {
   if (chessman[x1 / 30][y1 / 30])
       break;              /*如果当前位置有棋子，不能放置，退出*/
   step_sum++;       /*如果没有棋子，下一步谁走加1*/
   /*
    * P1 设置棋子
    */
   if (step_sum % 2) {
       setcolor(15);    /*画棋子*/
       setfillstyle(SOLID_FILL, 15); /* 封闭图形，进行实体填充*/
       circle(x1, y1, 10);           /*画圆*/
       floodfill(x1, y1, 15);       /*填充圆*/
       chessman[x1 / 30][y1 / 30] = PLAYER1;               /*设置棋盘状态*/
       win_flag = win_or_not(x1, y1, 1, chessman, 0);      /*分析游戏是否结束,谁胜谁败*/
       if (win_flag == 1)
    outtextxy(480, 240, "P1 Win");
       else if (win_flag == 3)
    outtextxy(480, 240, "DOGFALL");
       if (win_flag != 0) {                     /*如果没人胜，游戏继续*/
    while (bioskey(1) == 0);
    closegraph();                       /*what this mean?*/
       }
   } else { /* P2 设置棋子 */

       setcolor(12);                       
       setfillstyle(SOLID_FILL, 12);
       circle(x1, y1, 10);
       floodfill(x1, y1, 12);
       chessman[x1 / 30][y1 / 30] = PLAYER2;
       win_flag = win_or_not(x1, y1, 2, chessman, 0);
       if (win_flag == 2)
    outtextxy(480, 240, "P2 Win");
       else if (win_flag == 3)
    outtextxy(480, 240, "DOGFALL");
       if (win_flag != 0) {
    while (bioskey(1) == 0);
    closegraph();
       }
   }

 

      }
      break;
  }
     }
 }
    } else {
 chessman[7][7] = COMPUTER;             /*人和电脑玩,电脑先走一步*/          
 setcolor(12);
 setfillstyle(SOLID_FILL, 12);
 circle(240, 240, 10);
 floodfill(240, 240, 12);
 flag_run = 0;                    /*有什么用?*/
 step_sum++;                   /*下一步谁走？*/
 while (1) {
     while (1) {
  if (flag_run == 1)
      break;
  if (bioskey(1)) {
      key = bioskey(0);
      /*
       * 返回一个键盘值，如没有按键，则一直等待
       */
      switch (key) {

      case ESC:
   exit(0);
      case LEFT:
   if (x1 > 30) {
       x1 -= 30;
       show();
   }
   break;
      case UP:
   if (y1 > 30) {
       y1 -= 30;
       show();
   }
   break;
      case RIGHT:
   if (x1 < 450) {
       x1 += 30;
       show();
   }
   break;
      case DOWN:
   if (y1 < 450) {
       y1 += 30;
       show();
   }
   break;
      case BLANK:
   {
       if (chessman[x1 / 30 - 1][y1 / 30 - 1])
    break;                                                          /*有棋子了不走*/

       setcolor(15);
       setfillstyle(SOLID_FILL, 15); /* 封闭图形，进行实体填充
         */
       circle(x1, y1, 10);
       floodfill(x1, y1, 15);                              /*画棋子*/
       chessman[x1 / 30 - 1][y1 / 30 - 1] = PLAYER1;

       flag_run = 1;                                  /*有什么用?*/
       step_sum++;                                 /*下一步谁走*/
       win_flag = win_or_not(x1, y1, 1, chessman, 0);   /*谁胜谁负*/
       if (win_flag == 1)
    outtextxy(480, 240, "P1 Win");
       else if (win_flag == 3)
    outtextxy(480, 240, "DOGFALL");
       if (win_flag != 0) {
    while (bioskey(1) == 0);                                 /*没有人胜则继续等待下棋*/
    closegraph();
       }

   }
      }  /* switch */

  }

     }
     computer();                                            /*调用智能体*/
     /*
      * a,b存放的是现在电脑准备下的位置
      * 返回一个a,b的结构体不是更好，用全局变量不爽啊
      * struct {
      *          int a;
      *         int b;
      *  }
      */

     setcolor(12);
     setfillstyle(SOLID_FILL, 12);
     circle(a, b, 10);
     floodfill(a, b, 12);
     chessman[a / 30 - 1][b / 30 - 1] = COMPUTER;
     flag_run = 0;
     step_sum++;
     win_flag = win_or_not(a, b, 2, chessman, 0);
     if (win_flag == 2)
  outtextxy(480, 240, "ComputerWin");
     else if (win_flag == 3)
  outtextxy(480, 240, "DOGFALL");
     if (win_flag != 0) {
  while (bioskey(1) == 0);
  closegraph();
     }

 

 

 }
    }

}
void
five()
{
    int             i,
                    j;
    /*
     * 画棋盘的过程
     */
    int             gdriver = DETECT,
                    gmode;
    registerbgidriver(EGAVGA_driver);
    initgraph(&gdriver, &gmode, " ");
    /*
     * 对显示适配器进行配置
     */
    setbkcolor(1);

    for (i = 0; i < 30; i++) {
 setcolor((i >= 2) ? 9 : i);
 rectangle(i, i, 479 - i, 479 - i); /* 画矩形边框 */
    }
    /*
     * 画棋盘
     */
    for (i = 1; i < 14; i++)
 for (j = 1; j < 14; j++) {
     setcolor(14);
     line(30 + 30 * i, 30, 30 + 30 * i, 449);
     line(30, 30 + 30 * i, 449, 30 + 30 * i);
 }
    /*
     * 画整个图的边框
     */
    for (i = 0; i < 15; i++) {
 setcolor(i);
 rectangle(i, i, 640 - i, 480 - i);
 line(480 - i, 15, 480 - i, 465);
    }
    /*
     * 输出屏幕右侧的信息
     */
    setcolor(4);
    settextstyle(0, 0, 2);
    outtextxy(500, 45, "GOBANG");
    setcolor(10);
    settextstyle(0, 0, 1);
    outtextxy(500, 90, "Designed By");
    outtextxy(514, 118, "Ye Binbin");
    outtextxy(480, 140, "from class A of CS");

}

/*
 * 移动光标
 */
void
show()
{
    setcolor(1);

    if (oldx < 450) {
 if (oldy > 30)
     line(oldx + 7, oldy - 15, oldx + 15, oldy - 15);
 if (oldy > 30)
     line(oldx + 15, oldy - 15, oldx + 15, oldy - 7);
 if (oldy < 450)
     line(oldx + 15, oldy + 7, oldx + 15, oldy + 15);
 if (oldy < 450)
     line(oldx + 15, oldy + 15, oldx + 7, oldy + 15);
    }
    if (oldx > 30) {
 if (oldy < 450)
     line(oldx - 7, oldy + 15, oldx - 15, oldy + 15);
 if (oldy < 450)
     line(oldx - 15, oldy + 15, oldx - 15, oldy + 7);
 if (oldy > 30)
     line(oldx - 15, oldy - 7, oldx - 15, oldy - 15);
 if (oldy > 30)
     line(oldx - 15, oldy - 15, oldx - 7, oldy - 15);
    }
    setcolor(12);
    if (x1 < 450) {
 if (y1 > 30)
     line(x1 + 7, y1 - 15, x1 + 15, y1 - 15);
 if (y1 > 30)
     line(x1 + 15, y1 - 15, x1 + 15, y1 - 7);
 if (y1 < 450)
     line(x1 + 15, y1 + 7, x1 + 15, y1 + 15);
 if (y1 < 450)
     line(x1 + 15, y1 + 15, x1 + 7, y1 + 15);
    }

    if (x1 > 30) {
 if (y1 < 450)
     line(x1 - 7, y1 + 15, x1 - 15, y1 + 15);
 if (y1 < 450)
     line(x1 - 15, y1 + 15, x1 - 15, y1 + 7);
 if (y1 > 30)
     line(x1 - 15, y1 - 7, x1 - 15, y1 - 15);
 if (y1 > 30)
     line(x1 - 15, y1 - 15, x1 - 7, y1 - 15);
    }
    oldx = x1;
    oldy = y1;

}

 

void
set_chessman()
{
    /*
     * 棋子有三种状态，0是未初始状态，1是控制方棋子，2是对方棋子
     */
    int             i,
                    j;
    for (i = 0; i < 15; i++)
 for (j = 0; j < 15; j++)
     chessman[i][j] = 0;
}

/*
 * 0表示没有赢，1表示p1胜利，2表示p2胜利，3表示平局
 */
int
win_or_not(int x0, int y0, int who, int chessman[LENGTH][LENGTH], int a)
{
    int             i = x0 / 30 - 1,
                    j = y0 / 30 - 1;
    int             who_run = who;
    int             line_sum = -1;
    int             tmp_i = i,
                    tmp_j = j;
    int             c;
    if (a == 1) {
 /*
  * 测试第一层扩展是否满足赢的条件
  */
 c = chessman[i][j];
 chessman[i][j] = who_run;
    }

    while (1) {   /* 查找共行的棋子是否连接了五个 */
 while (tmp_i >= 0 && line_sum != 4) {
     if (chessman[tmp_i--][j] == who_run)
  line_sum++;
     else
  break;
 }
 if (line_sum == 4)
     line_sum++;
 tmp_i = i;
 while (tmp_i <= 15 && line_sum != 5) {
     if (chessman[tmp_i++][j] == who_run)
  line_sum++;
     else
  break;
 }
 if (line_sum == 5) {
     if (a == 1)
  chessman[i][j] = c;
     return who_run;
 }
 line_sum = -1;
 tmp_i = i;
 break;

    }
    while (1) {   /* 查找共列的棋子是否连接了五个 */
 while (tmp_j >= 0 && line_sum != 4) {
     if (chessman[i][tmp_j--] == who_run)
  line_sum++;
     else
  break;
 }
 if (line_sum == 4)
     line_sum++;
 tmp_j = j;
 while (tmp_j <= 15 && line_sum != 5) {
     if (chessman[i][tmp_j++] == who_run)
  line_sum++;
     else
  break;
 }
 if (line_sum == 5) {
     if (a == 1)
  chessman[i][j] = c;
     return who_run;
 }
 line_sum = -1;
 tmp_j = j;
 break;

    }
    while (1) {   /* 查找上对角线上是否连接了五个 */
 while (line_sum != 4 && tmp_i <= 15 && tmp_j >= 0) {
     if (chessman[tmp_i++][tmp_j--] == who_run)
  line_sum++;
     else
  break;
 }
 tmp_i = i;
 tmp_j = j;
 if (line_sum == 4)
     line_sum++;
 while (line_sum != 5 && tmp_i >= 0 && tmp_j <= 15) {
     if (chessman[tmp_i--][tmp_j++] == who_run)
  line_sum++;
     else
  break;
 }
 if (line_sum == 5) {
     if (a == 1)
  chessman[i][j] = c;
     return who_run;
 }
 tmp_i = i;
 tmp_j = j;
 line_sum = -1;
 break;
    }
    while (1) {   /* 查找下对角线上是否连接了五个 */
 while (line_sum != 4 && tmp_i >= 0 && tmp_j >= 0) {
     if (chessman[tmp_i--][tmp_j--] == who_run)
  line_sum++;
     else
  break;
 }
 tmp_i = i;
 tmp_j = j;
 if (line_sum == 4)
     line_sum++;
 while (line_sum != 5 && tmp_i <= 15 && tmp_j <= 15) {
     if (chessman[tmp_i++][tmp_j++] == who_run)
  line_sum++;
     else
  break;
 }
 if (line_sum == 5) {
     if (a == 1)
  chessman[i][j] = c;
     return who_run;
 }
 break;
    }
    if (step_sum == 225) {
 if (a == 1)
     chessman[i][j] = c;
 return 3;
    }
    if (a == 1)
 chessman[i][j] = c;
    return 0;

}

 

double
score_row(int i, int j, int chessman[LENGTH][LENGTH])
{
    int             sum_chessmen = 0;
    double          score = 0;
    int             mid_j;
    int             who_running = chessman[i][j];
    if (j == LENGTH) {
 while (chessman[i][j] == who_running) {
     j--;
     sum_chessmen++;
 }
 if (sum_chessmen >= 5)
     score = 200000;
 else {
     if (chessman[i][j] == 0) /* 没有下子,活的情况 */
  score = 2000 / POW(10, 4 - sum_chessmen);
     else
  score = 0; /* 死的情况 */
 }
    } else {
 while (chessman[i][j] == who_running && j != LENGTH) {
     j++;
     sum_chessmen++;
 }
 mid_j = j;
 j = j - sum_chessmen - 1;
 while (chessman[i][j] == who_running && j != -1) {
     j--;
     sum_chessmen++;
 }
 if (j >= 0 && mid_j < LENGTH) {
     if (chessman[i][j] == 0 && chessman[i][mid_j] == 0)
  score = 18000 / POW(50, 4 - sum_chessmen);
     else if ((chessman[i][j] != 0 && chessman[i][mid_j] == 0)
       || (chessman[i][j] == 0 && chessman[i][mid_j] != 0))
  score = 2000 / POW(10, 4 - sum_chessmen);
     else
  score = 0;
 }
 if (j < 0 && mid_j < LENGTH) {
     if (chessman[i][mid_j] == 0)
  score = 2000 / POW(10, 4 - sum_chessmen);
     else
  score = 0;
 }
 if (j >= 0 && mid_j >= LENGTH) {
     if (chessman[i][j] == 0)
  score = 2000 / POW(10, 4 - sum_chessmen);
     else
  score = 0;
 }
 if (j < 0 && mid_j >= LENGTH)
     score = 0;
    }
    return score;
}

double
score_col(int i, int j, int chessman[LENGTH][LENGTH])
{
    int             sum_chessmen = 0,
                    mid_i;
    double          score = 0;
    int             who_running = chessman[i][j];
    if (i == LENGTH) {
 while (chessman[i][j] == who_running) {
     i--;
     sum_chessmen++;
 }
 if (sum_chessmen >= 5)
     score = 200000;
 if (chessman[i][j] == 0)
     score = 2000 / POW(10, 4 - sum_chessmen);
 else
     score = 0;
    } else {
 while (chessman[i][j] == who_running) {
     i++;
     sum_chessmen++;
 }
 mid_i = i;
 if (i == LENGTH || chessman[i][j] != who_running) {
     i = i - sum_chessmen;
     while (chessman[i - 1][j] == who_running) {
  i--;
  sum_chessmen++;
     }
     if (i >= 0) {
  if (chessman[i][j] == 0 && chessman[mid_i][j] == 0)
      score = 18000 / POW(50, 4 - sum_chessmen);
  else if ((chessman[i][j] != 0 && chessman[mid_i][j]) == 0
    || (chessman[i][j] == 0
        && chessman[mid_i][j] != 0))
      score = 2000 / POW(10, 4 - sum_chessmen);
  else
      score = 0;
     }
     if (i < 0 && mid_i < LENGTH) {
  if (chessman[mid_i][j] == 0)
      score = 2000 / POW(10, 4 - sum_chessmen);
  else
      score = 0;
     }
     if (i < 0 && mid_i < LENGTH) {
  if (chessman[mid_i][j] == 0)
      score = 2000 / POW(10, 4 - sum_chessmen);
  else
      score = 0;
     }
     if (i >= 0 && mid_i >= LENGTH) {
  if (chessman[i][j] == 0)
      score = 2000 / POW(10, 4 - sum_chessmen);
  else
      score = 0;
     }
 }
    }
    return score;
}

double
score_diag_45(int i, int j, int chessman[LENGTH][LENGTH])
{
    int             sum_chessmen = 0;
    double          score = 0;
    int             mid_i,
                    mid_j;
    int             who_running = chessman[i][j];
    if (i == LENGTH || j == LENGTH) {
 while (chessman[i][j] == who_running && i > 1 && j > 1) {
     i--;
     j--;
     sum_chessmen++;
 }
 if (sum_chessmen >= 5)
     score = 200000;
 else {
     if (chessman[i][j] == 0)
  score = 2000 / POW(10, 4 - sum_chessmen);
     else
  score = 0;
 }
    } else {
 while (chessman[i][j] == who_running && i <= LENGTH && j <= LENGTH) {
     i++;
     j++;
     sum_chessmen++;
 }
 mid_i = i;
 mid_j = j;
 i = i - sum_chessmen;
 j = j - sum_chessmen;
 while (chessman[i - 1][j - 1] == who_running) {
     i--;
     j--;
     sum_chessmen++;
 }
 if (sum_chessmen >= 5)
     score = 200000;
 if (i >= 0 && j >= 0 && mid_i < LENGTH && mid_j < LENGTH) {
     if (chessman[mid_i][mid_j] == 0 && chessman[i][j] == 0)
  score = 18000 / POW(50, 4 - sum_chessmen);
     else if ((chessman[mid_i][mid_j] == 0 && chessman[i][j] != 0)
       || (chessman[mid_i][mid_j] != 0
    && chessman[i][j] == 0))
  score = 2000 / POW(10, 4 - sum_chessmen);
     else
  score = 0;
 } else {
     if (i >= 0 && j >= 0) {
  if (chessman[i][j] == 0)
      score = 2000 / POW(10, 4 - sum_chessmen);
  else
      score = 0;
     } else if (mid_i < LENGTH && mid_j < LENGTH) {
  if (chessman[mid_i][mid_j] == 0)
      score = 2000 / POW(10, 4 - sum_chessmen);
  else
      score = 0;
     } else
  score = 0;
 }
    }
    return score;
}

double
score_diag_135(int i, int j, int chessman[LENGTH][LENGTH])
{
    int             sum_chessmen = 0;
    double          score = 0;
    int             mid_i,
                    mid_j;
    int             who_running = chessman[i][j];
    while (chessman[i][j] == who_running && j != -1 && i < LENGTH) {
 i++;
 j--;
 sum_chessmen++;
    }
    mid_i = i;
    mid_j = j;
    j += sum_chessmen;
    i -= sum_chessmen;
    j++;
    i--;
    while (chessman[i][j] == who_running && j != LENGTH) {
 i--;
 j++;
 sum_chessmen++;
    }
    if (sum_chessmen >= 5)
 score = 200000;
    else {
 if (i >= 0 && j < LENGTH && mid_j >= 0 && mid_i < LENGTH) {
     if (chessman[i][j] == 0 && chessman[mid_i][mid_j] == 0)
  score = 18000 / POW(50, 4 - sum_chessmen);
     else {
  if ((chessman[i][j] == 0 && chessman[mid_i][mid_j] != 0)
      || (chessman[i][j] != 0
   && chessman[mid_i][mid_j] == 0))
      score = 2000 / POW(10, 4 - sum_chessmen);
  else
      score = 0;
     }
 } else {
     if (i >= 0 && j < LENGTH) {
  if (chessman[i][j] == 0)
      score = 2000 / POW(10, 4 - sum_chessmen);
  else
      score = 0;
     }
     if (mid_j >= 0 && mid_i < LENGTH) {
  if (chessman[mid_i][mid_j] == 0)
      score = 2000 / POW(10, 4 - sum_chessmen);
  else
      score = 0;
     }
 }
    }
    return score;
}

double
total_score(int who_running, int chessman[LENGTH][LENGTH])
{
    /*
     * 统计出在该点上的得分,who_running=1表示人的棋子,2为电脑的棋子
     */
    int             i,
                    j;
    double          score = 0;
    for (i = 0; i < LENGTH; i++)
 for (j = 0; j < LENGTH; j++) {
     if (chessman[i][j] == who_running) {
  score += score_row(i, j, chessman);
  score += score_col(i, j, chessman);
  score += score_diag_45(i, j, chessman);
  score += score_diag_135(i, j, chessman);
     }
 }
    return score;
}

double
score(int chessman[LENGTH][LENGTH])
{
    /*
     * 计算最终的得分数,分别考虑了在这个位置放对方棋子跟自己棋子的综合
     */
    double          sum1,
                       sum2;
    sum1 = total_score(COMPUTER, chessman);
    sum2 = total_score(PLAYER1, chessman);
    return sum1 - sum2;
}

/*
 * 扩展-----剪枝过程
 */

int
rowdt(int i, int j, int chessman[LENGTH][LENGTH])    /*在树直方向*/
{
    int             k;
    int             midjl = j - STEP,                 /*当前棋子的上方*/
                    midjr = j + STEP + 1;         /*当前棋子的下方棋子的下方??????*/
    if (midjl < 0)                                     
 midjl = 0;                  
    if (midjr > LENGTH)
 midjr = LENGTH;
    for (k = midjl; k < midjr; k++)             /**/
 if (chessman[i][k] != 0)                 /*如果有棋子*/
     return 1;
    return 0;
}

int
coldt(int i, int j, int chessman[LENGTH][LENGTH])          /*水平方向*/
{
    int             k;
    int             midil = i + STEP + 1,                  /*当前的右边棋子的右一个*/
                    midiu = i - STEP;                       /*当前棋子的左一个*/
    if (midiu < 0)
 midiu = 0;
    if (midil > LENGTH)
 midil = LENGTH;
    for (k = midiu; k < midil; k++)
 if (chessman[k][j] != 0)
     return 1;
    return 0;
}

int
diadt(int i, int j, int chessman[LENGTH][LENGTH])      /*右上到左下方向*/
{
    int             k,
                    midi,
                    midj;
    midi = i;
    midj = j;
    for (k = 0; k < STEP; k++) {
 midi++;
 midj--;
 if (midj < 0 || midi >= LENGTH)
     break;
 if (chessman[midi][midj] != 0)
     return 1;
    }
    for (k = 0; k < STEP; k++) {
 i--;
 j++;
 if (i < 0 || j >= LENGTH)
     break;
 if (chessman[i][j] != 0)
     return 1;
    }
    return 0;
}

int
vdiadt(int i, int j, int chessman[LENGTH][LENGTH])    /*左上到右下方向*/
{
    int             k,
                    midi,
                    midj;
    midi = i;
    midj = j;
    for (k = 0; k < STEP; k++) {
 midi--;
 midj--;
 if (midi < 0 || midj < 0)
     break;
 if (chessman[midi][midj] != 0)
     return 1;
    }
    for (k = 0; k < STEP; k++) {
 i++;
 j++;
 if (j >= LENGTH || i >= LENGTH)
     break;
 if (chessman[i][j] != 0)
     return 1;
    }
    return 0;
}

int
can_expand(int i, int j, int chessman[LENGTH][LENGTH])
{
    if (rowdt(i, j, chessman))
 return 1;
    if (coldt(i, j, chessman))
 return 1;
    if (diadt(i, j, chessman))
 return 1;
    if (vdiadt(i, j, chessman))
 return 1;
    /*
     * 如果不能扩展,返回0
     */
    return 0;
}

/************************************************************/