|
|
#define _CRT_SECURE_NO_WARNINGS
|
|
|
|
|
|
#include<stdio.h>
|
|
|
#include<stdlib.h>
|
|
|
#include<string.h>
|
|
|
#include<math.h>
|
|
|
#include<time.h>
|
|
|
|
|
|
#define BLACK 0
|
|
|
#define WHITE 1
|
|
|
#define EMPTY 2
|
|
|
|
|
|
struct Point { //点结构
|
|
|
int x, y;
|
|
|
};
|
|
|
struct Step { //步结构
|
|
|
Point first, second;
|
|
|
int value;
|
|
|
};
|
|
|
int Board[19][19];//存储棋盘信息，其元素值为 BLACK, WHITE, EMPTY 之一
|
|
|
|
|
|
/*以下为本人写的函数*/
|
|
|
|
|
|
struct directs {
|
|
|
//directX表示每个方向有几个相连，liveX表示每个方向是死0、眠1、活2
|
|
|
int direct[4];
|
|
|
int live[4];
|
|
|
};
|
|
|
|
|
|
struct point {
|
|
|
int x;
|
|
|
int y;
|
|
|
int mark;
|
|
|
};
|
|
|
|
|
|
//函数声明
|
|
|
void copy(int board1[19][19], int board2[19][19]);
|
|
|
int markslef(int* result);
|
|
|
int markenemy(int *result);
|
|
|
|
|
|
void analyse(int thearray[19], int side, int *result);
|
|
|
int* analyse1(int board[19][19], int side,int g,int h);//x,y为当前棋子位置
|
|
|
void analyse_horizontal(int board[19][19], int*result, int side,int g,int h);//" — "
|
|
|
void analyse_vertical(int board[19][19], int*result, int side,int g,int h);//" 丨 "
|
|
|
void analyse_oblique1(int board[19][19], int*result, int side,int g,int h);//" \ "
|
|
|
void analyse_oblique2(int board[19][19], int*result, int side,int g,int h);//" / "
|
|
|
bool surround(int board[19][19], int x, int y, int side);//用来判断该子周围两格内是不是空
|
|
|
|
|
|
bool surround(int board[19][19], int x, int y, int side)//周围有棋子返回ture，全是空白返回false
|
|
|
{
|
|
|
for (int i = -3; i < 4; i++)
|
|
|
{
|
|
|
if (x + i > 18)
|
|
|
break;
|
|
|
for (int j = -3; j < 4; j++)
|
|
|
{
|
|
|
while (x + i < 0)
|
|
|
i += 1;
|
|
|
while (y + j < 0)
|
|
|
j += 1;
|
|
|
if (i == 0 & j == 0)
|
|
|
j += 1;
|
|
|
if (y + j > 18)
|
|
|
break;
|
|
|
if (board[x + i][y + j] == WHITE || board[x + i][y + j] == BLACK)
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
void analyse_horizontal(int board[19][19], int*result, int side,int g,int h)
|
|
|
{
|
|
|
int thearray[19];
|
|
|
for (int l = 0; l < 19; l++)
|
|
|
thearray[l] = board[g][l];
|
|
|
analyse(thearray, side, result);
|
|
|
}
|
|
|
void analyse_vertical(int board[19][19], int*result, int side,int g,int h)
|
|
|
{
|
|
|
int thearray[19];
|
|
|
for (int l = 0; l < 19; l++)
|
|
|
thearray[l] = board[l][h];
|
|
|
analyse(thearray, side, result);
|
|
|
}
|
|
|
void analyse_oblique1(int board[19][19], int*result, int side,int g,int h)//" \ "
|
|
|
{
|
|
|
int thearray[19];
|
|
|
for (int x = 5; x < 19; x++)
|
|
|
{
|
|
|
int judge = 0;
|
|
|
for (int k = 0; k < 19; k++)
|
|
|
thearray[k] = -1;
|
|
|
for (int y = 0; y <= x; y++)
|
|
|
{
|
|
|
if (g==y&&h==18-x+y)
|
|
|
{
|
|
|
judge = 1;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (judge == 1)
|
|
|
{
|
|
|
for (int y = 0; y <= x; y++)
|
|
|
thearray[y] = board[y][18 - x + y];
|
|
|
analyse(thearray, side, result);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
for (int x = 1; x < 14; x++)
|
|
|
{
|
|
|
int judge = 0;
|
|
|
for (int k = 0; k < 19; k++)
|
|
|
thearray[k] = -1;
|
|
|
for (int y = 0; y <= 18 - x; y++)
|
|
|
{
|
|
|
if (g==x+y&&h==y)
|
|
|
{
|
|
|
judge = 1;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (judge == 1)
|
|
|
{
|
|
|
for (int y = 0; y <= 18 - x; y++)
|
|
|
thearray[y] = board[x + y][y];
|
|
|
analyse(thearray, side, result);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
void analyse_oblique2(int board[19][19], int*result, int side,int g,int h)//" / "
|
|
|
{
|
|
|
int thearray[19];
|
|
|
for (int x = 5; x < 19; x++)
|
|
|
{
|
|
|
int judge = 0;
|
|
|
for (int k = 0; k < 19; k++)
|
|
|
thearray[k] = -1;
|
|
|
for (int y = 0; y <= x; y++)
|
|
|
{
|
|
|
if (g==y&&h==x-y)
|
|
|
{
|
|
|
judge = 1;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (judge == 1)
|
|
|
{
|
|
|
for (int y = 0; y <= x; y++)
|
|
|
thearray[y] = board[y][x - y];
|
|
|
analyse(thearray, side, result);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
for (int x = 1; x < 14; x++)
|
|
|
{
|
|
|
int judge = 0;
|
|
|
for (int k = 0; k < 19; k++)
|
|
|
thearray[k] = -1;
|
|
|
for (int y = 0; y <= 18 - x; y++)
|
|
|
{
|
|
|
if (g==x+y&&h==18-y)
|
|
|
{
|
|
|
judge = 1;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (judge == 1)
|
|
|
{
|
|
|
for (int y = 0; y <= 18 - x; y++)
|
|
|
thearray[y] = board[x + y][18 - y];
|
|
|
analyse(thearray, side, result);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void analyse(int thearray[19], int side, int *result)
|
|
|
{
|
|
|
//1&&2：六连，长连
|
|
|
int judge_continuous = 0;//用于判断多少个同类棋子连续
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
if (thearray[i] == side)
|
|
|
{
|
|
|
judge_continuous += 1;
|
|
|
if (judge_continuous == 6)
|
|
|
{
|
|
|
result[0] += 1;
|
|
|
for (int j = 0; j < 6; j++)
|
|
|
thearray[i - j] = 1 - side;
|
|
|
}
|
|
|
if (judge_continuous > 6 && ((i < 18 && thearray[i + 1] != side) || i == 18))
|
|
|
{
|
|
|
result[1] += 1;
|
|
|
for (int j = 0; j < judge_continuous; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
judge_continuous = 0;
|
|
|
}
|
|
|
|
|
|
//3：活5
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
if (i > 5 && judge_continuous == 5)
|
|
|
{
|
|
|
if (thearray[i] == EMPTY && thearray[i - 6] == EMPTY)//两头为空
|
|
|
{
|
|
|
result[2] += 1;
|
|
|
for (int j = 1; j < 6; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (thearray[i] == side)
|
|
|
judge_continuous += 1;
|
|
|
else
|
|
|
judge_continuous = 0;
|
|
|
}
|
|
|
//4：眠5②：__OO__OOO__
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
int recover_i = i;
|
|
|
int judgeempty = 0;
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
{
|
|
|
if (thearray[i] == EMPTY)
|
|
|
judgeempty += 1;
|
|
|
i += 1;
|
|
|
judge_continuous += 1;
|
|
|
if (i > 14)
|
|
|
break;
|
|
|
int tempi = i + 5;
|
|
|
for (i; i < tempi; i++)
|
|
|
{
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
{
|
|
|
judge_continuous += 1;
|
|
|
if (thearray[i] == EMPTY)
|
|
|
judgeempty += 1;
|
|
|
}
|
|
|
else if (thearray[i] == -1)
|
|
|
{
|
|
|
while (i < 18 && thearray[i + 1] != -1)
|
|
|
i += 1;
|
|
|
judge_continuous = 0;
|
|
|
goto here4;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
i = recover_i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (judge_continuous == 6 && judgeempty == 1)
|
|
|
{
|
|
|
result[3] += 1;
|
|
|
for (int j = 1; j < 7; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
judge_continuous = 0;
|
|
|
i = recover_i;
|
|
|
}
|
|
|
here4: i = i;
|
|
|
}
|
|
|
//5：死5
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
int recover_i = i;
|
|
|
int judgeempty = 0;
|
|
|
if (thearray[i] == 1 - side)
|
|
|
{
|
|
|
i += 1;
|
|
|
if (i > 14)
|
|
|
break;
|
|
|
int tempi = i + 5;
|
|
|
for (i; i < tempi; i++)
|
|
|
{
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
judge_continuous += 1;
|
|
|
else if (thearray[i] == -1)
|
|
|
{
|
|
|
while (i < 18 && thearray[i + 1] != -1)
|
|
|
i += 1;
|
|
|
judge_continuous = 0;
|
|
|
goto here5;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
i = recover_i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (i < 19 && judge_continuous == 5 && thearray[i] == 1 - side)
|
|
|
{
|
|
|
result[4] += 1;
|
|
|
for (int j = 1; j < 6; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
judge_continuous = 0;
|
|
|
i = recover_i;
|
|
|
}
|
|
|
here5:i = i;
|
|
|
}
|
|
|
//6：活4
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
if (i > 4 && judge_continuous == 4)
|
|
|
{
|
|
|
if (thearray[i] == EMPTY && thearray[i - 5] == EMPTY)//两头为空
|
|
|
{
|
|
|
result[5] += 1;//不需要跳出，因为可以同时存在两个活4，接下来继续判断
|
|
|
for (int j = 1; j < 5; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (thearray[i] == side)
|
|
|
judge_continuous += 1;
|
|
|
else
|
|
|
judge_continuous = 0;
|
|
|
}
|
|
|
//7：眠4：__OO____OO__类似
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
|
|
|
int recover_i = i;
|
|
|
int judgeempty = 0;
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
{
|
|
|
if (thearray[i] == EMPTY)
|
|
|
judgeempty += 1;
|
|
|
i += 1;
|
|
|
judge_continuous += 1;
|
|
|
if (i > 14)
|
|
|
break;
|
|
|
int tempi = i + 5;
|
|
|
for (i; i < tempi; i++)
|
|
|
{
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
{
|
|
|
judge_continuous += 1;
|
|
|
if (thearray[i] == EMPTY)
|
|
|
judgeempty += 1;
|
|
|
}
|
|
|
else if (thearray[i] == -1)
|
|
|
{
|
|
|
while (i < 18 && thearray[i + 1] != -1)
|
|
|
i += 1;
|
|
|
judge_continuous = 0;
|
|
|
goto here7;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
i = recover_i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (judge_continuous == 6 && judgeempty == 2)
|
|
|
{
|
|
|
result[6] += 1;
|
|
|
for (int j = 1; j < 7; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
judge_continuous = 0;
|
|
|
i = recover_i;
|
|
|
}
|
|
|
here7:i = i;
|
|
|
}
|
|
|
//8：死4
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
int recover_i = i;
|
|
|
int judgeempty = 0;
|
|
|
if (thearray[i] == 1 - side)
|
|
|
{
|
|
|
i += 1;
|
|
|
if (i > 14)
|
|
|
break;
|
|
|
int tempi = i + 4;
|
|
|
for (i; i < tempi; i++)
|
|
|
{
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
judge_continuous += 1;
|
|
|
else if (thearray[i] == -1)
|
|
|
{
|
|
|
while (i < 18 && thearray[i + 1] != -1)
|
|
|
i += 1;
|
|
|
judge_continuous = 0;
|
|
|
goto here8;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
i = recover_i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (i < 19 && judge_continuous == 4 && thearray[i] == 1 - side)
|
|
|
{
|
|
|
result[7] += 1;
|
|
|
for (int j = 1; j < 5; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
judge_continuous = 0;
|
|
|
i = recover_i;
|
|
|
}
|
|
|
here8:i = i;
|
|
|
}
|
|
|
//9：活3
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
if (i > 3 && judge_continuous == 3)
|
|
|
{
|
|
|
if (thearray[i] == EMPTY && thearray[i - 4] == EMPTY)//两头为空
|
|
|
{
|
|
|
result[8] += 1;//不需要跳出，因为可以同时存在两个活3，接下来继续判断
|
|
|
for (int j = 1; j < 4; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (thearray[i] == side)
|
|
|
judge_continuous += 1;
|
|
|
else
|
|
|
judge_continuous = 0;
|
|
|
}
|
|
|
//10：朦胧3：__O__O__O__ __OO____O__
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
int recover_i = i;
|
|
|
int judgeempty = 0;
|
|
|
if (thearray[i] == EMPTY)
|
|
|
{
|
|
|
i += 1;
|
|
|
if (i > 13)
|
|
|
break;
|
|
|
int tempi = i + 5;
|
|
|
for (i; i < tempi; i++)
|
|
|
{
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
{
|
|
|
judge_continuous += 1;
|
|
|
if (thearray[i] == EMPTY)
|
|
|
judgeempty += 1;
|
|
|
}
|
|
|
else if (thearray[i] == -1)
|
|
|
{
|
|
|
while (i < 18 && thearray[i + 1] != -1)
|
|
|
i += 1;
|
|
|
judge_continuous = 0;
|
|
|
goto here10;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
i = recover_i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (judge_continuous == 5 && judgeempty == 2 && thearray[i] == EMPTY)
|
|
|
{
|
|
|
result[9] += 1;
|
|
|
for (int j = 1; j < 6; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
judge_continuous = 0;
|
|
|
i = recover_i;
|
|
|
}
|
|
|
here10:i = i;
|
|
|
}
|
|
|
//11：眠3：__O__OO__
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
int recover_i = i;
|
|
|
int judgeempty = 0;
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
{
|
|
|
if (thearray[i] == EMPTY)
|
|
|
judgeempty += 1;
|
|
|
i += 1;
|
|
|
judge_continuous += 1;
|
|
|
if (i > 14)
|
|
|
break;
|
|
|
int tempi = i + 5;
|
|
|
for (i; i < tempi; i++)
|
|
|
{
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
{
|
|
|
judge_continuous += 1;
|
|
|
if (thearray[i] == EMPTY)
|
|
|
judgeempty += 1;
|
|
|
}
|
|
|
else if (thearray[i] == -1)
|
|
|
{
|
|
|
while (i < 18 && thearray[i + 1] != -1)
|
|
|
i += 1;
|
|
|
judge_continuous = 0;
|
|
|
goto here11;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
i = recover_i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (judge_continuous == 6 && judgeempty == 3)
|
|
|
{
|
|
|
result[10] += 1;
|
|
|
for (int j = 1; j < 7; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
judge_continuous = 0;
|
|
|
i = recover_i;
|
|
|
}
|
|
|
here11:i = i;
|
|
|
}
|
|
|
//12：死3
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
int recover_i = i;
|
|
|
int judgeempty = 0;
|
|
|
if (thearray[i] == 1 - side)
|
|
|
{
|
|
|
i += 1;
|
|
|
if (i > 15)
|
|
|
break;
|
|
|
int tempi = i + 3;
|
|
|
for (i; i < tempi; i++)
|
|
|
{
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
judge_continuous += 1;
|
|
|
else if (thearray[i] == -1)
|
|
|
{
|
|
|
while (i < 18 && thearray[i + 1] != -1)
|
|
|
i += 1;
|
|
|
judge_continuous = 0;
|
|
|
goto here12;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
i = recover_i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (i < 19 && judge_continuous == 3 && thearray[i] == 1 - side)
|
|
|
{
|
|
|
result[11] += 1;
|
|
|
for (int j = 1; j < 4; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
judge_continuous = 0;
|
|
|
i = recover_i;
|
|
|
}
|
|
|
here12:i = i;
|
|
|
}
|
|
|
//13：活2：__OO__
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
if (i > 2 && judge_continuous == 2)
|
|
|
{
|
|
|
if (thearray[i] == EMPTY && thearray[i - 3] == EMPTY)//两头为空
|
|
|
{
|
|
|
result[12] += 1;//不需要跳出，因为可以同时存在两个活3，接下来继续判断
|
|
|
for (int j = 1; j < 3; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (thearray[i] == side)
|
|
|
judge_continuous += 1;
|
|
|
else
|
|
|
judge_continuous = 0;
|
|
|
}
|
|
|
//14：眠2：六个非X其中两个O
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
int recover_i = i;
|
|
|
int judgeempty = 0;
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
{
|
|
|
if (thearray[i] == EMPTY)
|
|
|
judgeempty += 1;
|
|
|
i += 1;
|
|
|
judge_continuous += 1;
|
|
|
if (i > 14)
|
|
|
break;
|
|
|
int tempi = i + 5;
|
|
|
for (i; i < tempi; i++)
|
|
|
{
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
{
|
|
|
judge_continuous += 1;
|
|
|
if (thearray[i] == EMPTY)
|
|
|
judgeempty += 1;
|
|
|
}
|
|
|
else if (thearray[i] == -1)
|
|
|
{
|
|
|
while (i < 18 && thearray[i + 1] != -1)
|
|
|
i += 1;
|
|
|
judge_continuous = 0;
|
|
|
goto here14;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
i = recover_i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (judge_continuous == 6 && judgeempty == 4)
|
|
|
{
|
|
|
result[13] += 1;
|
|
|
for (int j = 1; j < 7; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
judge_continuous = 0;
|
|
|
i = recover_i;
|
|
|
}
|
|
|
here14:i = i;
|
|
|
}
|
|
|
//15：死2
|
|
|
judge_continuous = 0;//判断值归零
|
|
|
for (int i = 0; i < 19; i++)
|
|
|
{
|
|
|
int recover_i = i;
|
|
|
int judgeempty = 0;
|
|
|
if (thearray[i] == 1 - side)
|
|
|
{
|
|
|
i += 1;
|
|
|
if (i > 16)
|
|
|
break;
|
|
|
int tempi = i + 2;
|
|
|
for (i; i < tempi; i++)
|
|
|
{
|
|
|
if (thearray[i] == side || thearray[i] == EMPTY)
|
|
|
judge_continuous += 1;
|
|
|
else if (thearray[i] == -1)
|
|
|
{
|
|
|
while (i < 18 && thearray[i + 1] != -1)
|
|
|
i += 1;
|
|
|
judge_continuous = 0;
|
|
|
goto here15;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
i = recover_i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (i < 19 && judge_continuous == 2 && thearray[i] == 1 - side)
|
|
|
{
|
|
|
result[14] += 1;
|
|
|
for (int j = 1; j < 3; j++)
|
|
|
{
|
|
|
if (thearray[i - j] == side)
|
|
|
thearray[i - j] = -1;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
judge_continuous = 0;
|
|
|
i = recover_i;
|
|
|
}
|
|
|
here15:i = i;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int* analyse1(int board[19][19], int side,int g,int h)//x,y为当前棋子位置
|
|
|
{
|
|
|
int *result = new int[15];//15种棋型
|
|
|
for (int i = 0; i < 15; i++)
|
|
|
result[i] = 0;
|
|
|
analyse_horizontal(board, result, side,g,h);
|
|
|
analyse_vertical(board, result, side,g,h);
|
|
|
analyse_oblique1(board, result, side,g,h);
|
|
|
analyse_oblique2(board, result, side,g,h);
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
point* AI(int board[19][19], int side) {
|
|
|
int i, j, k;
|
|
|
int marks[361] = { 0 };//i*19+j 所有点的分值
|
|
|
int temp_max_mark = 0;
|
|
|
int temp_max_j = 0;
|
|
|
point *max = new point[360];//分值最高的15个点
|
|
|
int enemy_side;
|
|
|
int temp_board[19][19];
|
|
|
|
|
|
if (side == BLACK)enemy_side = WHITE;
|
|
|
else enemy_side = BLACK;
|
|
|
|
|
|
for (i = 0; i < 360; i++) {
|
|
|
max[i].x = 0;
|
|
|
max[i].y = 0;
|
|
|
max[i].mark = -1;
|
|
|
}
|
|
|
int maxcount = 0;
|
|
|
for (i = 0; i < 19; i++) {
|
|
|
for (j = 0; j < 19; j++) {
|
|
|
if (board[i][j] == EMPTY && surround(board, i, j, side)) { //只考虑棋盘的空位
|
|
|
{
|
|
|
int boardtemp[19][19];
|
|
|
copy(board, boardtemp);
|
|
|
int mark_enemy1 = markenemy(analyse1(boardtemp, enemy_side,i,j));
|
|
|
boardtemp[i][j] = side;
|
|
|
int mark_self = markslef(analyse1(boardtemp, side,i,j));
|
|
|
boardtemp[i][j] = enemy_side;
|
|
|
int mark_enemy2 = markenemy(analyse1(boardtemp, enemy_side,i,j));
|
|
|
max[maxcount].mark = mark_self + mark_enemy2 - mark_enemy1;
|
|
|
max[maxcount].x = i;
|
|
|
max[maxcount].y = j;
|
|
|
maxcount += 1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
return max;
|
|
|
}
|
|
|
|
|
|
//决策树：
|
|
|
int* AItree(int board[19][19], int side, point* max)
|
|
|
{
|
|
|
int *result = new int[4];
|
|
|
int enemy_side = 1 - side;
|
|
|
point *maxtree = new point[360];//找到分数和最大的15个点
|
|
|
for (int i = 0; i < 360; i++)
|
|
|
maxtree[i].mark = maxtree[i].x = maxtree[i].y = -1;//赋初值0
|
|
|
for (int i = 0; i < 360; i++)
|
|
|
{
|
|
|
int chessboard_tree[19][19] = { 0 };
|
|
|
copy(board, chessboard_tree);
|
|
|
if (max[i].mark >= 0)
|
|
|
chessboard_tree[max[i].x][max[i].y] = side;
|
|
|
else
|
|
|
break;
|
|
|
int marks[361] = { 0 };
|
|
|
for (int z = 0; z < 361; z++)
|
|
|
marks[z] = -1;
|
|
|
for (int k = 0; k < 19; k++) {
|
|
|
for (int l = 0; l < 19; l++) {
|
|
|
if (chessboard_tree[k][l] == EMPTY && surround(chessboard_tree, k, l, side)) { //只考虑棋盘的空位
|
|
|
int boardtemp[19][19];
|
|
|
copy(chessboard_tree, boardtemp);
|
|
|
int mark_enemy1 = markenemy(analyse1(boardtemp, enemy_side,k,l));
|
|
|
boardtemp[k][l] = side;
|
|
|
int mark_self = markslef(analyse1(boardtemp, side,k,l));
|
|
|
boardtemp[k][l] = enemy_side;
|
|
|
int mark_enemy2 = markenemy(analyse1(boardtemp, enemy_side,k,l));
|
|
|
marks[k * 19 + l] = mark_self + mark_enemy2 - mark_enemy1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
point tempmax;
|
|
|
tempmax.mark = tempmax.x = tempmax.y = 0;
|
|
|
int aitree_temp_max = -1;
|
|
|
for (int k = 0; k < 361; k++)//找到分数最大的点
|
|
|
{
|
|
|
if (marks[k]>=0&&marks[k] > aitree_temp_max)
|
|
|
{
|
|
|
aitree_temp_max = marks[k];
|
|
|
tempmax.x = k / 19;
|
|
|
tempmax.y = k % 19;
|
|
|
tempmax.mark = marks[k];
|
|
|
}
|
|
|
}
|
|
|
maxtree[i].x = tempmax.x;
|
|
|
maxtree[i].y = tempmax.y;
|
|
|
maxtree[i].mark = tempmax.mark;
|
|
|
}
|
|
|
int aitree_temp_max = -1;
|
|
|
for (int i = 0; i < 360; i++)//找到最大的分数和的两步棋的坐标
|
|
|
{
|
|
|
if (max[i].mark >= 0&&maxtree[i].mark>=0)
|
|
|
{
|
|
|
if (max[i].mark + maxtree[i].mark > aitree_temp_max)
|
|
|
{
|
|
|
result[0] = max[i].x;
|
|
|
result[1] = max[i].y;
|
|
|
result[2] = maxtree[i].x;
|
|
|
result[3] = maxtree[i].y;
|
|
|
aitree_temp_max = max[i].mark + maxtree[i].mark;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
break;
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
int markslef(int* result) { //根据result内的各属性打分(自己)
|
|
|
/*1.六连:100000
|
|
|
2.长连:100000
|
|
|
3.活5：128
|
|
|
4.眠5：31
|
|
|
5.死5:0
|
|
|
6.活4:1024
|
|
|
7:眠4:512
|
|
|
8死4:0
|
|
|
9.活3:256
|
|
|
10.朦胧3：32
|
|
|
11.眠3：32
|
|
|
12.死3：0
|
|
|
13.活2：16
|
|
|
14.眠2：3
|
|
|
15.死2: 0
|
|
|
*/
|
|
|
int sum = 0;
|
|
|
sum += result[0] * 100000;
|
|
|
sum += result[1] * 100000;
|
|
|
sum += result[2] * 128;
|
|
|
sum += result[3] * 31;
|
|
|
sum += result[4] * 0;
|
|
|
sum += result[5] * 1024;
|
|
|
sum += result[6] * 512;
|
|
|
sum += result[7] * 0;
|
|
|
sum += result[8] * 256;
|
|
|
sum += result[9] * 32;
|
|
|
sum += result[10] * 31;
|
|
|
sum += result[11] * 0;
|
|
|
sum += result[12] * 16;
|
|
|
sum += result[13] * 3;
|
|
|
sum += result[14] * 0;
|
|
|
return sum;
|
|
|
}
|
|
|
|
|
|
int markenemy(int *result) { //根据result内的各属性打分（堵人）
|
|
|
/*1.六连:30000
|
|
|
2.长连:30000
|
|
|
3.活5：15000
|
|
|
4.眠5：12000
|
|
|
5.死5:0
|
|
|
6.活4:3000
|
|
|
7:眠4:2000
|
|
|
8死4:0
|
|
|
9.活3:256
|
|
|
10.朦胧3：32
|
|
|
11.眠3：32
|
|
|
12.死3：0
|
|
|
13.活2：16
|
|
|
14.眠2：3
|
|
|
15.死2: 0
|
|
|
*/
|
|
|
int sum = 0;
|
|
|
sum += result[0] * 30000;
|
|
|
sum += result[1] * 30000;
|
|
|
sum += result[2] * 15000;
|
|
|
sum += result[3] * 12000;
|
|
|
sum += result[4] * 0;
|
|
|
sum += result[5] * 3000;
|
|
|
sum += result[6] * 2000;
|
|
|
sum += result[7] * 0;
|
|
|
sum += result[8] * 256;
|
|
|
sum += result[9] * 32;
|
|
|
sum += result[10] * 31;
|
|
|
sum += result[11] * 0;
|
|
|
sum += result[12] * 16;
|
|
|
sum += result[13] * 3;
|
|
|
sum += result[14] * 0;
|
|
|
return sum;
|
|
|
}
|
|
|
|
|
|
|
|
|
void copy(int board1[19][19], int board2[19][19]) {
|
|
|
int i, j;
|
|
|
for (i = 0; i < 19; i++) {
|
|
|
for (j = 0; j < 19; j++) {
|
|
|
board2[i][j] = board1[i][j];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int main()
|
|
|
{
|
|
|
Step step;//临时步结构
|
|
|
char message[256];//通信消息缓冲
|
|
|
int computerSide;//己方执棋颜色
|
|
|
int start = 0;//对局开始标记
|
|
|
srand(int(time(0)));
|
|
|
//此处放置初始化代码
|
|
|
//...
|
|
|
|
|
|
while (1) //程序主循环
|
|
|
{
|
|
|
fflush(stdout);//不要删除此语句，否则程序会出问题
|
|
|
scanf("%s", message);//获取平台命令消息
|
|
|
//分析命令
|
|
|
if (strcmp(message, "name?") == 0)//向对战平台发送队名
|
|
|
{
|
|
|
fflush(stdin);
|
|
|
/***********将"令狐冲"改为你的队名，不超过6个汉字或12个英文字母，否则无成绩************/
|
|
|
/*******/ printf("name gkd\n"); /**只修改令狐冲，不要删除name空格****/
|
|
|
/***********将"令狐冲"改为你的队名，不超过6个汉字或12个英文字母，否则无成绩************/
|
|
|
}
|
|
|
else if (strcmp(message, "new") == 0)//建立新棋局
|
|
|
{
|
|
|
int i, j;
|
|
|
scanf("%s", message);//获取己方执棋颜色
|
|
|
fflush(stdin);
|
|
|
if (strcmp(message, "black") == 0) computerSide = BLACK; //执黑
|
|
|
else computerSide = WHITE; //执白
|
|
|
|
|
|
for (i = 0; i < 19; ++i) //初始化棋局
|
|
|
for (j = 0; j < 19; ++j)
|
|
|
Board[i][j] = EMPTY;
|
|
|
start = 1;
|
|
|
|
|
|
if (computerSide == BLACK)
|
|
|
{
|
|
|
/**********生成第一手着法，并保存在step结构中，落子坐标为(step.first.x,step.first.y)**********/
|
|
|
/****************************在下方填充代码，并替换我的示例代码******************************/
|
|
|
|
|
|
//此处保留老师的代码
|
|
|
step.first.x = 9;
|
|
|
step.first.y = 9;
|
|
|
|
|
|
|
|
|
/******************************在上面填充第一步行棋代码*******************************************/
|
|
|
|
|
|
Board[step.first.x][step.first.y] = computerSide;//处理己方行棋
|
|
|
//printf("move %c%c@@\n", step.first.x + 'A', step.first.y + 'A');//输出着法
|
|
|
printf("move %c%c\n", step.first.x + 'A', step.first.y + 'A');//输出着法
|
|
|
}
|
|
|
}
|
|
|
else if (strcmp(message, "move") == 0)//行棋,本程序核心
|
|
|
{
|
|
|
scanf("%s", message);//获取对手行棋着法
|
|
|
fflush(stdin);
|
|
|
int len = strlen(message);
|
|
|
|
|
|
step.first.x = message[0] - 'A'; step.first.y = message[1] - 'A';
|
|
|
if (len == 4)
|
|
|
{
|
|
|
step.second.x = message[2] - 'A'; step.second.y = message[3] - 'A';
|
|
|
}
|
|
|
//处理对手行棋
|
|
|
Board[step.first.x][step.first.y] = 1 - computerSide;
|
|
|
//if(!(step.second.x==-1 && step.second.y==-1)) Board[step.second.x][step.second.y] = 1 - computerSide;
|
|
|
if (len == 4) Board[step.second.x][step.second.y] = 1 - computerSide;
|
|
|
/**********************************************************************************************************/
|
|
|
/***生成落子的坐标，保存在step结构中，第一子下在(step.first.x,step.first.y)，第一子下在(step.first.x,step.first.y)***/
|
|
|
/**************************************在下方填充代码，并替换我的示例代码*****************************************/
|
|
|
|
|
|
int next_x;
|
|
|
int next_y;
|
|
|
int side = computerSide;
|
|
|
int * temp;
|
|
|
temp = new int[4];
|
|
|
|
|
|
//生成第1子落子位置step.first.x和step.first.y
|
|
|
temp = AItree(Board, side, AI(Board, side));
|
|
|
step.first.x = temp[0];
|
|
|
step.first.y = temp[1];
|
|
|
step.second.x = temp[2];
|
|
|
step.second.y = temp[3];
|
|
|
|
|
|
Board[step.first.x][step.first.y] = computerSide;
|
|
|
|
|
|
//生成第2子落子位置step.second.x和step.second.y
|
|
|
|
|
|
|
|
|
Board[step.second.x][step.second.y] = computerSide;
|
|
|
|
|
|
|
|
|
/*****************************************在上面填充代码******************************************************/
|
|
|
/**********************************************************************************************************/
|
|
|
|
|
|
printf("move %c%c%c%c\n", step.first.x + 'A', step.first.y + 'A', step.second.x + 'A', step.second.y + 'A');//输出着法
|
|
|
}
|
|
|
else if (strcmp(message, "error") == 0)//着法错误
|
|
|
{
|
|
|
fflush(stdin);
|
|
|
}
|
|
|
else if (strcmp(message, "end") == 0)//对局结束
|
|
|
{
|
|
|
fflush(stdin);
|
|
|
start = 0;
|
|
|
}
|
|
|
else if (strcmp(message, "quit") == 0)//退出引擎
|
|
|
{
|
|
|
fflush(stdin);
|
|
|
printf("Quit!\n");
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
