对称黑白棋实现（含文件读写）

最新推荐文章于 2022-07-28 18:20:34 发布
最新推荐文章于 2022-07-28 18:20:34 发布
阅读量744 收藏 5
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45754293/article/details/106893558
版权 
#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 TranFile//文件写入 
{
public:
	int x, y;
	TranFile(int x, int y) :x(x), y(y) {};//传入坐标 
	void tran(int n)
	{
		CreateDirectory("F:\\exam", NULL);
		if (n == 1)
		{
			ofstream fout1("F:\\exam\\Data1.txt");
			ofstream fout11("F:\\exam\\Data11.txt", ios::app);
			if (!fout1 || !fout11)
			{
				cerr << "打开文件失败" << endl;
				exit(1);
			}
			fout1 << x << y;
			fout11 << x << y;
			fout1.close();
			fout11.close();
		}
		else
		{
			ofstream fout2("F:\\exam\\Data2.txt");
			ofstream fout22("F:\\exam\\Data22.txt", ios::app);
			if (!fout2 || !fout22)
			{
				cerr << "文件打开失败" << endl;
			}
			fout2 << x << y;
			fout22 << x << y;
			fout2.close();
			fout22.close();
		}
	}
};
class FinFile//文件读写 
{
public:
	void Cin(ifstream& fin, int n)
	{
		int num[2];
		int cnt = 0;
		char word[2] = { '1','0' };
		if (!fin)
		{
			cerr << "文件打开失败" << endl;
			exit(1);
		}
		char x;
		while (fin >> x)
		{
			num[cnt++] = (int)x - 48;
			if (cnt == 2)
			{
				chess[num[0]][num[1]] = word[n - 1];
				cnt = 0;
			}
		}
		cout << endl;
		fin.close();
	}
	void put()
	{
		ifstream fin1("F:\\exam\\Data1.txt");//一手 
		ifstream fin2("F:\\exam\\Data2.txt");//二手 
		FinFile f;
		f.Cin(fin1, 1); f.Cin(fin2, 2);
	}
};
class PrintFile//打印结果到文件里 
{
public:
	void print(ofstream& fout)
	{
		fout << '\t' << '\t' << '\t'<<"棋盘大小： "<<N<<endl;
		fout << "====================================================================================================" << endl << endl;
		fout << '\t' << '\t' << '\t';
		fout << " ";
		for (int i = 1; i <= N; i++)
		{
			fout << i << " ";
		}
		fout << endl;
		for (int i = 1; i <= N; i++)
		{
			if (i != 10) { fout << '\t' << '\t' << '\t' << i << " "; }
			else { fout << '\t' << '\t' << '\t' << i; }

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

			}
			if (i == 1)
			{
				fout << "   一手: ";

			}
			else if (i == 2)
			{
				fout << "   二手: ";

			}
			fout << endl;
		}
	}
	void tranprint()
	{
		ofstream fout("F:\\exam\\result.txt", ios::app);
		if (!fout)
		{
			cerr << "打开文件失败" << endl;
			exit(1);
		}
		print(fout);
		fout.close();
	}
};
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;
	FinFile f;
	PrintFile pf;
	if (n == 1)//n==1，一手情况，n==2二手情况 
	{
		cout << "一手坐标：";//默认坐标从（1，1）开始 
		int a, b;
		cin >> a >> b;
		TranFile tf(a, b);
		tf.tran(1);
		f.put();
		//chess[a][b] = '1';
		sum = sum + 1;
		solve.Judge(a, b);//每次落子就要判断，打印棋盘
		system("cls");
		start.print();
		pf.tranprint();
	}
	else if (n == 2)
	{
		cout << "二手坐标：";//默认坐标从（1，1）开始 
		int c, d;
		cin >> c >> d;
		TranFile tf(c, d);
		tf.tran(2);
		f.put();
		//chess[c][d] = '0';
		sum = sum + 1;
		solve.Judge(c, d);
		system("cls");
		start.print();
		pf.tranprint();
	}
	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;
}

大一期末对称黑白棋，AI部分不要看，有兴趣的可以玩玩，

嗷嗷待哺的簸箕板
关注
C++ 听力测试
小天狼星_布莱克 的博客
07-25 242
此程序要有声音的电脑运行。
黑白棋C++实现
01-04
滕讯小游戏黑白棋，用C++语言实现，可实现简单的双人对战与人机对战。
三子棋游戏
m0_72161237的博客
07-28 1017
三子棋是黑白棋的一种。三子棋是一种民间传统游戏，又叫九宫棋、圈圈叉叉、一条龙、井字棋等。将正方形对角线连起来，相对两边依次摆上三个双方棋子，只要将自己的三个棋子走成一条线，对方就算输了。但是，有很多时候会出现和棋的情况。接下来我们一起来完成这个游戏设计。...
黑白棋（翻转棋）代码
09-04
用MFC自己写的一个黑白棋人机对战程序，人工智能还不错。
电脑围棋
qkyong的专栏
12-01 3580
1.0 概述本文旨在向读者介绍电脑围棋领域的状况及 Internet 上的相关资源。 为照顾尚不熟悉围棋的读者，第2部分介绍了围棋的基本常识和规则，熟悉这些的读者可以跳过它，或在必要时参考。 第6部分将告诉读者，由于各自的特点，目前围棋程序的水平与国际象棋程序相比差距极大，有待于进一步投入力量开发；第3部分 给出了其理论和实践的依据，并指出围棋程序是不可能仿照国际象棋程序那样开发的（参见表一）。
电脑围棋领域的研究概述
popkiler的专栏
09-11 2946
电脑围棋领域的研究概述原著：Jay Burmeister 　　　Janet Wiles 澳大利亚昆士兰州大学计算机科学与心理学系 Departments of Computer Science and Psychology The University of Queensland, QLD 4072, Australia 编译：George Zhong本译文纯属志愿工作
java源码包---java 源码 大量 实例
04-18
Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密 　Java非对称加密源程序代码实例，本例中使用RSA加密技术，...
java源码包2
04-20
Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密 　Java非对称加密源程序代码实例，本例中使用RSA加密技术...
最短的具有人工智能的黑白棋程序
编程的艺术世界 - Bruce Lee
04-08 2794
最短的具有人工智能的黑白棋程序           这是很久之前在黑白棋联盟的论坛上看到的，虽然为了精简写的跟外星文一样，但确实有点佩服这位作者。        直接贴到VC上就可以看到结果。我那时候特意把它“翻译”了一遍，当然就不会那么精简了，是为了让一些人看的明白一些。源程序：#define D define#define Y return#define R for#defin
[源码和文档分享]基于汇编语言实现的彩色黑白棋游戏
qq_38474647的博客
06-19 254
一、软件背景介绍 1.1 背景介绍 黑白棋在西方和日本很流行。游戏通过相互翻转对方的棋子，最后以棋盘上谁的棋子多来判断胜负。它的游戏规则简单，因此上手很容易，但是它的变化又非常复杂。有一种说法是：只需要几分钟学会它，却需要一生的时间去精通它。 黑白棋是 19 世纪末英国人发明的。直到上个世纪 70 年代日本人长谷川五郎将其进行发展和...
生成黑白相间的国际象棋棋盘
qq_43427963的博客
08-04 1146
// Use this for initialization void Start () { for (int i = 0; i < 10; i++)//十行 { for (int j = 0; j < 10; j++) { if (i % 2 == 0) { if (j % 2 == 0) { GameObject go = GameObject.Instantiate(Resour...
五子棋游戏设计VHDL语言
QQ_778132974的博客
12-11 3778
本设计实现五子棋游戏设计，使用verilog语言 quartusII 或者 vivado均可 通过VGA显示实时的棋盘，双方可以通过按键来控制黑棋和白棋的位置，实现五子棋游戏的功能。 开始和胜利的界面如下： 下面是该五子棋游戏设计的工程截图： ...
scratch编程小游戏黑白棋
迷你恐龙的博客
09-08 5339
你有没有玩过一种游戏，就是按3X3排列的方块，方块中有黑有白，当你按下一个后周围的黑块会变成白块，白块变黑块，当全部的方块都变成白色是就赢了，今天我们就来编写这个游戏！ 首先来看看效果： 知道怎么玩了吗？现在就来看看是怎么编写的吧！ 首先画出所有的角色： 方块要画出一黑一白： 方块首先要移动到合适的位置，然根据探测器来切换黑白： 方块1： 方块2： 方块3： 方块4： 方块5： 方块6： 方块7： 方块8： 方块9： 现在是最最最最重要的探测器程序了，探测器决定了布局的结果，保证不会
哈理工OJ P2320：OX
anquan1533的博客
12-16 113
题目链接：OX 题意 ：给出一个3X3的黑白棋棋盘，棋盘上有若干黑白子，再给出下一个下的人，问下一个下的人能否赢 分析：考虑到只有39种状态，故用一个数保存目前棋盘的状态，记为value，再枚举空位DFS，每次 DFS先判该状态是否已到达（剪枝），再拆分状态用c[3][3]储存，判断是否有赢的状态，最后遍历 棋盘寻找空位，若有则下，value储存状态，再DFS下去，注...
错觉图片生成实验 - 扭曲的黑白棋盘
weixin_49630241的博客
01-23 621
（图书介绍：童晶：《C和C++游戏趣味编程》新书预告）这学期的线下C语言课程，大一同学们学完旋转蛇案例后（童晶：第4章 旋转蛇（《C和C++游戏趣味编程》配套教学视频）），布置了一次错觉图片生成实验的PBL，给了大家5天时间分组完成代码、ppt报告。这次，介绍邵一宸、汤刘阳、李树斌、詹振威同学实现的扭曲的黑白棋盘。由于同学们学习C语言刚一个月，还没有正式学习数组、函数等语法知识，因此代码可能不够完...
黑马程序员-神奇的标志位“Bool flag=false”
qly2046
12-20 8515
神奇的标志位“Bool flag=false” 第一次接触标志位，是在苏坤老师讲的C#基础视频中，感觉标志位很神奇。为了充分理解这一知识点，我决定写篇博客对此总结一下，以便加深印象，更加方便广大网友日后使用。先写几个题让大家了解了解，然后总结出规律。 第一题： 李四的年终评定：如果被评为A级，则工资涨500元；B级则涨200元；C级不涨不扣；D级扣200元；E级扣500元。设李四的原工资为5
几种黑白相间的棋盘实现方法
猛一回头的博客
03-13 8854
方法一：用 DIV 实现 &lt;style&gt; .black-cell{ width:50px; height:50px; background: #000; position: absolute; top:0; left:0; } &lt;/style&gt; &...
FPGA基础之VGA（四）黑白棋盘
weixin_42736555的博客
11-27 3669
一、VGA原理 参见博文VGA（一） 二、黑白棋盘 2.1 棋盘显示算法 根据棋盘中每个小方格行列坐标之和的奇偶性来显示不同的颜色，和是奇数显示白色，偶数显示黑色。 2.2 显示原理 每个小方格包括40X40个像素点，640X480总共可以形成16X12个小方格。在同一个小方格内的像素点应该具有相同的属性，即它们的行列坐标应该相同。具体实现，水平计数器和垂直计数器分别除40，将得到的结果最低位进行...
C++ 实现稀疏矩阵与对称矩阵的压缩存储
"C++ 数据结构之对称矩阵及稀疏矩阵的压缩存储技术的实现" 在计算机科学中，处理大型矩阵时，如果矩阵中大部分元素都是零，那么使用传统方式存储将非常浪费空间。为了解决这个问题，我们引入了稀疏矩阵（Sparse ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值