对称黑白棋（没有文件读写，AI随机）c++

于 2020-06-22 00:07:58 发布
阅读量577 收藏 5
点赞数 3
文章标签： 其他
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45754293/article/details/106893779
版权

大一期末作业

#include<iostream>
#include<windows.h> 
#include<cstdlib> 
#include<time.h>
#include<fstream>
using namespace std;
int N;//棋盘规模大小
int sum = 0;//计数
char chess[11][11];//初始化棋盘数组,不超过10*10 
class Start//开始工作 
{
public:
	void show();//展示页面
	void work();//开始工作，包含五个模块
	void screen();//最终反馈，程序运行
	void rule();//规则
	void clear();//初始化棋盘 
	void print();//打印棋盘
	int sum_one();//统计一手数量
	int sum_two();//统计二手数量
};
class Solve//解决问题 
{
public:
	bool find(int a, int b, int k);//保证正方形内都不是为空
	bool sure(int x, int y, int k, int a, int b);//保证每一个点都是在正方形内和棋盘内
	bool xyjudge(int a, int b, int k);//XY轴对称判断
	void Judge(int a, int b);//落子查找判断
	void reverse(int a, int b, int k, int x, int y);//翻转
	void predict();//输出答案
	//小部分功能封装
	void calulate(int n);//落子赋值和判断的过程
};
class Pattern// 模式
{
public:
	void player();//人人
	void computer();//人机
	void twocomputer();//机机
};
void Start::show()//游戏页面 
{
	system("color F2");
	cout << "=======================================================================================================================" << endl << endl;
	cout << '\t' << '\t' << '\t' << '\t' << '\t' << '\t' << "对称棋" << endl << endl;
	cout << '\t' << '\t' << '\t' << '\t' << '\t' << '\t' << "1.规则" << endl << endl;
	cout << '\t' << '\t' << '\t' << '\t' << '\t' << '\t' << "2.人人对战" << endl << endl;
	cout << '\t' << '\t' << '\t' << '\t' << '\t' << '\t' << "3.人机对战" << endl << endl;
	cout << '\t' << '\t' << '\t' << '\t' << '\t' << '\t' << "4.机机对战" << endl << endl;
	cout << '\t' << '\t' << '\t' << '\t' << '\t' << '\t' << "5.退出游戏" << endl << endl;
	cout << '\t' << '\t' << '\t' << '\t' << '\t' << "   请输入你要操作的序号：";
}
void Start::work()//执行操作 
{
	Pattern pattern;
	Start start;
	int num;
	start.show();
	cin >> num;
	switch (num)
	{
	case 1:
		system("cls");
		Start::rule();
		break;
	case 2:
		system("cls");
		pattern.player();
		break;
	case 3:
		system("cls");
		pattern.computer();
		break;
	case 4:
		system("cls");
		pattern.twocomputer();
		break;
	case 5:
		exit(0);//退出游戏 
		break;
	}
	sum = 0;//重新归0 
}
void Start::screen()//最终反馈 
{
	while (1)
	{
		Start start;
		start.work();
		cout << "按任意数字返回主界面：";
		int n;
		cin >> n;
		system("cls");
	}
}
void Start::rule()//规则说明 
{
	cout << "=======================================================================================================================" << endl;
	cout << '\t' << '\t' << '\t' << '\t' << '\t' << '\t' << "规则" << endl << endl;
	cout << "  “对称”是一种新的抽象策略棋盘游戏。游戏的规则非常简单，使用对称的概念，并导致一个非常具有挑战性的游戏。" << endl;
	cout << "  “对称”是一个抽象的2人游戏。玩家需要在棋盘上创建对称的图案以获得领地，同时防止对手在棋盘上创建对称的图案。" << endl;
	cout << "  对称性的激发规则如下:" << endl;
	cout << "  黑白相间轮流把石头放在石头上NxN板（白色开始)";
	cout << "  当一块石头放在木板上使一块正方形完全被石头复盖时，如果这块正方形的石头颜色图案变成水平或垂直的“镜子”对称，这个正方形就变成最后一块石头的颜色";
	cout << "  所以“对角对称“不会引起任何颜色变化";
	cout << "  对称正方形可能有任何大小(2x2，3x3，4x4等)。";
	cout << "  有时一个以上的方块会因为移动而变成对称。所有这些方块都会改变颜色。";
	cout << "  当棋盘上没有空的字段时游戏结束。";
	cout << "  胜者是在最后有最多他们的颜色的石头在棋盘上的球员" << endl;
	cout << "=======================================================================================================================" << endl;
	cout << '\t' << '\t' << '\t' << '\t' << '\t' << '\t' << "样例：" << endl << endl;
	cout << "1 0" << "                1 1 " << endl << "1 0" << "                0 0 " << endl;
	cout << "水平对称" << "           垂直对称" << endl;
	cout << "1 0 1" << endl << "0 1 0" << endl << "1 0 1" << endl;
	cout << "既水平对称又垂直对称" << endl << endl;
	cout << "注意：一手为1  二手为0     在人机对战中你是一手 ，人机和机机对战图一乐，随机套用" << endl;
	cout << "=======================================================================================================================" << endl;
}
void Start::clear()//初始化棋盘 
{
	system("color F2");//实现背景色白，字体为绿
	cout << endl << endl;
	cout << '\t' << '\t' << '\t' << '\t' << '\t' << "你要设置的棋盘规模大小： ";
	cin >> N;
	for (int i = 1; i <= N; i++)
	{
		for (int j = 1; j <= N; j++)
		{
			chess[i][j] = '.';
		}
	}
}
void Start::print()//打印棋盘 
{
	Start start;
	cout << endl << endl;
	cout << '\t' << '\t' << '\t';
	cout << " ";
	for (int i = 1; i <= N; i++)
	{
		cout << i << " ";
	}
	cout << endl;
	for (int i = 1; i <= N; i++)
	{
		if (i != 10) { cout << '\t' << '\t' << '\t' << i << " "; }
		else { cout << '\t' << '\t' << '\t' << i; }

		for (int j = 1; j <= N; j++)
		{
			cout << chess[i][j] << " ";

		}
		if (i == 1)
		{
			cout << "   一手: " << start.sum_one();

		}
		else if (i == 2)
		{
			cout << "   二手: " << start.sum_two();

		}
		cout << endl;
	}

}
bool Solve::find(int a, int b, int k)//用于查找正方形里是否填满以及是否可以构成一个正方形，没有就返回false,有则true ,考虑到奇数边长正方形有一条边长在计算对称会忽略 
{
	//a,b是坐标，k是边长
	bool flag = false;//标记是否 
	for (int i = a; i < a + k && a + k <= N + 1; i++)
	{
		for (int j = b; j < b + k && b + k <= N + 1; j++)
		{
			if (chess[i][j] != '.')//初始化为空
			{
				flag = true;
			}
			else
			{
				flag = false;
				break;
			}
		}
		if (!flag) { break; }
	}
	return flag;
}
void Solve::Judge(int a, int b)//判断正方形是否对称， 也就是符合情况的正方形的左上角坐标全部在，a,b围成的区域里，其他只会重复 
{
	Solve solve;
	bool flag = false;
	int x[10], y[10], c[10];//存储符合情况的坐标和边长 ，因为N为10，也就是边长为10，最大的正方形也才10，符合情况的在10以内 
	int cnt = 0;
	for (int k = 2; k <= N; k++)
	{
		for (int i = k - 1; i >= 0; i--)
		{
			for (int j = k - 1; j >= 0; j--)
			{
				if (solve.find(a - i, b - j, k) && solve.sure(a - i, b - j, k, a, b) && solve.xyjudge(a - i, b - j, k))
				{
					x[cnt] = a - i; y[cnt] = b - j; c[cnt] = k;
					cnt++;
				}
			}
		}
	}
	for (int i = 0; i < cnt; i++)
	{
		solve.reverse(x[i], y[i], c[i], a, b);//翻转 
	}
	Start start;
	start.print();//打印 

}
bool Solve::sure(int x, int y, int k, int a, int b)//针对部分情况，有些点要在正方形区域里面 
{
	bool flag1 = a <= x + k - 1 && a >= x && b <= y + k - 1 && b >= y;
	bool flag2 = x * y <= a * b && x * y >= 1;//合法坐标，在(a,b)区域里 
	return flag1 && flag2;
}
bool Solve::xyjudge(int a, int b, int k)//判断X,Y轴对称 ，k是正方形的边长 
{
	bool flag_x = false, flag_y = false;//flag_x判断X轴对称，flag_y判断Y轴对称 
	for (int i = 0; i < k / 2; i++)
	{
		for (int j = 0; j < k; j++)
		{
			if (chess[a + i][b + j] == chess[a + k - i - 1][b + j] && chess[a + i][b + j] != '.')//对称且不为空 
			{
				flag_x = true;
			}
			else
			{
				flag_x = false;
				break;
			}
		}
		if (!flag_x) { break; }
	}
	for (int i = 0; i < k; i++)
	{
		for (int j = 0; j < k / 2; j++)
		{
			if (chess[a + i][b + j] == chess[a + i][b + k - j - 1] && chess[a + i][b + j] != '.')//对称且不为空，貌似可以不写find() 
			{
				flag_y = true;
			}
			else
			{
				flag_y = false;//只要有一个不符合就跳出 
				break;
			}
		}
		if (!flag_y) { break; }
	}
	return flag_x | flag_y;//只要有一个符合就行 
}
void Solve::reverse(int a, int b, int k, int x, int y)//实现数组的翻转，a,b,是起始坐标，k是边长，xy是符合对称的坐标 
{
	for (int i = a; i < a + k; i++)
	{
		for (int j = b; j < b + k; j++)
		{
			chess[i][j] = chess[x][y];//chess[x][y]是实现对称的棋子，最后翻转成他的样子
		}
	}
}
int Start::sum_one()//统计每次下棋之后，棋盘里的一手棋数量 
{
	int sum = 0;
	for (int i = 1; i <= N; i++)
	{
		for (int j = 1; j <= N; j++)
		{
			if (chess[i][j] == '1')
			{
				sum++;
			}
		}
	}
	return sum;
}
int Start::sum_two()//统计每次下棋之后，棋盘里的二手棋数量 
{
	int sum = 0;
	for (int i = 1; i <= N; i++)
	{
		for (int j = 1; j <= N; j++)
		{
			if (chess[i][j] == '0')
			{
				sum++;
			}
		}
	}
	return sum;
}
void Solve::predict()//最后比较一手二手最后的棋子数量 
{
	int cnt1 = 0, cnt2 = 0;//一手cnt1,二手cnt2
	for (int i = 1; i <= N; i++)
	{
		for (int j = 1; j <= N; j++)
		{
			if (chess[i][j] == '1')
			{
				cnt1++;
			}
			else
			{
				cnt2++;
			}
		}
	}
	if (cnt1 > cnt2)
	{
		cout << "一手胜利！" << endl;
	}
	else if (cnt1 < cnt2)
	{
		cout << "二手胜利！" << endl;
	}
	else
	{
		cout << "平局！" << endl;
	}
}
void Solve::calulate(int n)
{
	Solve solve;
	Start start;
	if (n == 1)//n==1，一手情况，n==2二手情况 
	{
		cout << "一手坐标：";//默认坐标从（1，1）开始 
		int a, b;
		cin >> a >> b;
		chess[a][b] = '1';
		sum = sum + 1;
		solve.Judge(a, b);//每次落子就要判断，打印棋盘
		system("cls");
		start.print();

	}
	else if (n == 2)
	{
		cout << "二手坐标：";//默认坐标从（1，1）开始 
		int c, d;
		cin >> c >> d;
		chess[c][d] = '0';
		sum = sum + 1;
		solve.Judge(c, d);
		system("cls");
		start.print();

	}
	else if (n == 3)
	{
		int c, d;
		srand((int)time(0));//保证随机数不一样 
		c = 1 + rand() % (N + 1);
		d = 1 + rand() % (N + 1);
		while (chess[c][d] != '.')
		{
			c = 1 + rand() % (N + 1);
			d = 1 + rand() % (N + 1);
		}
		chess[c][d] = '0';//电脑下棋 即应该返回c,d值，也就是坐标 
		sum = sum + 1;
		solve.Judge(c, d);
		system("cls");
		start.print();
	}
	else if (n == 4)
	{
		int a, b;
		a = 1 + rand() % (N + 1);
		b = 1 + rand() % (N + 1);
		while (chess[a][b] != '.')
		{
			a = 1 + rand() % (N + 1);
			b = 1 + rand() % (N + 1);

		}
		chess[a][b] = '1';
		sum = sum + 1;
		solve.Judge(a, b);//每次落子就要判断，打印棋盘
		system("cls");
		start.print();
	}
}
void Pattern::player()//人人对战模式 
{
	Start start;
	Solve solve;
	start.clear();
	system("cls");
	start.print();//打印棋盘
	while (sum < N * N)
	{
		solve.calulate(1);
		if (sum == N * N)
		{
			break;
		}
		solve.calulate(2);
	}
	solve.predict();//棋盘填完，判断谁多
}
void Pattern::computer()//人机对战模式 ,应该只有一层 
{
	//默认自己先手 
	Start start;
	Solve solve;
	start.clear();
	system("cls");
	start.print();//打印棋盘
	while (sum < N * N)
	{
		solve.calulate(1);
		if (sum == N * N)
		{
			break;
		}
		solve.calulate(3);
	}
	solve.predict();//棋盘填完，判断谁多
}
void Pattern::twocomputer()//机机对战 
{
	//默认自己先手 
	Start start;
	Solve solve;
	start.clear();
	system("cls");
	start.print();//打印棋盘
	while (sum < N * N)
	{
		//sum计算一共合计下了多少个棋子
		solve.calulate(4);
		if (sum == N * N)
		{
			break;
		}
		solve.calulate(3);
	}
	solve.predict();//棋盘填完，判断谁多
}
int main()
{
	Start s;
	s.screen();//最终反馈
	return 0;
}
嗷嗷待哺的簸箕板
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
C语言零基础项目：黑白棋游戏！详细思路+源码分享
致力于C语言C++知识分享！
12-28 2876
规则简单，但是变化复杂，是典型的易学难精，奥妙无穷，不信您就试试看吧！
C++经典编程题目（十三）黑白棋子交替排列问题
二十三年弃置身
08-27 2370
14. 有黑白棋子各有Ｎ个（分别用＊和Ｏ代替），按下图方式排列 ＊＊＊．．．＊＊＊ＯＯＯ．．．ＯＯＯ Ｎ个黑棋 Ｎ个白棋 允许将相邻两个棋子互换位置，最后使队形成黑白交替排列，试编程实现该操作。 #include "stdio.h" #include <iostream> using namespace std...
黑白棋算法分析（一）
jcs130的专栏
08-01 4690
刚才去QQ黑白棋上和别人下了几局，关于黑白棋的下法总结了一下，准备写人机对战程序了~： 黑白棋和五子棋不同，棋盘各点的权值不是单纯的通过连子数决定，还和所下位置有很大关系！ 这个是黑白棋的棋盘：    黑白棋游戏的核心就是要抢占四个角！因为只要放到了角上，就不会被改变了。这就是“金角银边草肚皮”说法的由来 金角： 角的权值应设为最大。 相对应的，和四个角相邻的格...
黑白棋AI版
10-31
人机对战版黑白棋，包含可执行文件及代码，方便使用
C++实现对称黑白棋.zip
04-24
Step 1 000 010 000 White: 1 Black: 0 Step 2 000 012 000 White: 1 Black: 1 Step 3 000 012 010 White: 2 Black: 1 Step 4 000 022 022 White: 0 Black: 4 Step 5 100 022 022 White: 1 Black: 4 ...White wins
C++ 课程设计 对称黑白棋.zip
04-24
“Symmetry” is a new abstract strategy board game. The game rules are very simple, use the concept of symmetry, and result in a very challenging gameplay! “Symmetry” is an abstract 2-player game....
C++noi信奥赛1353 - 轴对称三角形
最新发布
11-14
noi信奥赛题目
易语言源码加密配置文件读写模块 1.0.rar
02-16
本模块——"易语言源码加密配置文件读写模块 1.0"，是针对易语言开发的一个特定功能组件，主要目的是为了帮助开发者更好地管理和保护他们的源代码。 在软件开发中，源码的安全性至关重要，因为它包含了程序的核心...
C++实现文件加密解密.rar
03-21
本资源"**C++实现文件加密解密**"可能包含了用于创建加密和解密文件的源代码示例，旨在帮助开发者理解如何在C++环境中安全地处理敏感数据。 在C++中，文件加密通常基于一些流行的加密算法，如AES（高级加密标准）、...
黑白棋AI程序
03-06
黑白棋AI程序黑白棋AI程序黑白棋AI程序黑白棋AI程序黑白棋AI程序黑白棋AI程序
C++黑白棋AI游戏
04-01
使用vc6.0，C++语言写的，适合对游戏感兴趣的。
黑白棋AI算法
07-18
自己制作的黑白棋AI算法 采用了alha-beta剪枝和比较准确的估值算法，有比较墙的智能水平
黑白棋(带简单AI)
12-15
自己写的黑白棋，有简单的AI,可以双人对战或人机对战。有悔棋功能。有计时功能。
黑白棋（翻转棋）代码
09-04
用MFC自己写的一个黑白棋人机对战程序，人工智能还不错。
黑白棋C\C++实现方式
热门推荐
相濡以沫的博客
12-06 1万+
黑白棋的C\C++实现方式
用c＋＋实现黑白棋
zdfantasy的专栏
10-19 1万+
黑白棋规则介绍黑白棋是由黑方和白方两人进行的益智游戏。棋盘为N×N方格，黑白棋总共使用N2个棋子，每个棋子分正反两面，分别是黑色和白色。轮到一方下棋时，必须把棋下在与对方棋子相邻的空位上，要求所下的棋子和原有的已方棋子夹住对方的至少一个棋子(横竖斜夹均可)，然后把被夹住的子变成己方的颜色(也叫吃子)。下棋过程中，任何棋子既不会从棋盘上拿走，也不会从一个格子移到另一个格子,吃子时，不会发生连锁反
C++ 黑白棋AI minimax+alphabeta剪枝
weixin_30408675的博客
12-02 1875
没事写着玩玩，通过debian上的黑白棋测试，搜了10层，打hard应该问题不大 #include <cstdio> #include <cstring> using namespace std; template <typename T> T min(const T &x, const T &y) { return x < y ? x...
用c++实现基于openssl的大文件的对称加密与解密
05-26
以下是使用 OpenSSL 库进行大文件对称加密和解密的 C++ 代码示例： ```c++ #include #include #include #include #include using namespace std; // 加密函数 void encrypt_file(const char *in_filename, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值