2016 UESTC Training for Data Structures P - 浑身难受 CDOJ 1276 树状数组

最新推荐文章于 2017-07-03 19:59:41 发布
最新推荐文章于 2017-07-03 19:59:41 发布
阅读量327 收藏
点赞数
分类专栏： 数据结构 CDOJ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/code12hour/article/details/51290410
版权

P - 浑身难受

maya，camp上搬来的神题，作为一名智障

一共二十四种情况，然后每种倒序一下可以得到另外一种，所以可以简化成12种，然后我这个智障就写了十二种，

首先分为3类，

1，  1和4不相连，就n^2枚举2和3的位置，然后1和4的所在的区间用按值树状数组维护，1那里就是查询区间有多少比个比2小的值，4那里就是查询有多少个比3大的值（总点数减去<=3的就是啦），然后乘一下就可以

2，  1，3不相连，就n^2枚举2和4的位置，然后1和3的所在的区间用按值树状数组维护，1那里就是查询区间有多少比个比2小的值，3那里就是查询有多少个比4小的减去有多少个比3小的，然后乘一下就可以

3，  2，4不连在一起，把序列翻转一下，就是A[i]=5-A[i]，p[i]=N+1-p[i]，翻转完之后就是1和3不连在一起，然后就可以用2来做了

 

4，  2413，这种题解写的是2413=24xx-2411-2433-2431，一开始没想明白，然后我就枚举3和4做的，然后2和1那里就分别统计比3小的有多少个，因为两数不可能相等，所以要么就是1423，要么就是2413，然后算出来之后，减去1423，就是2413的个数

后来想明白了题解的做法，主要题解提到了2433和2411，一开始以为是0，后来发现不是0，33表示两个数都在2和4之间，11表示两个数都比2小

具体做法就是枚举2和4的位置，固定2和4之后，要枚举1和3，因为只知道1和3都比4小，然后分为三种情况 （实际上是4种）

1，枚举的两个数都比2小，这个你是能算出来的，相当于2411

2，枚举的两个数都在2和4之间，这个也是能算出来的，相当于2433

3，枚举的两个数，一个比2小，一个在2和4之间，这个相当于是2413+2431

所以2413=24xx-2411-2433-2431

 

这题，真是做的浑身难受，300行代码怼过去了


代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define ll long long
#define maxn 2005
int N, A[4], p[maxn];
int BIT1[maxn], BIT2[maxn];
ll query(int tree[], int i)
{
	ll sum = 0;
	while (i)
	{
		sum += tree[i];
		i -= i&(-i);
	}
	return sum;
}
void update(int tree[], int i, int val)
{
	if (i == 0)
		return;
	while (i <= N)
	{
		tree[i] += val;
		i += i&(-i);
	}
}
ll No1234()//枚举23位置
{
	ll sum = 0;
	for (int i = 2; i <= N - 2; ++i)//i是2，j是3
	{
		update(BIT1, p[i - 1], 1);
		memset(BIT2, 0, sizeof(int)*maxn);
		for (int j = N - 1; j >= i + 1; --j)
		{
			update(BIT2, p[j + 1], 1);
			if (p[i] < p[j])
				sum += query(BIT1, p[i])*(N - j - query(BIT2, p[j]));
		}
	}
	return sum;
}
ll No1243()//枚举23位置
{
	ll sum = 0;
	for (int i = 2; i <= N - 2; ++i)//i是2，j是3
	{
		update(BIT1, p[i - 1], 1);
		memset(BIT2, 0, sizeof(int)*maxn);
		for (int j = i + 2; j <= N; ++j)
		{
			update(BIT2, p[j - 1], 1);
			if (p[i] < p[j])
				sum += query(BIT1, p[i])*(j - i - 1 - query(BIT2, p[j]));
		}
	}
	return sum;
}
ll No1324()//枚举23位置
{
	ll sum = 0;
	for (int i = 2; i <= N - 2; ++i)//i是3，j是2
	{
		update(BIT1, p[i - 1], 1);
		memset(BIT2, 0, sizeof(int)*maxn);
		for (int j = N - 1; j >= i + 1; --j)
		{
			update(BIT2, p[j + 1], 1);
			if (p[i] > p[j])
				sum += (N - j - query(BIT2, p[i]))*query(BIT1, p[j]);
		}
	}
	return sum;
}
ll No1342()//枚举23位置
{
	ll sum = 0;
	for (int i = 2; i <= N - 2; ++i)//i是3，j是2
	{
		update(BIT1, p[i - 1], 1);
		memset(BIT2, 0, sizeof(int)*maxn);
		for (int j = i + 2; j <= N; ++j)
		{
			update(BIT2, p[j - 1], 1);
			if (p[i] > p[j])
				sum += query(BIT1, p[j])*(j - i - 1 - query(BIT2, p[i]));
		}
	}
	return sum;
}
ll No1423()//枚举24位置
{
	ll sum = 0;
	for (int i = 2; i <= N - 2; ++i)//i是4，j是2
	{
		update(BIT1, p[i - 1], 1);
		memset(BIT2, 0, sizeof(int)*maxn);
		for (int j = N - 1; j >= i + 1; --j)
		{
			update(BIT2, p[j + 1], 1);
			if (p[i] > p[j])
				sum += query(BIT1, p[j])*(query(BIT2, p[i]) - query(BIT2, p[j]));
		}
	}
	return sum;
}
ll No1432()//枚举24位置
{
	ll sum = 0;
	for (int i = 2; i <= N - 2; ++i)//i是4，j是2
	{
		update(BIT1, p[i - 1], 1);
		memset(BIT2, 0, sizeof(int)*maxn);
		for (int j = i + 2; j <= N; ++j)
		{
			update(BIT2, p[j - 1], 1);
			if (p[i] > p[j])
			{
				sum += query(BIT1, p[j])*(query(BIT2, p[i]) - query(BIT2, p[j]));
			}
		}
	}
	return sum;
}
ll No2134()//枚举23位置
{
	ll sum = 0;
	for (int i = N - 1; i >= 3; --i)//i是3，j是2
	{
		update(BIT1, p[i + 1], 1);
		memset(BIT2, 0, sizeof(int)*maxn);
		for (int j = i - 2; j >= 1; --j)
		{
			update(BIT2, p[j + 1], 1);
			if (p[i] > p[j])
				sum += (N - i - query(BIT1, p[i]))*query(BIT2, p[j]);
		}
	}
	return sum;
}
ll No2143()//枚举24位置
{
	ll sum = 0;
	for (int i = N - 1; i >= 3; --i)//i是4，j是2
	{
		update(BIT1, p[i + 1], 1);
		memset(BIT2, 0, sizeof(int)*maxn);
		for (int j = i - 2; j >= 1; --j)
		{
			update(BIT2, p[j + 1], 1);
			if (p[i] > p[j])
				sum += (query(BIT1, p[i]) - query(BIT1, p[j])) * query(BIT2, p[j]);
		}
	}
	return sum;
}
ll No2314()//先翻转，再枚举24位置
{
	//翻转后是3241，再倒序一下，是1423
	ll sum = 0;
	for (int i = 1; i <= N; ++i)
		p[i] = N + 1 - p[i];
	for (int i = 1; i <= N / 2; ++i)
	{
		int t;
		t = p[i];
		p[i] = p[N + 1 - i];
		p[N + 1 - i] = t;
	}
	sum = No1423();
	return sum;
}
ll No2413()//暴力枚举3和4，树状数组维护1和2的数，x4x3-1423=2413
{
	ll sum = 0;
	for (int i = 2; i <= N - 2; ++i)//i是4，j是3
	{
		update(BIT1, p[i - 1], 1);
		memset(BIT2, 0, sizeof(int)*maxn);
		for (int j = i + 2; j <= N; ++j)
		{
			update(BIT2, p[j - 1], 1);
			if (p[i] > p[j])
			{
				sum += query(BIT1, p[j])*query(BIT2, p[j]);
			}
		}
	}
	memset(BIT1, 0, sizeof(int)*maxn);
	memset(BIT2, 0, sizeof(int)*maxn);
	sum -= No1423();
	return sum;
}
ll No3124()//枚举2和3的位置
{
	ll sum = 0;
	for (int i = N - 1; i >= 3; --i)//i是2，j是3
	{
		update(BIT1, p[i + 1], 1);
		memset(BIT2, 0, sizeof(int)*maxn);
		for (int j = i - 2; j >= 1; --j)
		{
			update(BIT2, p[j + 1], 1);
			if (p[j] > p[i])
				sum += (N - i - query(BIT1, p[j]))*query(BIT2, p[i]);
		}
	}
	return sum;
}
ll No3214()//枚举2和4的位置
{
	ll sum = 0;
	for (int i = 2; i <= N - 2; ++i)//i是2，j是4
	{
		update(BIT1, p[i - 1], 1);
		memset(BIT2, 0, sizeof(int)*maxn);
		for (int j = i + 2; j <= N; ++j)
		{
			update(BIT2, p[j - 1], 1);
			if (p[i] < p[j])
				sum += (query(BIT1, p[j]) - query(BIT1, p[i]))*query(BIT2, p[i]);
		}
	}
	return sum;
}
void deal_A()
{
	int x = A[0] * 1000 + A[1] * 100 + A[2] * 10 + A[3];
	if (x == 2341 || x == 2431 || x == 3142 || x == 3241 || x == 3412 || x == 3421 || x == 4123 || x == 4132 || x == 4213 || x == 4231 || x == 4312 || x == 4321)
	{
		int t;
		t = A[0];
		A[0] = A[3];
		A[3] = t;
		t = A[1];
		A[1] = A[2];
		A[2] = t;
		for (int i = 1; i <= N / 2; ++i)
		{
			t = p[i];
			p[i] = p[N + 1 - i];
			p[N + 1 - i] = t;
		}
	}
}
ll compute()
{
	int x = A[0] * 1000 + A[1] * 100 + A[2] * 10 + A[3];
	if (x == 1234)
		return No1234();
	if (x == 1243)
		return No1243();
	if (x == 1324)
		return No1324();
	if (x == 1342)
		return No1342();
	if (x == 1423)
		return No1423();
	if (x == 1432)
		return No1432();
	if (x == 2134)
		return No2134();
	if (x == 2143)
		return No2143();
	if (x == 2314)
		return No2314();
	if (x == 2413)
		return No2413();
	if (x == 3124)
		return No3124();
	if (x == 3214)
		return No3214();
	return -1;
}
int main()
{
	//freopen("input.txt", "r", stdin);
	scanf("%d", &N);
	for (int i = 0; i < 4; ++i)
		scanf("%d", &A[i]);
	for (int i = 1; i <= N; ++i)
		scanf("%d", &p[i]);
	if (N < 4)
		printf("0\n");
	else
	{
		deal_A();
		ll ans = compute();
		printf("%lld\n", ans);
	}
	//system("pause");
	//while (1);
	return 0;
}

sky-edge
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2016 UESTC Training for Data Structures O - 卿学姐种美丽的花 CDOJ 1344 线段树/树状数组
一蓑烟雨任平生
05-01 676
O - 卿学姐种美丽的花 给一个区间，等差数列更新，单点查询 我们可以开一个线段树记录这个点被更新的次数，然后因为是区间更新，所以我们需要一个lazy，lazy表示这个区间的被更新的数列的首项是多少，还有一个cnt，表示公差，因为两个数列加和到一起时，公差也会相加，所以就是这样了，然后lazy下放的时候，也是计算下两个子区间的首端点的位置是多少，相当于把这个数列分为两个子数列 然后我们就
uestc研究生健康打卡-Python-下载
01-09
标题中的“uestc研究生健康打卡-Python-下载”表明这是一个使用Python编程语言编写的程序，用于自动完成中国电子科技大学（UESTC）研究生的健康打卡任务。这个程序可能旨在帮助学生节省时间，避免手动填写每日健康...
2016 UESTC Training for Data Structures R - Japan CDOJ 383 树状数组 逆序对
一蓑烟雨任平生
05-01 445
R - Japan 坐标有n个城市，右边有m个城市，城市都是按序号排序的，然后有K条连线，然后问连线的交点有多少个 也是类似于逆序数，不过跟E题不同的是不用考虑在左端点或者右端点的交点，只考虑交在中间的，也不用离散化 首先我们把每条线段按左端点升序排序，左端点相同按右端点升序排序 然后因为我们只数交点在中间的，所以我们首先找到同一个左端点的序号范围，假设当前为[i,j)，序号编号是从0开始
2016 UESTC Training for Data Structures K - 郭大侠与甲铁城 CDOJ 1342 离线树状数组
一蓑烟雨任平生
05-01 461
K - 郭大侠与甲铁城 有一个区间，长度1e5，每个点有一种颜色，颜色属于[1,1000]，离线询问某个区间的颜色种树，询问次数也少1e5 我的做法是离线树状数组 首先把区间保存下来，按右端点升序排序，然后我们建树状数组，同时也开一个last数组记录所有颜色的最后的出现位置，初始为0，即没有出现， 然后我们对于每个r，就从1（或上次更新到的位置）更新到这个r，然后我们更新时，对于这个点
2016 UESTC Training for Data Structures E - 卿学姐与城堡的墙 CDOJ 1341 树状数组 逆序对 离散化
一蓑烟雨任平生
05-01 606
E题：卿学姐与城堡的墙 有N条直线，以y=kx+b的形式给出，问有多少种方式任取两个直线，使这两个直线的交点在x=u和x=v之间 对于两个直线a和b，怎么判断他们的交点在x=u和x=v之间呢 假如直线a在x=u时的纵坐标为yau，在x=v时的纵坐标为yav，直线b在x=u时的纵坐标为ybu，在x=v时的纵坐标为ybv。假设yau在ybu的下面，但是yav却在ybv的上面，那中间就是一定有交点
2016 UESTC Training for Data Structures A - 卿学姐与公主 CDOJ 1324 线段树
一蓑烟雨任平生
05-01 615
A题 题意：有一个数列，长度为10^5，初始全为0 要求支持两种操作：单点更新和区间查询最大值 操作次数10^5， 另：答案可能会爆int，所以用long long存   唔，线段树裸题，存的是最大值，所以更新时的push_up是： tr[id].mx=max(tr[lid].mx,tr[rid].mx); 然后就可以了，   坑点就是爆int，咦，对，还有就是更新的时候是加上
CDOJ1583-树状数组 （2017 UESTC Training for Data Structures）
Code-Dreamer的博客
07-02 661
传送门：CDOJ1583 题目大意： 给你两个n个数的排列，问你从第一个排列通过交换相邻的数变为第二个排列的最小步数 题目思路： 因为只能交换相邻的数，所以我们可以贪心想到直接按顺序从左到右将第一个变为第二个， 所一每个数的交换次数为移动到终点位置的距离，这里我们可以很好想到树状数组来处理 我们先求出第一个排列只的数在第二个中的排名数组，然后求排名数组的逆序数对就是答案
2016 UESTC Training for Data Structures L - 郭大侠与苦恼 CDOJ 1284 map+启发式合并
一蓑烟雨任平生
05-01 599
L - 郭大侠与苦恼 题目简单，就是给你一棵树，然后问异或值为0的简单路径有多少条 好难，好麻烦，想了好久才想明白 按dfs的顺序来map+启发式合并， 后来想找个题的大概框架和树形01背包相似，都是用dfs来实现的，只不过树形01背包dfs后的过程是背包的合并，这个是map的合并，还是启发式合并（就是把size小的合并到size大的上）， 然后我们这里维护的是pre[u]，就是从根
2016 UESTC Training for Data Structures F - 郭大侠与“有何贵干？” CDOJ 1335 线段树 扫描线 离散化
一蓑烟雨任平生
05-01 496
F - 郭大侠与“有何贵干？” 就是给一个三维空间，和N个长方体，问覆盖K次的体积 x和y都是1e9，但是z是[1,3]，所以可以把这个分为两个二维平面，求被覆盖K次的面积，最后加一下就行 然后就转换成了二维平面求覆盖k次的面积，k属于[1,10]，然后就是，先离散化，然后线段树+扫描线 具体做法，就是，线段树节点开一个sum[12]的数组，然后i时，sum[i]表示覆盖i次的面积，当
CDOJ1601 - 二维树状数组 （2017 UESTC Training for Data Structures）
Code-Dreamer的博客
07-03 368
传送门：CDOJ1601 题目思路： 题目可以抽象为在一个坐标系中初始时所有点都为0，然后有m次操作，有两种 1，将一个矩形中的所有点都异或1,0变1,1变0， 2，查询一个点的数 题目思路： 这种题可以是一个一维问题扩栈而来，一维就是在x轴上，矩形变成一段区间，对于一维我们只需在 a[l]+1,a[r+1]-1,当查询是质询查询改点左边的前缀和，因为在区间内左边有个
UESTC-综合课程设计III-基于UNIX/Linux的自学系统+源代码+文档说明
01-08
- - 小白不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的课程设计，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ ## 项目备注 1、该资源内项目代码都经过...
UESTC研究生机器学习作业-线性回归，逻辑回归，BP神经网络，SVM，聚类，半监督学习python源码
最新发布
06-27
<项目介绍> -三、线性回归 四、逻辑回归 五、BP神经网络 六、SVM 七、聚类 九、半监督学习- 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩...
UESTC-编译原理-词法分析器-语法分析器.zip
06-02
《UESTC编译原理：词法分析器与语法分析器》 在计算机科学领域，编译原理是理解和构建编译器的关键学科。本资源“UESTC-编译原理-词法分析器-语法分析器.zip”是成都电子科技大学（UESTC）的一份课程设计或课程作业...
UESTC-C++程序课程设计代码-大冒险.zip
06-02
该压缩包文件“UESTC-C++程序课程设计代码-大冒险.zip”主要包含了UESTC（电子科技大学）一门C++程序设计课程的项目代码，项目名为“大冒险”。这个项目可能是学生们在课程中为了实践C++编程技能而完成的一项作业或...
CDOJ 215 吴队长征婚 DFS+剪枝
一蓑烟雨任平生
03-21 6712
吴队长征婚这件事因为请客而没有传出去(虽然他忘了请一个队吃饭)，于是吴队长高兴地玩起了木棒。吴队长拿了一些长度相同的木(guang)棒(gun)，随机的把它们截成了NN段，每一段最长50。现在他想把这些木棒还原成原来的状态，但是他忘记了原来的木棒有多少根，也忘记了每一根有多长。请帮助他设计一个程序，帮他计算之前木棒可能的最小长度。输入数据保证每一段木棒长度都大于0。 输入有多组数据，每组数据分为
CDOJ 1168 凤神与狗（数论_概率）
一蓑烟雨任平生
06-28 1367
D - 凤神与狗 Time Limit: 3000/1000MS (Java/Others)     Memory Limit: 65535/65535KB (Java/Others) 凤神隐居山林，与猫狗为伴。起初，他拥有c只猫和d只狗。每天下午他随机从中选择一只出去游玩并且晚上归来。如果他带的是狗，则第二天早上狗的数量增加w只，否则，猫的数量增加w只。由于凤神特别钟爱狗，某些重要的日子
CDOJ 1059 秋实大哥与小朋友（离散化）
一蓑烟雨任平生
06-22 967
本文部分代码及思路来源于：http://www.cnblogs.com/Xiper/p/4470202.html 秋实大哥与小朋友 Time Limit: 3000/1000MS (Java/Others)     Memory Limit: 65535/65535KB (Java/Others) 秋实大哥以周济天下，锄强扶弱为己任，他常对天长叹：安得广厦千万间，大庇天下寒士
CDOJ 1088 王之迷宫 BFS
一蓑烟雨任平生
06-21 860
Time Limit: 3000/1000MS (Java/Others)     Memory Limit: 65535/65535KB (Java/Others) 王被困在了一个3维的迷宫中，他很想逃离这个迷宫回去当学霸，你能帮助他么? 由于王很仁慈，他悄悄地告诉你，本题读入迷宫的每一行时，要用scanf("%s"...) ...... Input 多组测试数据，对于每组测试数据
完整版代码复现PARAFAC-Based Channel Estimation for Intelligent Reflective Surface Assisted MIMO System
05-30
以下是完整版代码复现PARAFAC-Based Channel Estimation for Intelligent Reflective Surface Assisted MIMO System： ```matlab %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % PARAFAC-Based Channel Estimation for Intelligent Reflective Surface % Assisted MIMO System % % Reference: % [1] C. Huang, Y. Shi, Y. Huang, X. Yu, and Z. Ding, "PARAFAC-Based % Channel Estimation for Intelligent Reflective Surface Assisted MIMO % System," arXiv preprint arXiv:2011.07213, 2020. % % This code is written by Cheng Huang (huangcheng.uestc@hotmail.com). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% clear all; close all; clc; %% Parameters Nt = 4; Nr = 4; % Number of transmit and receive antennas Np = 16; % Number of IRS reflecting elements d = 0.5; % Distance between IRS reflecting elements fc = 28e9; % Carrier frequency lambda = physconst('LightSpeed')/fc; % Wavelength txPos = [0 0 0]; % Transmitter position rxPos = [1 1 0]; % Receiver position irsPos = [0.5 0.5 1]; % IRS position txArray = phased.URA(Nt,[0.5 0.5], 'ElementSpacing', lambda/2); % Transmitter antenna array rxArray = phased.URA(Nr,[0.5 0.5], 'ElementSpacing', lambda/2); % Receiver antenna array irsArray = phased.ConformalArray('ElementPosition', [0 0 0; repmat([d 0 0], Np-1, 1)], ... 'ElementNormal', [0 0 1; repmat([0 0 1], Np-1, 1)], 'Element', phased.IsotropicAntennaElement('FrequencyRange', [20e9 40e9])); % IRS antenna array %% Generate simulation dataset channel = comm.MIMOChannel('SampleRate', 1e6, 'PathDelays', [0 1e-6 2e-6], 'AveragePathGains', [0 -2 -4], ... 'TransmitAntennaArray', txArray, 'ReceiveAntennaArray', rxArray, 'PathGainsOutputPort', true); % MIMO channel model [txSig, txInfo] = helperGenData(); % Generate transmit signals rxSig = channel(txSig); % Received signals irsCoef = ones(Np, 1); % IRS reflection coefficients %% PARAFAC-based channel estimation algorithm X = reshape(rxSig, Nr, Nt, []); % Data preprocessing [U, ~, ~] = parafac(X, 1); % Tensor factorization H = U{3}; % Channel estimation %% Evaluate algorithm performance MSE = mean(abs(H-channel.PathGains).^2); BER = helperComputeBER(H, channel.PathGains); fprintf('MSE = %.4f, BER = %.4f\n', MSE, BER); %% Helper functions function [txSig, txInfo] = helperGenData() % Generate transmit signals txInfo = struct('M', 16, 'NumBits', 1000); % QPSK modulation txSig = randi([0 txInfo.M-1], txInfo.NumBits, 1); txSig = pskmod(txSig, txInfo.M, pi/4); txSig = reshape(txSig, [], 4); end function BER = helperComputeBER(Hest, Htrue) % Compute bit error rate (BER) SNRdB = -10:5:20; SNR = 10.^(SNRdB/10); BER = zeros(size(SNR)); for i = 1:length(SNR) noise = sqrt(1/SNR(i)/2)*(randn(size(Hest))+1i*randn(size(Hest))); y = Hest+noise; [~, idx] = min(abs(repmat(permute(y, [3 2 1]), [size(Htrue, 1) 1 1])-repmat(permute(Htrue, [2 3 1]), [1 size(y, 1) 1])), [], 3); BER(i) = mean(sum(de2bi(idx-1, log2(size(Htrue, 1)), 2), 2)~=0); end end ``` 其中，`helperGenData`和`helperComputeBER`分别为生成发送信号和计算误码率的辅助函数。运行代码后，会输出估计信道与真实信道之间的均方误差（MSE）和误码率（BER）。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值