五子棋 0.0.cpp

#include<iostream>
#include<stdio.h>
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
using namespace std;
int map[15][15] = { 0 }; //用0表示空位，1表示Al，2表示玩家
int flag[5][15][15] = { 0 };//定义一个标记的三维数组，用以记录全部的子叶被遍历过，第一个为层数
//int cord[15][15] = { 0 };//定义每一层的flag,便于删除

int flag1 = 0;
int x_pos[10], y_pos[10];//记录每一步的位置之后返回前删子
int sum = 0;
int sm[15][15] = { -10000 };//记录每一步的最终分数
int x_now = 7, y_now = 7;

int calcular(int flag, int record)//打分函数
{
	int m = 0;
	if (flag == 0)
	{
		if (record == 1)
		{
			m = 10;
			return m;
		}
		if (record == 2)
		{
			m = 100;
			return m;
		}
		if (record == 3)
		{
			m = 1000;
			return m;
		}
		if (record == 4)
		{
			m = 10000;
			return m;
		}
		if (record == 5)
		{
			m = 100000;
			return m;
		}
		else
			return m;
	}
	if (flag == 1)
	{

		if (record == 2)
		{
			m = 10;
			return m;
		}
		if (record == 3)
		{
			m = 100;
			return m;
		}
		if (record == 4)
		{
			m = 1000;
			return m;
		}
		if (record == 5)
		{
			m = 100000;
			return m;
		}
		else
			return m;
	}
	if (flag == 2)
	{
		if (record == 3)
		{
			m = 50;
			return m;
		}
		if (record == 4)
		{
			m = 500;
			return m;
		}
		if (record == 5)
		{
			m = 100000;
			return m;
		}
		else
			return m;
	}
}

int crossing()//对所在行判断
{
	int sum_crossing = 0;
	for (int i = 0; i < 15; i++)//每一列
	{
		for (int j = 0; j < 15; j++)//每一行
		{
			if (map[i][j] != 0)//以一个棋子为中心发散判断，遇到空或其他颜色的棋子跳出
			{
				int colour = map[i][j];
				int m, n;
				int x;
				while (1)//横向判断
				{
					m = i;
					n = j;
					int record = 1;//记录同颜色的棋子数
					int flag = 0;//如果值为0则两边全为空，如果值为1有一边有子，为2两边有子
					while (1)
					{
						m++;
						if (m > 14)//边界值判断
						{
							flag++;
							break;
						}
						else
						{
							if (map[m][n] == colour)
							{
								record++;
							}
							else if (map[m][n] == 3 - colour)
							{
								flag++;
								break;
							}
							else if (map[m][n] == 0)
							{
								break;
							}
						}
					}
					m = i;
					n = j;
					while (1)
					{
						m--;
						if (m < 0)//边界值判断
						{
							flag++;
							break;
						}
						else
						{
							if (map[m][n] == colour)
							{
								record++;
							}
							else if (map[m][n] == 3 - colour)
							{
								flag++;
								break;
							}
							else if (map[m][n] == 0)
							{
								break;
							}

						}
					}

					x = calcular(flag, record);
					break;
				}
				if (map[i][j] == 1)	sum_crossing = sum_crossing + x;
				else if (map[i][j] == 2)sum_crossing = sum_crossing - x;
			}
		}

	}
	return sum_crossing;
}

int lengthways()//对所在列判断
{
	int sum_lenthways = 0;
	for (int i = 0; i < 15; i++)//每一列
	{
		for (int j = 0; j < 15; j++)//每一行
		{
			if (map[i][j] != 0)//以一个棋子为中心发散判断，遇到空或其他颜色的棋子跳出
			{
				int colour = map[i][j];
				int m, n;
				int x;
				while (1)//纵向判断
				{
					m = i;
					n = j;
					int record = 1;//记录同颜色的棋子数
					int flag = 0;//如果值为0则两边全为空，如果值为1有一边有子，为2两边有子
					while (1)
					{
						n++;
						if (n > 14)//边界值判断
						{
							flag++;
							break;
						}
						else
						{
							if (map[m][n] == colour)
							{
								record++;
							}
							else if (map[m][n] == 3 - colour)
							{
								flag++;
								break;
							}
							else if (map[m][n] == 0)
							{
								break;
							}
						}
					}
					m = i;
					n = j;
					while (1)
					{
						n--;
						if (n < 0)//边界值判断
						{
							flag++;
							break;
						}
						else
						{
							if (map[m][n] == colour)
							{
								record++;
							}
							else if (map[m][n] == 3 - colour)
							{
								flag++;
								break;
							}
							else if (map[m][n] == 0)
							{
								break;
							}

						}
					}

					x = calcular(flag, record);
					break;
				}
				if (map[i][j] == 1)sum_lenthways = sum_lenthways + x;
				else if (map[i][j] == 2)sum_lenthways = sum_lenthways - x;
			}
		}

	}
	return sum_lenthways;
}

int leftline()//对所在列判断
{
	int sum_leftline = 0;
	for (int i = 0; i < 15; i++)//每一列
	{
		for (int j = 0; j < 15; j++)//每一行
		{
			if (map[i][j] != 0)//以一个棋子为中心发散判断，遇到空或其他颜色的棋子跳出
			{
				int colour = map[i][j];
				int m, n;
				int x;
				while (1)//纵向判断
				{
					m = i;
					n = j;
					int record = 1;//记录同颜色的棋子数
					int flag = 0;//如果值为0则两边全为空，如果值为1有一边有子，为2两边有子
					while (1)
					{
						n++;
						m++;
						if (n > 14 || m > 14)//边界值判断
						{
							flag++;
							break;
						}
						else
						{
							if (map[m][n] == colour)
							{
								record++;
							}
							else if (map[m][n] == 3 - colour)
							{
								flag++;
								break;
							}
							else if (map[m][n] == 0)
							{
								break;
							}
						}
					}
					m = i;
					n = j;
					while (1)
					{
						n--;
						m--;
						if (n < 0 || m < 0)//边界值判断
						{
							flag++;
							break;
						}
						else
						{
							if (map[m][n] == colour)
							{
								record++;
							}
							else if (map[m][n] == 3 - colour)
							{
								flag++;
								break;
							}
							else if (map[m][n] == 0)
							{
								break;
							}

						}
					}

					x = calcular(flag, record);
					break;
				}
				if (map[i][j] == 1)sum_leftline = sum_leftline + x;
				else if (map[i][j] == 2)sum_leftline = sum_leftline - x;
			}
		}
	}
	return sum_leftline;
}
int rightline()//对所在列判断
{
	int sum_rightline = 0;
	for (int i = 0; i < 15; i++)//每一列
	{
		for (int j = 0; j < 15; j++)//每一行
		{
			if (map[i][j] != 0)//以一个棋子为中心发散判断，遇到空或其他颜色的棋子跳出
			{
				int colour = map[i][j];
				int m, n;
				int x;
				while (1)//纵向判断
				{
					m = i;
					n = j;
					int record = 1;//记录同颜色的棋子数
					int flag = 0;//如果值为0则两边全为空，如果值为1有一边有子，为2两边有子
					while (1)
					{
						m++;
						n--;
						if (m > 14 || n < 0)//边界值判断
						{
							flag++;
							break;
						}
						else
						{
							if (map[m][n] == colour)
							{
								record++;
							}
							else if (map[m][n] == 3 - colour)
							{
								flag++;
								break;
							}
							else if (map[m][n] == 0)
							{
								break;
							}
						}
					}
					m = i;
					n = j;
					while (1)
					{
						m--;
						n++;
						if (m < 0 || n>0)//边界值判断
						{
							flag++;
							break;
						}
						else
						{
							if (map[m][n] == colour)
							{
								record++;
							}
							else if (map[m][n] == 3 - colour)
							{
								flag++;
								break;
							}
							else if (map[m][n] == 0)
							{
								break;
							}

						}
					}

					x = calcular(flag, record);
					break;
				}
				if (map[i][j] == 1)sum_rightline = sum_rightline + x;
				else if (map[i][j] == 2)sum_rightline = sum_rightline - x;
			}
		}

	}
	return sum_rightline;
}




int tree(int x, int depth)
{
	depth++;
	int sum1 = -10000000, sum2 = 10000000;
	for (int i = 0; i < 15; i++)
	{
		for (int j = 0; j < 15; j++)
		{
			if (map[i][j] != 0)
				flag[depth][i][j] = 1;
		}
	}
	int c = 0;
	for (int i = 0; i < 15; i++)
	{
		for (int j = 0; j < 15; j++)
		{

			if (flag[depth][i][j] == 0)
			{
				map[i][j] = x;
				c = 1;
				x_pos[depth] = i;
				y_pos[depth] = j;
				break;
			}

		}
		if (c == 1)
			break;
	}
	c = 0;
	for (int i = 0; i < 15; i++)
	{
		for (int j = 0; j < 15; j++)
		{
			if (map[i][j] != 0)
				flag[depth][i][j] = 1;
		}
	}
	while (1)
	{
		flag1 = 0;//记录是否全局的flag[][]都为1
		if (depth == 1)
		{
			sum = 0;
			sum = sum + crossing();
			sum = sum + lengthways();
			sum = sum + leftline();
			sum = sum + rightline();
			map[x_pos[depth]][y_pos[depth]] = 0;
			return sum;
		}
		sum = tree(3 - x, depth);
		for (int i = 0; i < 15; i++)
		{
			for (int j = 0; j < 15; j++)
			{
				if (flag[depth + 1][i][j] == 0)
				{
					flag1 = 1;//如果存在某个位置flag不为0
				}
			}
		}
		if (x == 1)
		{
			sum1 = max(sum, sum1);
		}
		else if (x == 2)
		{
			sum2 = min(sum, sum2);
		}
		if (flag1 == 0 && depth != 1)
		{

			flag1 = 1;
			map[x_pos[depth]][y_pos[depth]] = 0;
			if (x == 1)
			{
				return sum1;
			}
			else if (x == 2)
			{
				return sum2;
			}
		}
		else if (flag1 == 0 && depth == 1)
		{
			map[x_pos[depth]][y_pos[depth]] = 0;
			sm[x_pos[1]][y_pos[1]] = sum1;
			return sm[x_pos[1]][y_pos[1]];
		}

	}
}
void traverse()//先复制棋盘，再下棋进行遍历。遍历树，打算先深搜四层，先不写剪枝//可以不复制棋盘，只需要每一步评分之后删去棋子
{

	int t = -1000;
	while (1)
	{
		flag1 = 0;
		sum = tree(1, 0);
		if (t < sum)
		{
			x_now = x_pos[1];
			y_now = y_pos[1];
		}
		t = max(t, sum);
		for (int i = 0; i < 15; i++)
		{
			for (int j = 0; j < 15; j++)
			{
				if (flag[1][i][j] == 0)
				{
					flag1 = 1;
					break;//如果存在某个位置flag不为0
				}
			}
			if (flag1 == 1)break;
		}
		if (flag1 == 0)break;//得到分数最大的位置即x_now,y_now
	}
}


void drawback()
{

	IMAGE img;
	int step = 40;
	initgraph(800, 700);
	/*loadimage(&img, L"背景.jpeg", 800, 700, 1);
	putimage(0, 0, &img);*/
	setbkcolor(GREEN);
	cleardevice();
	setlinecolor(RGB(0, 0, 0));
	for (int i = 0; i < 16; i++)
	{
		line(i * step, 1 * step, i * step, 15 * step);
		line(1 * step, i * step, 15 * step, i * step);
	}
	/*int x=40, y=40;
	while (1)
	{

		setfillcolor(BLACK);
		setcolor(BLACK);
		fillcircle(x, y, 20);
		x += 40;
		y += 40;
	}*/
}

void play()
{
	char input;
	while (1)
	{
		if (kbhit())
		{
			input = getch();
			if (input == 'a')
			{
				x_now--;
			}
			else if (input == 'd')
			{
				x_now++;
			}
			else if (input == 'w')
			{
				y_now--;
			}
			else if (input == 's')
			{
				y_now++;
			}
			else if (input == 'z')
			{
				break;
			}
		}
	}
}

void start1()//玩家选择先手
{
	play();
	setfillcolor(BLACK);
	setcolor(BLACK);
	fillcircle((x_now + 1) * 40, (y_now + 1) * 40, 20);
	map[x_now][y_now] = 2;
	x_now++;
	setfillcolor(WHITE);
	setcolor(WHITE);
	fillcircle((x_now + 1) * 40, (y_now + 1) * 40, 20);
	map[x_now][y_now] = 1;
	while (1)
	{
		play();
		setfillcolor(BLACK);
		setcolor(BLACK);
		fillcircle((x_now + 1) * 40, (y_now + 1) * 40, 20);
		map[x_now][y_now] = 2;
		traverse();
		setfillcolor(WHITE);
		setcolor(WHITE);
		fillcircle((x_now + 1) * 40, (y_now + 1) * 40, 20);
		map[x_now][y_now] = 1;
		for (int i = 0; i < 5; i++)
		{
			for (int j = 0; j < 15; j++)
			{
				for (int z = 0; z < 15; z++)
				{
					flag[i][j][z] = 0;
				}
			}
		}
		sm[15][15] = { -10000 };

	}
}

int main()
{
	int n;
	printf("请选择先手/后手：先手为黑子请输入1，后手为白子请输入2\n");
	scanf("%d", &n);
	drawback();
	if (n == 1)
	{
		start1();
	}
	/*if (n == 2)
	{

	}*/


	getch();
	closegraph();
	return 0;
}