牛客竞赛数据结构专题班树状数组、线段树练习题

已于 2024-08-18 22:57:25 修改
阅读量118 收藏 2
点赞数 3
分类专栏： # 线段树 文章标签： 数据结构 算法
于 2024-08-18 21:04:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Landing_on_Mars/article/details/141305401
版权

牛客竞赛_ACM/NOI/CSP/CCPC/ICPC算法编程高难度练习赛_牛客竞赛OJ

G 智乃酱的平方数列（线段树，等差数列，多项式）

题目描述
想必你一定会用线段树维护等差数列吧？让我们来看看它的升级版。

请你维护一个长度为5×10 ^5的数组，一开始数组中每个元素都为0，要求支持以下两个操作：

1、区间[l,r]加自然数的平方数组，即al+=1，al+1+=4，al+2+=9，al+3+=16...ar+=(r−l+1)∗(r−l+1)
2、区间[l,r]查询区间和mod 10^9 + 7

输入描述:
第一行输入n,m,(1≤n,m≤5*10 ^5)
接下来m行，对于每行，先读入一个整数q。
当q的值为1时，还需读入两个整l,r,(1≤l≤r≤n)表示需要对区间[l,r]进行操作，让第一个元素加1，第二个元素加4，第三个元素加9...以此类推。
当q的值为2时，还需读入两个整数l,r(1≤l≤r≤n)表示查询l到r的元素和

输出描述:
对于每一个q=2，输出一行一个非负整数，表示l到r的区间和mod 110^9+7。
示例1

输入
复制

4 4
2 1 4
1 1 4
1 3 4
2 1 4
输出
复制

0
35
示例2

输入
复制

10 6
1 1 6
1 8 9
1 3 6
2 1 10
1 1 10
2 1 10
输出
复制

126
511


解析： 

等差数列可以写成 [x-(l-1)]^2,其中 x 表示当前的位置，等价于 x^2-2*x*(l-1)+(l-1)^2，通过线段树维护其系数即可

#include <iostream>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <utility>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <math.h>
#include <map>
#include <sstream>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <stdio.h>
#include <tuple>
using namespace std;
/*
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
*/
typedef long long LL;
#define int long long
#define ld long double
//#define INT __int128
const LL INF = 0x3f3f3f3f3f3f3f3f;
typedef unsigned long long ULL;
typedef pair<long long, long long> PLL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int inf = 0x3f3f3f3f;
const LL mod = 1e9+7;
const ld eps = 1e-12;
const int N = 5e5 + 10, M = N + 10;
int n, m;
struct TREE {
	int l, r;
	int la1, la2, la3;
	int sum;
	int base1, base2;
}tr[N << 2];
#define ls u<<1
#define rs u<<1|1
void cal(int u, int la1, int la2, int la3) {
	la3 %= mod;
	int len = tr[u].r - tr[u].l + 1;
	tr[u].sum = (tr[u].sum + len * la3 % mod) % mod;
	tr[u].sum = (tr[u].sum - 2 * tr[u].base2 * la2 % mod + mod) % mod;
	tr[u].sum = (tr[u].sum + tr[u].base1 * la1 % mod) % mod;
	tr[u].la1 = (tr[u].la1 + la1) % mod;
	tr[u].la2 = (tr[u].la2 + la2) % mod;
	tr[u].la3 = (tr[u].la3 + la3) % mod;
}
void up(int u) {
	tr[u].sum = (tr[ls].sum + tr[rs].sum) % mod;
}
void down(int u) {
	if (tr[u].la1||tr[u].la2||tr[u].la3) {
		cal(ls, tr[u].la1, tr[u].la2, tr[u].la3);
		cal(rs, tr[u].la1, tr[u].la2, tr[u].la3);
		tr[u].la1 = tr[u].la2 = tr[u].la3 = 0;
	}
}
void build(int u, int l, int r) {
	tr[u].l = l, tr[u].r = r;
	if (l == r) {
		tr[u].base1 = (l * l) % mod , tr[u].base2 = l;
		return;
	}
	int mid = (l + r) >> 1;
	build(ls, l, mid), build(rs, mid + 1, r);
	tr[u].base1 = (tr[ls].base1 + tr[rs].base1) % mod;
	tr[u].base2 = (tr[ls].base2 + tr[rs].base2) % mod;
}
void modify(int u, int l, int r, int d) {
	if (l <= tr[u].l && tr[u].r <= r) {
		cal(u, 1, d, d * d);
		return;
	}
	down(u);
	int mid = (tr[u].l + tr[u].r) >> 1;
	if (l <= mid)modify(ls, l, r, d);
	if (r > mid)modify(rs, l, r, d);
	up(u);
}
int query(int u, int l, int r) {
	if (l <= tr[u].l && tr[u].r <= r) {
		return tr[u].sum;
	}
	down(u);
	int ret = 0;
	int mid = (tr[u].l + tr[u].r) >> 1;
	if (l <= mid)ret = (ret + query(ls, l, r)) % mod;
	if (r > mid)ret = (ret + query(rs, l, r)) % mod;
	//up(u);
	return ret;
}
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	cin >> n >> m;
	build(1, 1, n);
	int op, l, r;
	while (m--) {
		cin >> op >> l >> r;
		if (op == 1) {
			modify(1, l, r, l - 1);
		}
		else {
			cout << query(1, l, r) << endl;
		}
	}
	return 0;
}
/*
4 5
2 1 4
1 1 4
2 1 4
1 3 4
2 1 4
4 5
2 1 4
1 3 4
2 1 4
1 1 4
2 1 4
*/

K    智乃酱的双塔问题·改（线段树，dp，矩阵连乘)

解析：

不能发现这个问题如果不带修改则可以用 dp+前缀和（矩阵乘法）解决，带修改则可以用线段树维护区间和。

令 f[i][0/1] 表示从第 1 层的左边（0）或右边（1）到第 i 层的左边（0）或右边（1）的方案数

我们可以将每一层的转移状态用矩阵表示，

#include <iostream>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <utility>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <math.h>
#include <map>
#include <sstream>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <stdio.h>
#include <tuple>
using namespace std;
/*
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
*/
typedef long long LL;
//#define int long long
#define ld long double
//#define INT __int128
const LL INF = 0x3f3f3f3f3f3f3f3f;
typedef unsigned long long ULL;
typedef pair<long long, long long> PLL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int inf = 0x3f3f3f3f;
const LL mod = 1e9 + 7;
const ld eps = 1e-12;
const int N = 2e5 + 10, M = N + 10;
int n, m;
char s[N];
struct MATRIX {
	LL a[2][2];
	void init(int b1,int b2,int b3,int b4) {
		a[0][0] = b1, a[0][1] = b2;
		a[1][0] = b3, a[1][1] = b4;
	}
	MATRIX operator*(MATRIX oth) {
		MATRIX ret;
		ret.init(0, 0, 0, 0);
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 2; j++) {
				for (int k = 0; k < 2; k++) {
					(ret.a[i][j] += a[i][k] * oth.a[k][j] % mod) %= mod;
				}
			}
		}
		return ret;
	}
};

struct TREE {
	int l, r;
	MATRIX ma;
}tr[N << 2];
#define ls u<<1
#define rs u<<1|1
void up(int u) {
	tr[u].ma = tr[ls].ma * tr[rs].ma;
}
void build(int u, int l, int r) {
	tr[u].l = l, tr[u].r = r;
	if (l == r) {
		tr[u].ma.init(1, s[l] == '/', s[l] != '/', 1);
		return;
	}
	int mid = l + r >> 1;
	build(ls, l, mid), build(rs, mid + 1, r);
	up(u);
}
void modify(int u, int pos, char ch) {
	if (tr[u].l == tr[u].r) {
		tr[u].ma.init(1, ch == '/', ch != '/', 1);
		return;
	}
	int mid = tr[u].l + tr[u].r >> 1;
	if (pos <= mid)modify(ls, pos, ch);
	if (pos > mid)modify(rs, pos, ch);
	up(u);
}
MATRIX query(int u, int l, int r) {
	if (l <= tr[u].l && tr[u].r <= r) {
		return tr[u].ma;
	}
	int mid = tr[u].l + tr[u].r >> 1;
	MATRIX ret;
	ret.init(1, 0, 0, 1);
	if (l <= mid)ret = (ret * query(ls, l, r));
	if (r > mid)ret = (ret * query(rs, l, r));
	return ret;
}
signed main() {
	cin >> n >> m;
	scanf("%s", s + 1);
	build(1, 1, n - 1);
	int op, ht, hs, h;
	for (int i = 1; i <= m; i++) {
		scanf("%d", &op);
		if (op == 0) {
			char c[2];
			scanf("%d%s",&h, c);
			modify(1, h,c[0]);
		}
		else {
			int ps, pt;
			scanf("%d%d%d%d",&hs,&ht, &ps, &pt);
			auto ret = query(1, hs, ht - 1);
			/*cout << "__________________" << endl;
			for (int i = 0; i < 2; i++) {
				cout << ret.a[i][0] << " " << ret.a[i][1] << endl;
			}
			cout << endl;*/
			LL ans = ret.a[ps][pt];
			printf("%lld\n", ans);
		}
	}
	return 0;
}

J    智乃酱的双塔问题·极（带修改的DP，DDP）

这题思路与上题一样，只不过将矩阵的乘法运算换成 floyd 算法，矩阵的含义变为图的邻接矩阵。（可以变的主要原因是因为 floyd 算法的运算形式与矩阵连乘的形式很相似）

#include <iostream>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <utility>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <math.h>
#include <map>
#include <sstream>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <stdio.h>
#include <tuple>
using namespace std;
/*
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
*/
typedef long long LL;
//#define int long long
#define ld long double
//#define INT __int128
const LL INF = 0x3f3f3f3f3f3f3f3f;
typedef unsigned long long ULL;
typedef pair<long long, long long> PLL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int inf = 0x3f3f3f3f;
const LL mod = 1e9 + 7;
const ld eps = 1e-12;
const int N = 1e5 + 10, M = N + 10;
int n, m;
int val[N][3];
char s[N];
#define inf INF
struct MATRIX {
	LL a[2][2];
	void init(LL b1, LL b2, LL b3, LL b4) {
		a[0][0] = b1, a[0][1] = b2;
		a[1][0] = b3, a[1][1] = b4;
	}
	MATRIX operator*(MATRIX oth) {
		MATRIX ret;
		ret.init(inf, inf, inf, inf);
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 2; j++) {
				for (int k = 0; k < 2; k++) {
					//(ret.a[i][j] += a[i][k] * oth.a[k][j] % mod) %= mod;
					if (a[i][k] == inf || oth.a[k][j] == inf)continue;
					ret.a[i][j] = min(ret.a[i][j], (a[i][k] + oth.a[k][j]));
				}
			}
		}
		return ret;
	}
};

struct TREE {
	int l, r;
	MATRIX ma;
}tr[N << 2];
#define ls u<<1
#define rs u<<1|1
void up(int u) {
	tr[u].ma = tr[ls].ma * tr[rs].ma;
}
void build(int u, int l, int r) {
	tr[u].l = l, tr[u].r = r;
	if (l == r) {
		if (s[l] == '/')
			tr[u].ma.init(val[l][0], val[l][2], inf, val[l][1]);
		else tr[u].ma.init(val[l][0], inf, val[l][2], val[l][1]);
		return;
	}
	int mid = l + r >> 1;
	build(ls, l, mid), build(rs, mid + 1, r);
	up(u);
}
void modify(int u, int pos, char ch, int val1, int val2, int val3) {
	if (tr[u].l == tr[u].r) {
		if (ch == '/')
			tr[u].ma.init(val1, val3, inf, val2);
		else tr[u].ma.init(val1, inf, val3, val2);
		return;
	}
	int mid = tr[u].l + tr[u].r >> 1;
	if (pos <= mid)modify(ls, pos, ch, val1, val2, val3);
	if (pos > mid)modify(rs, pos, ch, val1, val2, val3);
	up(u);
}
MATRIX query(int u, int l, int r) {
	if (l <= tr[u].l && tr[u].r <= r) {
		return tr[u].ma;
	}
	int mid = tr[u].l + tr[u].r >> 1;
	MATRIX ret;
	ret.init(0, inf, inf, 0);
	if (l <= mid)ret = ret * query(ls, l, r);
	if (r > mid)ret = ret * query(rs, l, r);
	return ret;
}
signed main() {
	cin >> n >> m;
	scanf("%s", s + 1);
	for (int i = 1; i < n; i++) {
		scanf("%d%d%d", &val[i][0], &val[i][1], &val[i][2]);
	}
	build(1, 1, n - 1);
	int op, ht, hs, h;
	for (int i = 1; i <= m; i++) {
		scanf("%d", &op);
		if (op == 0) {
			char c[2];
			scanf("%d%s", &h, c);
			//cout << "______" << c[0] << endl;
			s[h] = c[0];
			modify(1, h, c[0], val[h][0], val[h][1], val[h][2]);
		}
		else if (op == 1) {
			int val1, val2, val3;
			scanf("%d%d%d%d", &h, &val1, &val2, &val3);
			val[h][0] = val1, val[h][1] = val2, val[h][2] = val3;
			modify(1, h, s[h], val1, val2, val3);
		}
		else {
			int ps, pt;
			scanf("%d%d%d%d", &hs, &ht, &ps, &pt);
			auto ret = query(1, hs, ht - 1);
			/*cout << "__________________" << endl;
			for (int i = 0; i < 2; i++) {
				cout << ret.a[i][0] << " " << ret.a[i][1] << endl;
			}
			cout << endl;*/
			LL ans = ret.a[ps][pt];
			if (ans == inf) {
				printf("-1\n");
			}
			else
				printf("%lld\n", ans);
		}
	}
	return 0;
}

/*
4 13
///
1 2 1
2 3 5
8 8 1
2 1 4 1 0
2 1 2 1 0
2 2 3 1 0
2 3 4 1 0
0 3 \
2 1 4 0 0
2 2 4 0 0
2 2 4 0 1
2 3 4 0 1
2 3 4 1 0
1 1 1 1 1
1 2 1 1 1
1 3 1 1 1
2 1 4 1 0
0 3 /
2 1 4 1 0


4 13
///
1 2 1
2 3 5
8 8 1
2 1 4 1 0
0 3 \
2 1 4 0 0
2 2 4 0 0
2 2 4 0 1
2 3 4 0 1
2 3 4 1 0
1 1 1 1 1
1 2 1 1 1
1 3 1 1 1
2 1 4 1 0
0 3 /
2 1 4 1 0
*/

Landing_on_Mars
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客练习赛34 F little w and Discretization (线段树 + 树状数组 + 离线)
purple_bro的博客
12-15 414
题目链接 题意： 给你 nnn 个数，mmm 个操作，每个操作是对区间 [Li,Ri][L_i,R_i][Li​,Ri​] 进行离散化，求这个区间离散化前和离散化后相同位置元素的值不一样的个数，每一个操作都是独立的。 解题思路： 这里是按照题解的写法，每一个离散化的操作可以看成是一个区间求 mexmexmex 的操作，得到区间的 mexmexmex 之后，在询问这个区间比 mexmexmex ...
python 数据结构 算法 LeetCode 牛客 面试 编程之美 动态规划 字典树 快速排序 树 字符串 数组 链表 全排列
10-08
树 * 字典树 * 遍历-层次遍历 * 遍历-中序遍历-非递归 * 遍历-前序遍历-非递归 * 遍历-后序遍历-非递归 * 二叉查找树-两数之和 * 二叉查找树-中第K小的元素 * 二叉查找树-从有序数组中构造二叉查找树 * 二叉查找树-...
牛客竞赛数据结构专题班 线段树练习题
cosx_的博客
10-05 357
牛客竞赛数据结构专题班树状数组、线段树练习题 zngg的专题题解 树状数组单开一个博客 [NOIP2012]借教室 二分题解 二分答案，用差分+前缀和check 题意： mmm 次操作，每次区间 −d-d−d 每次操作前判断最小值是否 >=d>=d>=d 区间修改，维护区间最小值 code： #include <bits/stdc++.h> using namespace std; typedef long long ll; const int MAXN = 1e6 + 5;
数据结构专题——树状数组、线段树练习题
愿历尽千帆，归来仍少年
09-22 577
数据结构之线段树、树状数组
数据结构 【树状数组】【线段树】【珂朵莉树】
qq_33969563的博客
11-11 434
数据结构 树状数组，线段树，珂朵莉树
b+树时间复杂度_前端大神用的学习笔记：线段树和树状数组
weixin_39808893的博客
11-20 512
全文篇幅较长，细心理解一定会有收获的♪(^∇^*)。1|0线段树1|1一些概念    线段树是一种二叉搜索树，每一个结点都是一个区间(也可以叫作线段，可以有单点的叶子结点)，有一张比较形象的图如下(侵删)：    可以看出，线段树除根结点外的其他节点，都由其父节点二分长度得到，这种优秀的性质使得我们可以把它近似看成是一棵完全二叉树。而完全二叉树可以用一个数组表示：设根节点下标为 nownow (在...
一些线段树、树状数组的题单。
qq_53398102的博客
07-20 50
线段树、树状数组题单
入门线段树和树状数组
ailanxier的博客
08-02 248
    学习了一周的线段树和树状数组，深深地体会到了这每种操作几乎都是 O(logN)O(logN)O(logN) 级别的数据结构的美，但是做起题来还是相当痛苦的（特别是一开始只会模板的时候，很难灵活运用线段树的性质）。还好有雨巨大神带入门，视频讲解十分直观（b站上也有很多介绍线段树的视频），不用像以前一样看各种博客题解入门。但是我现在就是在写博客了，希望能尽可能将我目前理解的知识整理出来，毕竟能让别人看懂（网上已经这么多关于线段树和树状数组的文章你还能找到我，相信我，你没选错），才说明自己也是真的懂了(虽
ACM 线段树，树状数组入门题（附代码解释）
不二君
08-15 444
如果是初学者建议先看看这篇博客，写的很不错传送门 目录 HDU 1166 敌兵布阵（线段树） HDU 1698 Just a Hook（线段树） POJ 3468 A Simple Problem with Integers（线段树区间修改+求和） HDU 1540 Tunnel Warfare（最长连续区间+单点修改） 洛谷 P3372 【模板】线段树 1 洛谷 P3373 【模板...
牛客练习赛4 C-Sum 线段树+二进制拆分
狙击美佐的博客
04-11 130
牛客练习赛4 C-Sum 线段树+二进制拆分题意思路Code 传送门：https://ac.nowcoder.com/acm/contest/16/C 题意 给你n个数A1...An，m个操作。给你n个数A_1...A_n，m个操作。给你n个数A1​...An​，m个操作。 操作分两种：操作分两种：操作分两种： 操作一：1  x  y，将Ax改成y操作一：1\;x\;y，将A_x改成y操作一：1xy，将Ax​改成y 操作二：2  l  r，求[Al...Ar]所有子集的&并mod  1e9+7操作
python 数据结构 算法 LeetCode 牛客 面试 编程之美 动态规划 字典树等等
12-27
常见的数据结构包括数组、链表、栈、队列、哈希表、树（如二叉树、AVL树、B树）、图等。在Python中，内置的`list`、`dict`、`set`等都是常用的数据结构，而自定义数据结构则能帮助我们优化特定问题的解决方案。 2. ...
python 数据结构 算法 LeetCode 牛客 面试
06-17
5. 树结构：Python可以使用嵌套列表或类来表示树，处理二叉树、平衡二叉树、堆树等数据结构的问题。 6. 回溯和剪枝：Python的递归特性使得回溯法在解决棋盘游戏、组合问题（如N皇后问题）等方面非常方便。 总之，...
一个Codeforces、牛客竞赛、AtCoder平台的编程竞赛查询插件，ACMer必备.zip
10-23
一个Codeforces、牛客竞赛、AtCoder平台的编程竞赛查询插件，ACMer必备.zip
【数据结构-前缀哈希】力扣1124. 表现良好的最长时间段
sjsjs11的博客
08-14 368
表现良好的时间段”有两种情况，一种是当前的sum能在哈希表中匹配到sum - 1时（如果是匹配sum的话，这个子段是「劳累的天数」等于「不劳累的天数」。这一题前缀+哈希并不是空间最优，最优空间是使用贪心+栈的做法，虽然空间复杂度都是O(n)，但是实际的空间使用可能高于 O(n)，因为当哈希表需要扩展时，会预留更多的空间以减少哈希冲突。所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。输入：hours = [9,9,6,0,6,6,9]
Immutable-持久化数据结构：助力 React 性能提升
李刚的学习专栏
08-14 884
如果组件的属性和状态是不可变的数据结构，可以显著简化Diff算法的复杂性： 引用比较：每次更新都会产生一个完全新的对象，而不是修改原有对象，React可以简单地通过比较对象的引用，来确定数据是否发生了变化。如果两个对象的引用不同，那么肯定不同，这比深度比较数据结构的每个部分要快得多； 结构共享：Immutable数据结构在进行更新时，只创建变动部分的新实例，而保留未变部分的引用。这意味着在Diff算法中，React能够迅速识别出哪些部分是完全相同的，从而跳过这些部分的比较，直接关注那些确实发生了变化的部分。
C语言实现排序之快速排序算法
2403_83044722的博客
08-14 395
快速排序（Quick Sort）是一种非常高效且实用的排序算法，它采用分治法（Divide and Conquer）的思想来完成排序。
单调队列《滑动窗口》
2402_82371019的博客
08-13 661
/ i = 6: a[i] = 6，将队列尾的元素（索引 5）移除，因为 a[5] < 6。// i = 2: a[i] = -1，将队列尾的元素（索引 1）移除，因为 a[1] >= -1。// i = 3: a[i] = -3，将队列尾的元素（索引 2）移除，因为 a[2] >= -3。队列 [3, 4, 5]。// i = 4: a[i] = 5，将队列尾的元素（索引 3）移除，因为 a[3] < 5。// i = 1: a[i] = 3，将队列尾的元素（索引 0）移除，因为 a[0] < 3。
二叉树详解（1）
最新发布
weixin_73077334的博客
08-15 1170
二叉树详解（1）
牛客竞赛算法入门班怎么样
01-14
牛客竞赛算法入门班是一个针对算法竞赛初学者的培训班。它提供了系统的课程和习题，帮助学员掌握算法竞赛中常用的算法和数据结构，并提高解题能力。通过参加这个培训班，学员可以学到以下内容： 1. 算法基础知识：包括时间复杂度、空间复杂度、递归、排序算法等。 2. 数据结构：包括数组、链表、栈、队列、树、图等。 3. 常用算法：包括贪心算法、动态规划、回溯算法、分治算法等。 4. 算法竞赛技巧：包括如何优化算法、如何处理特殊情况、如何设计算法等。 5. 实战习题：提供大量的算法竞赛习题，帮助学员巩固所学知识并提高解题能力。 通过参加牛客竞赛算法入门班，学员可以系统地学习算法竞赛的基础知识和技巧，提高解题能力，并为参加算法竞赛打下坚实的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值