POJ 3481 Double Queue

最新推荐文章于 2017-08-16 15:52:34 发布
最新推荐文章于 2017-08-16 15:52:34 发布
阅读量986 收藏
点赞数
分类专栏： ###### 数据结构 ####### ++++ 二叉树 ++++ POJ - Treap - Splay 文章标签： 伸展树 STL map 树堆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013569656/article/details/20052549
版权

题目大意：

        新成立与罗马尼亚布加勒斯特的巴尔干半岛投资集团银行，装备了由IBM公司支持的现代计算环境以及IT技术。通常每个客户在接受服务时都会得到一个编号K和权限P（K < 10^6, P < 10^7）。但是一名经理创造性的提出可以通过低权限（而非高权限）从服务柜台获得服务，因此他建议软件工程师按照如下规则实现该服务系统：

                0表示终止服务系统；

                1 K P表示在等待队列里假如一名编号为K优先级为P的客户；

                2表示为最高权限客户提供服务，并从等待列表中除去该客户；

                3表示为最低权限客户提供服务，并从等待列表中除去该客户；

         对于命令2和3需要输出相应的客户编号（等待列表中各个客户编号和优先级互不相同）。

题目链接

伸展树：

注释代码：

/*              
 * Problem ID : POJ 3481 Double Queue 
 * Author     : Lirx.t.Una              
 * Language   : C++      
 * Run Time   : 235 ms              
 * Run Memory : 176 KB              
*/  

#include <stdio.h>
#include <stdlib.h>

//maximum and minimum priority
//最大和最小的有限权值
#define	MAXP		10000000
#define	MINP		0

struct	Node;

typedef	struct Node		BNode;
typedef	struct Node *	PtNode;
typedef	struct Node *	Tree;

struct	Node {//伸展树结点

	int		k;//客户的服务编号
	int		p;//客户得到的优先权值
	
	Tree	lft;
	Tree	rht;
};

Tree
splay( Tree tree, int p ) {//伸展

	if ( !tree )
		return NULL;

	BNode	node;//用于收取从tree上剪下来的结点
	Tree	tl;//left tree，node的左分支
	Tree	tr;//right tree，node的右分支
	Tree	ttmp;//temporary tree，临时变量，用于旋转

	node.lft = NULL;
	node.rht = NULL;

	tl = &node;
	tr = &node;

	while (1) {
	
		if ( p == tree->p )//查找成功
			break;

		if ( p < tree->p ) {//目标小于当前结点
			            //需向左子树伸展
		
			if ( !tree->lft )//若左子树为空则无法伸展
				       //因此也就到了极限，可以直接退出循环
				break;

			if ( p < tree->lft->p ) {//若目标比左子树还小
				//则在向左子树伸展之前（即嫁接之前）先做一次
				//AVL左旋转，这样可以保证嫁接回来后整个数的
				  //高度可以降低，可以提高查询速率
			
				//常规的AVL左旋转
				ttmp 		= tree->lft;
				tree->lft	= ttmp->rht;
				ttmp->rht	= tree;
				tree		= ttmp;
				
				if ( !tree->lft )//旋转完成后顶点被更新
					       //因此新的顶点的左子树可能为空
						   //若为空则不能再继续向新的左子树伸展
						   //因此必须跳出循环，将剪去的嫁接回来
					break;
			}//对于大于等于左子树的情况，直接减去顶点并外接即可
			//只有当伸展必须向子树的外侧纵深时才需要旋转调整高度

			//将顶点剪去，暂时接在外部两侧的辅助树上
			tr->lft = tree;
			tr		= tree;
			tree	= tree->lft;
		}
		else {//右伸展与左伸展同理
		
			if ( !tree->rht )
				break;

			if ( p > tree->rht->p ) {
			
				ttmp		= tree->rht;
				tree->rht	= ttmp->lft;
				ttmp->lft	= tree;
				tree		= ttmp;

				if ( !tree->rht )
					break;
			}

			tl->rht	= tree;
			tl		= tree;
			tree	= tree->rht;
		}
	}

	//将暂接在外侧树上的子树接回来
	tl->rht		= tree->lft;
	tr->lft		= tree->rht;
	tree->lft	= node.rht;
	tree->rht	= node.lft;

	return tree;
}

Tree
push( Tree tree, int k, int p ) {//插入结点
	               //插入的结点作为新的顶点

	PtNode	node;

	node = (PtNode)malloc( sizeof(BNode) );

	node->k 	= k;
	node->p 	= p;
	node->lft	= NULL;
	node->rht	= NULL;

	if ( !tree )
		return node;

	tree = splay( tree, p );//先按照插入点的权值
	           //将整棵树伸展一遍，这样可以有效
	           //降低树的高度，使之趋于平衡
	           //接着再进行插入
	           //此时顶点的权值和插入结点的权值非常相近

	if ( p < tree->p ) {//若小于顶点
	
		node->lft = tree->lft;
		node->rht = tree;
		tree->lft = NULL;
	}
	else {//大于顶点
	
		node->rht = tree->rht;
		node->lft = tree;
		tree->rht = NULL;
	}

	return node;
}

Tree
pop( Tree tree, int p ) {//删除指定权值的结点
	//本来该函数是只能删除指定权值的结点的，
	  //如果查询不到指定权值的结点将会在伸展后
	  //返回与其最接近的顶点
	//但是这里由于题目的特殊性，只删除最大或最小
	  //权值，因此这里输入的参数p不是MAXP就是MINP
	//因此在splay后，顶点必然就是最大或者最小的
	//因此无论如何都可以删除
	//并且由于题目中要求空树输出0，因此该功能就在函数外
	  //实现了，因此函数内就不再判断树空了

	Tree	ttmp;

	ttmp = splay( tree, p );//伸展，将最大或者最小结点变成顶点
	printf("%d\n", ttmp->k);//输出

	if ( !ttmp->lft )//左子树为空则直接将右子树作为新树
		tree = ttmp->rht;
	else {
	
		//否则用顶点的值对左子树进行伸展
		//由于顶点一定比左子树中任何一个结点的值都大
		//因此伸展后左子树的右子树必为空
		//接着再以伸展后的左子树作为新树
		//将老树的右子树接在其右子树上即可
		tree	  = splay( ttmp->lft, ttmp->p );
		tree->rht = ttmp->rht;
	}
	free(ttmp);

	return tree;
}

int
main() {

	int		n;
	int		k, p;

	Tree	tree;

	tree = NULL;
	while ( scanf("%d", &n), n ) {
	
		switch (n) {
		
			case 1 :
		
				scanf("%d%d", &k, &p);
				tree = push( tree, k, p );
				break;

			case 2 :

				if ( !tree ) {
				
					puts("0");
					break;
				}

				tree = pop( tree, MAXP );
				break;

			default :

				if ( !tree ) {
				
					puts("0");
					break;
				}

				tree = pop( tree, MINP );
				break;
		}
	}

	return 0;
}

无注释代码：

#include <stdio.h>
#include <stdlib.h>

#define	MAXP		10000000
#define	MINP		0

struct	Node;

typedef	struct Node		BNode;
typedef	struct Node *	PtNode;
typedef	struct Node *	Tree;

struct	Node {

	int		k;
	int		p;
	
	Tree	lft;
	Tree	rht;
};

Tree
splay( Tree tree, int p ) {

	if ( !tree )
		return NULL;

	BNode	node;
	Tree	tl;
	Tree	tr;
	Tree	ttmp;

	node.lft = NULL;
	node.rht = NULL;

	tl = &node;
	tr = &node;

	while (1) {
	
		if ( p == tree->p )
			break;

		if ( p < tree->p ) {
		
			if ( !tree->lft )
				break;

			if ( p < tree->lft->p ) {
			
				ttmp 		= tree->lft;
				tree->lft	= ttmp->rht;
				ttmp->rht	= tree;
				tree		= ttmp;
				
				if ( !tree->lft )
					break;
			}

			tr->lft = tree;
			tr		= tree;
			tree	= tree->lft;
		}
		else {
		
			if ( !tree->rht )
				break;

			if ( p > tree->rht->p ) {
			
				ttmp		= tree->rht;
				tree->rht	= ttmp->lft;
				ttmp->lft	= tree;
				tree		= ttmp;

				if ( !tree->rht )
					break;
			}

			tl->rht	= tree;
			tl		= tree;
			tree	= tree->rht;
		}
	}

	tl->rht		= tree->lft;
	tr->lft		= tree->rht;
	tree->lft	= node.rht;
	tree->rht	= node.lft;

	return tree;
}

Tree
push( Tree tree, int k, int p ) {

	PtNode	node;

	node = (PtNode)malloc( sizeof(BNode) );

	node->k 	= k;
	node->p 	= p;
	node->lft	= NULL;
	node->rht	= NULL;

	if ( !tree )
		return node;

	tree = splay( tree, p );

	if ( p < tree->p ) {
	
		node->lft = tree->lft;
		node->rht = tree;
		tree->lft = NULL;
	}
	else {
	
		node->rht = tree->rht;
		node->lft = tree;
		tree->rht = NULL;
	}

	return node;
}

Tree
pop( Tree tree, int p ) {

	Tree	ttmp;

	ttmp = splay( tree, p );
	printf("%d\n", ttmp->k);

	if ( !ttmp->lft )
		tree = ttmp->rht;
	else {
	
		tree	  = splay( ttmp->lft, ttmp->p );
		tree->rht = ttmp->rht;
	}
	free(ttmp);

	return tree;
}

int
main() {

	int		n;
	int		k, p;

	Tree	tree;

	tree = NULL;
	while ( scanf("%d", &n), n ) {
	
		switch (n) {
		
			case 1 :
		
				scanf("%d%d", &k, &p);
				tree = push( tree, k, p );
				break;

			case 2 :

				if ( !tree ) {
				
					puts("0");
					break;
				}

				tree = pop( tree, MAXP );
				break;

			default :

				if ( !tree ) {
				
					puts("0");
					break;
				}

				tree = pop( tree, MINP );
				break;
		}
	}
	
	return 0;
}

STL：

注释代码：

/*              
 * Problem ID : POJ 3481 Double Queue 
 * Author     : Lirx.t.Una              
 * Language   : C++      
 * Run Time   : 297 ms              
 * Run Memory : 196 KB              
*/  

#include <iostream>
#include <cstdio>
#include <map>

using namespace std;

int
main() {
	
	map<int, int>			mp;
	map<int, int>::iterator	it;//迭代器
	
	int		n;
	int		k, p;

	//在map[i] = j中i为第一个参数，j为第二个参数
	//i向j映射
	//其中迭代顺序为按照i的大小从前往后排
	//即map.begin()为i最小的元素的迭代器
	//map.end() - 1为i最大的元素的迭代器
	//迭代器重载过->运算符，其中
	  //it->first为第一个参数，即i
	  //it->second为第二个参数，即j
	//map内部实现为红黑树

	//此程序中map的几个调用
	  //mp.begin()、mp.end()返回起始和末尾元素的迭代器
	    //其中mp.end()指向的是最后一个元素的后面一个位置，其实是空的
	    //因此得到的it需要--
	  //mp.erase(it)将相应迭代器所指向的元素删去
	  //mp.empty()判断map是否为空
	  //it->first、it->second，返回迭代器所指元素的第一和第二参数
	
	while ( scanf("%d", &n), n )
		switch (n) {
		
			case 1 :
				
				scanf("%d%d", &k, &p);
				mp[p] = k;
				break;
				
			case 2 :
				
				if ( mp.empty() ) {
					
					puts("0");
					break;
				}
				
				it = mp.end();
				printf("%d\n", (--it)->second);
				mp.erase(it);
				break;
				
			default :
				
				if ( mp.empty() ) {
					
					puts("0");
					break;
				}
				
				it = mp.begin();
				printf("%d\n", it->second);
				mp.erase(it);
				break;
	}
	
	return 0;
}

无注释代码：

#include <iostream>
#include <cstdio>
#include <map>

using namespace std;

int
main() {

	map<int, int>			mp;
	map<int, int>::iterator	it;

	int		n;
	int		k, p;

	while ( scanf("%d", &n), n )
		switch (n) {
		
			case 1 :

				scanf("%d%d", &k, &p);
				mp[p] = k;
				break;

			case 2 :

				if ( mp.empty() ) {
				
					puts("0");
					break;
				}

				it = mp.end();
				printf("%d\n", (--it)->second);
				mp.erase(it);
				break;

			default :

				if ( mp.empty() ) {
			
					puts("0");
					break;
				}

				it = mp.begin();
				printf("%d\n", it->second);
				mp.erase(it);
				break;
		}

	return 0;
}

树堆（Treap）：

注释代码：

/*               
 * Problem ID : POJ 3481 Double Queue  
 * Author     : Lirx.t.Una               
 * Language   : C/C++       
 * Run Time   : 266 ms               
 * Run Memory : 196 KB               
*/    

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

struct	Node;

typedef	struct Node *	PtNode;
typedef struct Node *	Tree;

struct	Node {

	int		k;
	int		p;

	Tree	lft;
	Tree	rht;

	int		fix;//随机修正值
};

Tree
RotL(Tree k2) {//AVL左旋

	Tree	k1;

	k1		= k2->lft;
	k2->lft = k1->rht;
	k1->rht = k2;

	return k1;
}

Tree
RotR(Tree k2) {//AVL右旋

	Tree	k1;

	k1		= k2->rht;
	k2->rht = k1->lft;
	k1->lft = k2;

	return k1;
}

Tree
Insert( Tree tree, int k, int p ) {//插入

	if ( !tree ) {//正常的BST插入，并附上随机修正值
		//插在叶结点上
	
		PtNode	node;

		node = (PtNode)malloc( sizeof( struct Node ) );

		node->k		= k;
		node->p 	= p;
		node->lft	= NULL;
		node->rht 	= NULL;

		node->fix 	= rand();

		return node;
	}

	//调整高度时按照随机修正值小的往高处调的原则进行维护
	//待调结点和顶点比较修正值大小
	if ( p < tree->p ) {
	
		tree->lft = Insert( tree->lft, k, p );
		if ( tree->lft->fix < tree->fix )
			tree = RotL(tree);
	}
	else {
	
		tree->rht = Insert( tree->rht, k, p );
		if ( tree->rht->fix < tree->fix )
			tree = RotR(tree);
	}

	return tree;
}

Tree
Remove( Tree tree, int p ) {//删除相应权值的结点

	if ( !tree )
		return NULL;

	if ( p == tree->p ) {//找到匹配结点
	
		if ( !tree->lft || !tree->rht ) {//可以直接删除

			Tree	ttmp;

			ttmp = tree;

			if ( !tree->lft )
				tree = tree->rht;
			else
				tree = tree->lft;

			free(ttmp);
			return tree;
		}

		//左右子树都非空，必须做调整后在进行删除


		if ( tree->lft->fix < tree->rht->fix ) {
		//按照随机修正值小的结点往上走的原则
        //先将左子树顶点左旋至顶点位置，此时老顶点称为新顶点的右子树顶点了
		//然后在右子树中删除匹配结点就行了
		
		
			tree		= RotL(tree);
			tree->rht	= Remove( tree->rht, p );
		}
		else {//与上对称，同理
		
			tree		= RotR(tree);
			tree->lft	= Remove( tree->lft, p );
		}

		return tree;
	}

	if ( p < tree->p )
		tree->lft = Remove( tree->lft, p );
	else
		tree->rht = Remove( tree->rht, p );

	return tree;
}

int
MinP(Tree tree) {//get minimum priority in tree
	//获得tree中权值最小的顶点的权值

	while ( tree->lft )
		tree = tree->lft;

	printf("%d\n", tree->k);//顺便输出最小结点的编号值
	return tree->p;
}

int
MaxP(Tree tree) {//get maximum priority in tree

	while ( tree->rht )
		tree = tree->rht;

	printf("%d\n", tree->k);
	return tree->p;
}

int
main() {

	int		n;
	int		k, p;

	Tree	tree;

	tree = NULL;
	srand( (unsigned int)time(NULL) );
	while ( scanf("%d", &n), n )
		switch (n) {
		
			case 1 :

				scanf("%d%d", &k, &p);
				tree = Insert( tree, k, p );
				break;

			case 2 :

				if ( !tree ) {
				
					puts("0");
					break;
				}

				tree = Remove( tree, MaxP(tree) );
				break;

			default :

				if ( !tree ) {
				
					puts("0");
					break;
				}

				tree = Remove( tree, MinP(tree) );
				break;
		}

	return 0;
}

无注释代码：

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

struct	Node;

typedef	struct Node *	PtNode;
typedef struct Node *	Tree;

struct	Node {

	int		k;
	int		p;

	Tree	lft;
	Tree	rht;

	int		fix;
};

Tree
RotL(Tree k2) {

	Tree	k1;

	k1		= k2->lft;
	k2->lft = k1->rht;
	k1->rht = k2;

	return k1;
}

Tree
RotR(Tree k2) {

	Tree	k1;

	k1		= k2->rht;
	k2->rht = k1->lft;
	k1->lft = k2;

	return k1;
}

Tree
Insert( Tree tree, int k, int p ) {

	if ( !tree ) {
	
		PtNode	node;

		node = (PtNode)malloc( sizeof( struct Node ) );

		node->k		= k;
		node->p 	= p;
		node->lft	= NULL;
		node->rht 	= NULL;

		node->fix 	= rand();

		return node;
	}

	if ( p < tree->p ) {
	
		tree->lft = Insert( tree->lft, k, p );
		if ( tree->lft->fix < tree->fix )
			tree = RotL(tree);
	}
	else {
	
		tree->rht = Insert( tree->rht, k, p );
		if ( tree->rht->fix < tree->fix )
			tree = RotR(tree);
	}

	return tree;
}

Tree
Remove( Tree tree, int p ) {

	if ( !tree )
		return NULL;

	if ( p == tree->p ) {
	
		if ( !tree->lft || !tree->rht ) {

			Tree	ttmp;

			ttmp = tree;

			if ( !tree->lft )
				tree = tree->rht;
			else
				tree = tree->lft;

			free(ttmp);
			return tree;
		}

		if ( tree->lft->fix < tree->rht->fix ) {
		
			tree		= RotL(tree);
			tree->rht	= Remove( tree->rht, p );
		}
		else {
		
			tree		= RotR(tree);
			tree->lft	= Remove( tree->lft, p );
		}

		return tree;
	}

	if ( p < tree->p )
		tree->lft = Remove( tree->lft, p );
	else
		tree->rht = Remove( tree->rht, p );

	return tree;
}

int
MinP(Tree tree) {

	while ( tree->lft )
		tree = tree->lft;

	printf("%d\n", tree->k);
	return tree->p;
}

int
MaxP(Tree tree) {

	while ( tree->rht )
		tree = tree->rht;

	printf("%d\n", tree->k);
	return tree->p;
}

int
main() {

	int		n;
	int		k, p;

	Tree	tree;

	tree = NULL;
	srand( (unsigned int)time(NULL) );
	while ( scanf("%d", &n), n )
		switch (n) {
		
			case 1 :

				scanf("%d%d", &k, &p);
				tree = Insert( tree, k, p );
				break;

			case 2 :

				if ( !tree ) {
				
					puts("0");
					break;
				}

				tree = Remove( tree, MaxP(tree) );
				break;

			default :

				if ( !tree ) {
				
					puts("0");
					break;
				}

				tree = Remove( tree, MinP(tree) );
				break;
		}

	return 0;
}

单词解释：

found：vt, 创立，创办

Balkan：地名，巴尔干半岛（即意大利陆地）

investment：n, 投资

Bucharest：地名，布加勒斯特（罗马尼亚首都）

equip：vt, 装备

Romania：国家，罗马尼亚

client：n, 客户，客户机

upon：prep, 根据

identify：vt, 鉴定，识别

invention：n, 发明

shock：vt, 震惊

propose：vt, 建议，打算

request：n, 请求，要求

serving desk：n, 服务柜台

identifier：n, 标示符

__Lirx_t_Una__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
poj 3481 Double Queue.md
11-17
poj 3481 Double Queue.md
7.11.1 Double Queue
jianguosongzi的博客
07-19 92
2023暑期夏令营
Double Queue（SET水题）
Techay的博客
03-05 472
The new founded Balkan Investment Group Bank (BIG-Bank) opened a new office in Bucharest, equipped with a modern computing environment provided by IBM Romania, and using modern information technologies
POJ 3481 Double Queue(Treap)
code
04-23 2930
POJ 3481 Double Queue(Treap) http://poj.org/problem?id=3481 题意:每个顾客有个编号和优先级,银行每次可以添加顾客的要求进队列,且保证队列中当前任意顾客的编号和优先级都不同.银行可以执行先服务最大优先级的顾客或者先服务最小优先级的顾客操作.对于每个服务,输出顾客的编号. 分析:直接构建Treap,插入节点的v值(顾客优先级)和节点的r
poj3481-Double Queue
AcToy
07-16 755
根据优先值的大小，输出它所对应的节点，在建树的过程中，再加一个kk变量，找到优先值p的位置，输出kk即可 /************************************************************************* > File Name: 3481.cpp > Author: Ac_Toy > Mail: ycsgldy@163.
poj.rar_poj
09-20
POJ 上的近100道水题，基本涵盖了所有基本算法和数据结构，全部AC
POJ.rar_poj
09-19
poj nwpu 2013 年才语言答案，不是全部，仅供参考
poj3481
weixin_34367257的博客
09-19 74
priority_queue如果想同时建立小根堆和大根堆需要这样写 priority_queue&lt;Elem, vector&lt;Elem&gt; , greater&lt;Elem&gt; &gt; pq3; //小根priority_queue&lt;Elem, vector&lt;Elem&gt; , less&lt;Elem&gt; &gt; pq2;//大根 并重载大于和小于号...
POJ 3481 Double Queue
coding_sun的博客
08-16 993
POJ 3481 Double Queue（中文版） 北大2017大数据研究中心夏令营上机考试 G题
[poj 3481]Double Queue[set || map][STL]
以中有足乐者...
08-09 943
题意: 三种操作: 1 k p      向队伍中插入编号为k的优先级为p的客户 2           选择优先级最高的客户出队 3           选择优先级最低的客户出队 set: 可以利用set的有序性和首尾出队功能. //228K 297MS #include #include using namespace std; struct node { i
POJ 2259 Team Queue
源代码
02-24 1261
题目大意：          队列和优先队列在计算机科学界耳熟能详，但组队列并没那么有名，但它经常出现在日常生活中，比如在餐厅里面排队买饭的队列就是。          在一个组队列中，每个元素都属于某一组，在入队时会先找熟人（即同组组员），若有则直接插到同组人的末尾（相当于队列中的队列），若无则只能排到整个队列的末尾了同时他将成为他所属的组中第一个出现在组队列中的成员。对于出队列，就和普通的
POJ 2051 Argus
源代码
02-24 867
题目大意： 单词解释： Argus：人名，希腊神话中的百眼巨人 stream：n, 流，溪流 real-time：adj, 实时的，接到指示立即执行的 continuous：adj, 连续不断的 ordered：adj, 有序的 item：n, 项目，条款，物件 sensor：n, 传感器 traffic：n, 交通，通信量 Internet traffic：n, 英特网通信量
POJ 2559 Largest Rectangle in a Histogram
源代码
02-24 827
题目大意：         在一张直方图（每天柱子的宽都是1）中找出最大面积矩形并输出其面积。         有多个测例，每个测例都会给出该测例中唯一一个直方图中柱子的数量n（n ≤ 100,000），并依次（按照直方图中从左往右的顺序）给出每根柱子的高度hi（hi ≤ 1,000,000,000），对于每个测例都需要输出最大矩形的面积，以n等于0结束测例退出程序。         ！！！
ZOJ 2334 Monkey King
源代码
03-01 817
题目大意： 注释代码： 无注释代码： 单词解释： aggressive：adj, 侵略性的，好斗的 quarrel：vt, 吵架，争论 duel：vi/n, 决斗 conflict：vt/n, 冲突，争斗 reduce：vt, 减少
POJ 2418 Hardwood Species
源代码
02-27 718
题目大意： BST： 注释代码： 无注释代码： AVL： 注释代码： 无注释代码： 单词解释： hardwood：n, 阔叶树，硬木 hardwoods：n, 阔叶林
poj Divisibility
最新发布
09-12
POJ Divisibility是一个编程题，要求编写一个程序来确定一系列整数是否可被K整除。输入文件的第一行包含两个整数N和K，用一个空格分隔。第二行包含一系列N个整数，以空格分隔。每个整数的绝对值不大于10000。在输出...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值