打败魔王（这是2022中兴捧月打榜的一道题）

已于 2022-05-09 18:37:29 修改
阅读量889 收藏 1
点赞数 1
分类专栏： C/C++ 文章标签： 动态规划 c++ 算法
于 2022-05-08 19:39:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_33909696/article/details/124653104
版权

文章目录

1、题目描述

小明和小红是两位魔法师，他们一起在一张N*N的方格地图上冒险（N<=9）去击败魔王，地图中的方格代表他们所走的路径，方格中的正整数代表可获得的法力值，而其他的方格中的数字为0代表无法获得法力值，如下图所示（见样例）：
在这里插入图片描述

他们二人从图上的起点出发，为了更快的打败魔王，他只能向右或者向下前进，直到到达下方的魔王城。在走过的路上，他们能够获得地图里的数字（获取后地图中将变为数字0）变为法力值。小明先从起点出发走到魔王城，然后小红再出发到达魔王城，为了更好的对抗魔王，请你帮帮2位魔法师使其获得的法力值为最大。

输入描述：

第一行为1个整数N(0<N<=9)表示N*N的地图，然后输入若干行，每行中有3个整数，前2个表示位置坐标x,y(1<=x,y<=N)，第3个数为该坐标提供的法力值k(0<=k<65536)。最后一行数输入单独的一行0 0 0表示输入结束。

输出描述：

只需要输出一个整数，表示小明和小红能获得的最大法力值的和。

样例1：

输入：
7
2 1 12
2 5 8
2 6 6
3 3 5
4 3 13
6 6 5
7 2 1
0 0 0
输出：
49

样例2：

输入：
5
1 1 5
1 3 6
2 5 6
4 2 13
5 1 5
0 0 0
输出：
30

2、解法1

贪心：进行两次动态规划，每次取最大值。这个方法无法获取全局最大，要获取全局最大请继续向下读

动态规划

  • 1、确定dp数组极其含义
    dp[i][j]表示坐标为i,j的位置最大法力为dp[i][j].
  • 2、确定递推公式
    dp[i][j]可由两个方向进行得到，一个是dp[i-1][j],另一个是dp[i][j-1]，因为本题要获取最大法力，因此：dp[i][j]=max(dp[i-1][j],dp[i][j-1])+mp[i][j]
  • 3、如何初始化
    因为只有两个方向，因此在边缘上对其进行累加即可。

完整cpp代码：


#include<iostream>
#include<vector>
#include<queue>
#include<string>
#include<bits/stdc++.h>
using namespace std;

void my_dp(int N,vector<vector<int>> &dp, vector<vector<int>>& mp, vector<vector<int>>& mp_b)
{
	for (int i = 1; i < N; i++)
	{
		for (int j = 1; j < N; j++)
		{
			int a = dp[i - 1][j];
			int b = dp[i][j - 1];
			if (a >= b) //选择向右的路径
			{
				dp[i][j] = a + mp[i][j]; // 计算此时的最大法力值

				mp[i - 1][j] = 0; // 由题意，我们走了这个地方就需要将该点的法力值清0
				for (int p = 0; p < j; p++)// 那么该点上面的数据我们需要将其保持恒定不变，从备份图中拷贝过来
					mp[i][p] = mp_b[i][p];

			}
			else
			{
				dp[i][j] = b + mp[i][j];// 和上面一样
				mp[i][j - 1] = 0;
				for (int p = 0; p < i; p++)
					mp[p][j] = mp_b[p][j];

			}
		}
	}
}

void my_Init(int N,vector<vector<int>> &dp, vector<vector<int>> mp)
{
	int tem = 0;
	for (int i = 0; i < N; i++) // 进行初始化，因为只能向下和向右，因此边缘为边缘数据的累和
	{
		tem += mp[i][0];
		dp[i][0] = tem;
	}
	tem = 0;
	for (int i = 0; i < N; i++)
	{
		tem += mp[0][i];
		dp[0][i] = tem;
	}
}
int main() {
	int N = 0;
	cin >> N;
	vector<vector<int>> mp(N,vector<int>(N,0));//构建地图
	while (true) // 数据输入
	{
		int x, y, z;
		cin >> x >> y >> z;

		if (x == 0 && y == 0 && z == 0)
			break;
		mp[x-1][y-1] = z;
	}
	vector<vector<int>> mp_b = mp; // 进行地图备份
	// dp[i][j] 表示位置在i和j处能获得的最大法力
	// dp[i][j] = max(dp[i-1][j],dp[i][j-1])
	// 创建dp数组
	vector<vector<int>> dp(N,vector<int>(N,0));
	vector<vector<int>> dp1(N, vector<int>(N, 0));
	// 进行第一个人dp数组初始化
	my_Init(N,dp,mp);
	//进行第一个人dp
	my_dp(N,dp,mp,mp_b);

	mp[0][0] = 0;
	mp[N - 1][N - 1] = 0;  // 上面是从1,1点开始的，我们需要手动将起点和重点清0

	// 第二轮开始，从新初始化dp1
	my_Init(N, dp1, mp);
	// 进行第二个人的dp
	my_dp(N, dp1, mp, mp_b);

	// 两人最大法力值为两个dp数组的和
	cout << dp[N-1][N-1]+dp1[N-1][N-1] << endl;

	
}

该方法只能达到局部最优，但无法实现全局最优，如这位网友（ m0_49301123）举的一个例子：

0 0 0 0 0
0 0 5 0 0
0 13 0 0 0
0 0 0 8 0
0 1 0 0 0
两次分别取最大值会是第一次13+8=21，第二次5，总21+5=26
而实际上应该是第一次13+1=14，第二次5+8=13，总14+13=27

使用上面方法就无法进行实现。

3、解法2

使用回溯进行深搜：当第一个人选择了一条路径时，我们在这条路径的基础上在进行第二个人的路径搜索，总的来讲就是深搜在嵌套一层深搜索。但这个方法速度很慢，但能跑出正确结果。

完整cpp代码如下：


#include<iostream>
#include<vector>
#include<queue>
#include<string>
#include<bits/stdc++.h>
using namespace std;

int dx[2] = {1,0};
int dy[2] = {0,1};

int** vis = NULL;
int** vis1 = NULL;
vector<pair<int, int>> path; // 代表走过的路径的坐标
vector<pair<int, int>> min_path; //记录最小的路径

vector<pair<int, int>> path1; // 代表走过的路径的坐标
vector<pair<int, int>> min_path1; //记录最小的路径

int mi = INT_MIN;

vector<vector<int>> mp_b;  // 地图备份

void dfs1(int x, int y, int dxs, int dxy, vector<vector<int>>& map, int m, int n, int step, vector<pair<int, int>> ph)
{
	// 函数的出口
	if (x == dxs && y == dxy)
	{
		// 统计这一条路径的中总和路径长度
		int tem = 0;
		for (int i = 0; i < path1.size(); i++)
		{
			tem += map[path1[i].first][path1[i].second];
		}
		// 统计前一条路径和
		 
		for (int i = 0; i < ph.size(); i++)
		{
			tem += mp_b[ph[i].first][ph[i].second];
		}
		  
		// 如果这条路径比前一条还短，那么就进行路径更新
		if (tem >= mi)
		{
			//min_path1 = path1;
			mi = tem;
		}

		return;
	}

	// 进行是个方向进行探索
	for (int i = 0; i < 2; i++)
	{
		int tx = x + dx[i];
		int ty = y + dy[i];
		// 判断是否越界，并且判断是否没有访问
		if (tx >= 0 && ty >= 0 && tx < m && ty < n && !vis1[tx][ty]) // 注意这里tx是小于行，ty是小于列
		{
			// 如果没有走过，并且没有越界，进行探索

			// 首先标记这个点为已经走过
			vis[tx][ty] = 1;
			// 并将这个点压入path中
			path1.push_back(pair<int, int>(tx, ty));
			dfs1(tx, ty, dxs, dxy, map, m, n, step + 1,ph);
			// 回溯的时候将其取消标记
			vis[tx][ty] = 0;
			// 并将这个点出站
			path1.pop_back();
		}
	}


}

void dfs(int x, int y, int dxs, int dxy, vector<vector<int>> &map, int m, int n, int step)
{
	// 函数的出口
	if (x == dxs && y == dxy)
	{
		// 进行第二个人的dfs
		vis1[0][0] = 1;
		// 将path中的地图清0
		for (int i = 0; i < path.size(); i++)
		{
			map[path[i].first][path[i].second] = 0;
			/*tem += map[path[i].first][path[i].second];*/
		}
		dfs1(0,0,m-1,n-1, map,m,n,0,path);
		for (int w = 0; w < m; w++) // 进行清零 为下一次做准备
		{
			for (int w1 = 0; w1 < n; w1++)
			{
				vis1[w][w1] = 0;
			}
		}
		// 将path中的地图恢复
		for (int i = 0; i < path.size(); i++)
		{
			map[path[i].first][path[i].second] = mp_b[path[i].first][path[i].second];
		}
		 统计这一条路径的中总和路径长度
		//int tem = 0;
		//for (int i = 0; i < path.size(); i++)
		//{
		//	tem += map[path[i].first][path[i].second];
		//}
		 如果这条路径比前一条还短，那么就进行路径更新
		//if (tem >= mi)
		//{
		//	min_path = path;
		//	mi = tem;
		//}

		return;
	}

	// 进行是个方向进行探索
	for (int i = 0; i < 2; i++)
	{
		int tx = x + dx[i];
		int ty = y + dy[i];
		// 判断是否越界，并且判断是否没有访问
		if (tx >= 0 && ty >= 0 && tx < m && ty < n && !vis[tx][ty]) // 注意这里tx是小于行，ty是小于列
		{
			// 如果没有走过，并且没有越界，进行探索

			// 首先标记这个点为已经走过
			vis[tx][ty] = 1;
			// 并将这个点压入path中
			path.push_back(pair<int, int>(tx, ty));
			dfs(tx, ty, dxs, dxy, map, m, n, step + 1);
			// 回溯的时候将其取消标记
			vis[tx][ty] = 0;
			// 并将这个点出站
			path.pop_back();
		}
	}


}


int** to_arr(int a, int b)
{
	int** map = (int**)malloc(a * sizeof(int*));
	for (int i = 0; i < a; i++)
		map[i] = (int*)malloc(b * sizeof(int)); // 进行内存申请
	// 进行初始化
	for (int i = 0; i < a; i++)
		for (int j = 0; j < b; j++)
			memset(map[i], 0, b * sizeof(int));
	return map;
}
int main() {
	int N = 0;
	cin >> N;
	int m = N ;
	int n = N ;
	vector<vector<int>> mp(N, vector<int>(N, 0));//构建地图
	while (true) // 数据输入
	{
		int x, y, z;
		cin >> x >> y >> z;

		if (x == 0 && y == 0 && z == 0)
			break;
		mp[x - 1][y - 1] = z;
	}
	// 进行备份
	mp_b = mp;

	vis = to_arr(m, n);//申请已访问标记数组
	vis1 = to_arr(m, n);//申请已访问标记数组
	//将0,0标记为已访问
	vis[0][0] = 1;
	path.push_back(pair<int, int>(0, 0));

	dfs(0, 0, m - 1, n - 1, mp, m, n, 0);

	cout << mi << endl;

	//dfs();


}

上面那种情况测试用例：

输入：
5
2 3 5
3 2 13
4 4 8
5 2 1
0 0 0
输出：
27

4、解法3

总体来讲，上面方法二进行递归嵌套对整个题的开销是非常大的，但是不进行递归又无法获取全局最大，为此，折中的方法是在递归的基础上进行动态规划。

这个方法的时间复杂度较方法1要慢，较方法二要快，但方法1无法获取全局最优，因此，总体上来看，这个方法是目前较好的一种解决方法。如果有同学有更好的解决方法，可以在评论区留言，大家一起学习进步



#include<iostream>
#include<vector>
#include<queue>
#include<string>
#include<bits/stdc++.h>
using namespace std;

int dx[2] = {1,0};
int dy[2] = {0,1};

int** vis = NULL;
int** vis1 = NULL;
vector<pair<int, int>> path; // 代表走过的路径的坐标
vector<pair<int, int>> min_path; //记录最小的路径

int mi = INT_MIN;

vector<vector<int>> mp_b;  // 地图备份

void my_dp(int N, vector<vector<int>>& dp, vector<vector<int>>& mp)
{
	for (int i = 1; i < N; i++)
	{
		for (int j = 1; j < N; j++)
		{
			int a = dp[i - 1][j];
			int b = dp[i][j - 1];
			if (a >= b) //选择向右的路径
			{
				dp[i][j] = a + mp[i][j]; // 计算此时的最大法力值
			}
			else
			{
				dp[i][j] = b + mp[i][j];// 和上面一样
			}
		}
	}
}

void my_Init(int N, vector<vector<int>>& dp, vector<vector<int>> mp)
{
	int tem = 0;
	for (int i = 0; i < N; i++) // 进行初始化，因为只能向下和向右，因此边缘为边缘数据的累和
	{
		tem += mp[i][0];
		dp[i][0] = tem;
	}
	tem = 0;
	for (int i = 0; i < N; i++)
	{
		tem += mp[0][i];
		dp[0][i] = tem;
	}
}

void dfs(int x, int y, int dxs, int dxy, vector<vector<int>> &map, int m, int n, int step)
{
	// 函数的出口
	if (x == dxs && y == dxy)
	{
		// 进行第二个人的dfs
		vis1[0][0] = 1;
		// 将path中的地图清0
		for (int i = 0; i < path.size(); i++)
		{
			map[path[i].first][path[i].second] = 0;
			/*tem += map[path[i].first][path[i].second];*/
		}
		vector<vector<int>> dp(m, vector<int>(m, 0));
		my_Init(m, dp, map);
		my_dp(m, dp, map);
		int tem = 0;
		for (int i = 0; i < path.size(); i++)
		{
			tem += mp_b[path[i].first][path[i].second];
		}
		tem = tem + dp[m - 1][m - 1];
		// 如果这条路径比前一条还短，那么就进行路径更新
		if (tem >= mi)
		{
			//min_path1 = path1;
			mi = tem;
		}
		// 将path中的地图恢复
		for (int i = 0; i < path.size(); i++)
		{
			map[path[i].first][path[i].second] = mp_b[path[i].first][path[i].second];
		}
		return;
	}
	// 进行是个方向进行探索
	for (int i = 0; i < 2; i++)
	{
		int tx = x + dx[i];
		int ty = y + dy[i];
		// 判断是否越界，并且判断是否没有访问
		if (tx >= 0 && ty >= 0 && tx < m && ty < n && !vis[tx][ty]) // 注意这里tx是小于行，ty是小于列
		{
			// 如果没有走过，并且没有越界，进行探索

			// 首先标记这个点为已经走过
			vis[tx][ty] = 1;
			// 并将这个点压入path中
			path.push_back(pair<int, int>(tx, ty));
			dfs(tx, ty, dxs, dxy, map, m, n, step + 1);
			// 回溯的时候将其取消标记
			vis[tx][ty] = 0;
			// 并将这个点出站
			path.pop_back();
		}
	}


}

int** to_arr(int a, int b)
{
	int** map = (int**)malloc(a * sizeof(int*));
	for (int i = 0; i < a; i++)
		map[i] = (int*)malloc(b * sizeof(int)); // 进行内存申请
	// 进行初始化
	for (int i = 0; i < a; i++)
		for (int j = 0; j < b; j++)
			memset(map[i], 0, b * sizeof(int));
	return map;
}
int main() {
	int N = 0;
	cin >> N;
	int m = N ;
	int n = N ;
	vector<vector<int>> mp(N, vector<int>(N, 0));//构建地图
	while (true) // 数据输入
	{
		int x, y, z;
		cin >> x >> y >> z;

		if (x == 0 && y == 0 && z == 0)
			break;
		mp[x - 1][y - 1] = z;
	}
	// 进行备份
	mp_b = mp;

	vis = to_arr(m, n);//申请已访问标记数组
	vis1 = to_arr(m, n);//申请已访问标记数组
	//将0,0标记为已访问
	vis[0][0] = 1;
	path.push_back(pair<int, int>(0, 0));

	dfs(0, 0, m - 1, n - 1, mp, m, n, 0);

	cout << mi << endl;
}
思禾
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
中兴捧月历年题目
05-09
中兴捧月历年题目 要比赛的同学们注意啦，整理不容易呀
2020中兴捧月傅里叶派题目和参考答案.rar
05-13
2020中兴捧月傅里叶派题目和参考答案。 二分图的DFS，剪枝优化等。
2023 中兴捧月算法挑战赛-自智网络-参赛总结
最新发布
越努力，越幸运！
07-01 964
1.修改了lsqr的收敛判别条件，使其计算速度更快2.采用了加速投影梯度下降法进行非负最小二乘的求解，在原始非负投影改成区间投影，将负解投影到解的可行空间，保证了解的有效性3.有针对性的优化，算法仍有很大提升空间（例如一阶段第九组数据对初值较为敏感）1.在迪杰斯特拉算法(Dijkstra)的基础上增加运载约束、延误时间约束，保证了路径的可行性与有效性。
2022中兴捧月算法挑战赛（RAW图像去噪）——初赛到决赛总结与反思
轻舟的万重重山
08-08 2676
复赛流程：讲上述PPT，线上每个人一共15min，包括提问。复赛结果：意外进了决赛前18强冠军：用8*8邻域视为同一正态分布的样本点集合；取方差前40%小的集合，并把0和1样本点出现较多的集合去除，用最小二乘解得到a，b。亚军：根据低随机纹理强度提取有效图像块，并对图像块按纹理强度排序，再进行超峰度进行坐标转换，搜索迭代最佳值并换算得到a，b。季军：SwinTranfomer+两层全连接，转化为有监督的学习，模型直接输出a、b的预测。......
2020中兴捧月算法大赛迪杰斯特拉赛道初赛题解
gzxb1995的博客
06-27 2538
目录摘要1 程序中使用的数据结构1.1 几个基本数据类型1.2 车道(Lane)1.3 道路(Road)1.4 站点(Station)1.5 货物(Goods)1.6 系统资源(SystemResource)1.7 物流系统(LogisticsSystem)2 算法思路2.1 初赛初版：路由表、深度优先搜索、路径惩罚2.1.1 搜索策略2.1.2 路径惩罚策略2.1.3 货物发送策略2.1.4 效果与问题2.1.5 转向新的思路2.2 初赛终版：多条路径的宽度优先搜索、货物组包、路径统合2.2.1 搜索策略
2020中兴捧月算法赛道傅里叶派赛题菜鸡回顾
callmedapeng的博客
05-10 3328
最近抱着试水的心理参加了2020中兴捧月算法大赛傅里叶派赛题。从4.19号由旁观者转变为参赛者，到5.8号提交完成最后的文档和代码，前后算起来也有20天了。虽然自己比较菜，但毕竟是第一次参加这种比较正式的程序算法类竞赛，自己也学到了一些东西，所以还是写点东西纪念一下吧，留待日后回首。当然这也是第一次在CSDN写博客，一下解锁两个第一次，想想心里也是有点小激动。 2020中兴捧月算法赛道傅里叶派赛题菜鸡回顾0.原始赛题描述1.赛题分析与算法建立1.1问题重述1.2问题抽象1.3算法建立2.程序源码3.参考博客
2020中兴捧月算法大赛——傅里叶赛道 第1名方案
weixin_45624843的博客
05-02 1579
大家好，我是轶扬。 最近我在总结研究生阶段参与的一些项目和比赛，翻到了2020年参加的中兴捧月算法大赛，题目很有意思，解法上也有一些有趣的创新，所以拿出来特别记录一下。 中兴捧月算法大赛是中兴通讯公司主办的算法赛事，每年都会根据当下热点设置多个赛道，包括图像、音频、通信和数据库等。由于我是通信背景出身，所以我在2020年参加了中兴捧月的“傅里叶”赛道，这个赛道的题目有一种大家很容易想到的解法，因此有很多非通信专业的同学参与进来，人数达到了一千多名，是当年5个赛道之最。我最终凭借算法效率的巨大优势（程度运行.
mowangyuyan.rar_doc_魔王语言_魔王语言解释
09-22
《魔王语言：解析与应用》 在信息技术领域，编程语言是构建软件系统的基础，而“魔王语言”（Mowangyuyan）则是一种非主流的、独特的小众编程语言。这种语言以其特殊的语法和表达方式，吸引了一部分对编程有独特...
mowangyuyan.rar_翻译_魔王语言_魔王语言翻译
09-22
在这个项目中，我们关注的是如何编写一个程序，可以将普通语言转换成所谓的“魔王语言”。 在编程中，实现这种翻译功能通常涉及到字符串处理和算法设计。我们可以使用C语言，正如压缩包中的"魔王语言.c"源代码文件...
mowangyuyan.rar_魔王语言
09-23
魔王语言的文档“魔王语言.doc”很可能是实验的指导手册，里面可能包含了语言的设计理念、语法特点、示例代码以及相关的练习题。学习者可以通过阅读这份文档，了解如何使用魔王语言编写程序，以及如何利用数据结构...
中兴通讯公司 中兴捧月试题
06-16
这个是中兴捧月两届的试题集，第三节中兴捧月大赛即将开始，希望对大家有帮助。
第二届“中兴捧月”杯校园程序设计大赛初赛题目
05-12
第二届“中兴捧月”杯校园程序设计大赛现已全面拉开序幕，软硬件方面都有，题目有一定难度也很有新意。
ZTE2017算法大赛傅里叶题目及作品
09-14
ZTE2017中兴捧月算法大赛傅里叶题目及作品。资源内包含ZTE2017中兴捧月算法大赛傅里叶题目和作品。
中兴捧月杯程序设计大赛往届题目
06-05
中兴捧月杯程序设计大赛往届题目，这是往届的题目，希望对大家有参考作用
苏小红-C语言程序设计-资料包
10-13
苏小红-C语言程序设计-资料包，包含13章PPT，第二章到第十三章代码
2017年中兴捧月神算师算法精英挑战赛之阿尔法勒克斯特派（AlphaNext派）-----进来加群咯
菲菲家的吴先森
04-20 4753
所属门派： 阿尔法勒克斯特派（AlphaNext派） 门派技能： 图像处理与模式识别 门派描述： 图像处理，感知智能，让机器更加智能。 门派升级任务： 魔高一尺，道高一丈     阿尔法勒克斯特派初赛赛题 机器智能化一直是图灵先生孜孜追求的目标，欣慰的是，图灵先生已经看到了AlphaGo战胜了众多围棋高手；一些特定场景下，图像和视频分析技术也已经成功应用于工业生产和人们生活之中...
2021中兴捧月杯算法大赛&模面大赛总结
lin0cp的博客
07-11 3075
一、2021中兴捧月杯算法赛 本次比赛我参加的是迪杰斯特拉门派，题目是人口流量预测。最终成绩：西北区域优胜奖，38/500，初赛全国前50可进入复赛，获得区域优胜，然后组织面试，根据面试结果，大概15人左右可进入全国总决赛。总体来说，中兴算法赛的难度不是很大（但想做得好冲击国奖还是很有难度），且可获得很多招聘机会，非常推荐大家参加。 初赛一阶段 给定训练数据集（传感器ID，日期，流量），测试数据集（传感器ID，日期(后91天)），完成流量预测任务。 其实这个赛题的难度就在于数据处理方面，有的传感器可能损坏或
中兴捧月杯初赛题目--求网络中两点之间的路径--总结篇
FeelTouch Labs
07-25 3572
中心捧月杯的程序设计部分就这样结束了，在截止时间前我没有提交作品，在此做个总结警醒自己。 一，心理认知 1，尽管我是心理上认真对待了，这次比赛，但是行动上放松了。但我在初赛中选定一个定目后，感觉根据自己的编程能力3天内基本就可以搞定了，所以前期没有做。 2，在截止日期前的三天我全力以赴，果真很见成效，但是毕竟要调试，不懂得地方要去检索，时间很快就过去了 3，大数据和性能优化的问题自己没有关
给我分析下这段java的GC日志是什么意思
06-01
很抱歉，您还是没有提供具体的Java GC日志，无法分析。但是，一般来说，Java GC日志的格式大致如下： ``` 2021-04-15T09:12:38.156+0800: 123.456: [GC (Allocation Failure) 123.456: [ParNew: 31456K->3584K...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

思禾

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值