POJ 3666 Making the Grade (dp, 数据结构[左偏树, 划分树, 函数式线段树等])

最新推荐文章于 2019-05-14 22:02:00 发布
最新推荐文章于 2019-05-14 22:02:00 发布
阅读量1k 收藏 3
点赞数
分类专栏： 数据结构 动态规划 文章标签： dp 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yunyouxi/article/details/44419739
版权
题目类型  dp, 数据结构[左偏树, 划分树, 函数式线段树等]

题目意思
给出一个最多包含 2000 个在 [0, 1e9] 范围内的数的数列 问把这个数列修改成一个非递增或非递减数列的最小代价
代价＝原数列的每一个元素和修改后的数列的相应位置的元素的差的绝对值的和

解题方法
1. dp (离散化)
dp[i][j] : 前 i 个元素组成一个非递减数列且第 i 个元素的值为 j 的最小代价 看起来计算要O(n^3) 其实 O(n^2)就可以了
            因为在计算 dp[i][j] 的时候可以直接用计算 dp[i][j-1]时得到的 (dp[i-1][0] -> dp[i-1][j-1]这些值中的最小值) 这个信息
            非递增数列的代价同样可以O(n^2)时间内算出

2. 参考论文的解法 ->  左偏树的特点及其应用
    2.1 知道方法后问题的重点就变成找某一个变化数列的中位数 论文的方法是用一棵左偏树(树根保存着最大值且为中位数)保存一个数列的左半部分, 需             要合并另一个数列的时候就把那个数列的左半部分形成的左偏树和当前左偏树合并 注意当合并的两个数列的元素个数都为奇数时合并后需要把根删           掉 (例如数列1 2 3和数列4 5 6合并后就应该得到一棵只包含3个元素的左偏树而不是4个)
    2.2 其实就是找某一段区间的第 k 小数 (求中位数可以由数列长度算出k) 所以这一部分也可以用 划分树 或 函数式线段树做

参考代码 - 有疑问的地方在下方留言 看到会尽快回复的
1.dp 
#include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;

typedef long long LL;
const int maxn = 2000 + 10;
const LL INF = 1LL<<60;
int a[maxn], b[maxn];
LL dp[2][maxn];

int Abs(int x) { return x < 0 ? -x : x; }

int main() {
//	freopen("in", "r", stdin);
	int n;
	while(scanf("%d", &n) != EOF) {
		for( int i=0; i<n; i++ ) { scanf("%d", &a[i]); b[i] = a[i]; }
		sort(b, b + n);
		int nb = unique(b, b + n) - b;
		for( int i=0; i<nb; i++ ) dp[0][i] = Abs(b[i] - a[0]);
		int now = 0;
		for( int i=1; i<n; i++ ) {
			LL nmin = INF;
			for( int j=0; j<nb; j++ ) {
				nmin = min(nmin, dp[now][j]);
				dp[now^1][j] = nmin + Abs(b[j] - a[i]);
			}
			for( int j=0; j<nb; j++ ) dp[now][j] = INF;
			now ^= 1;
		}
		LL ans = INF;
		for( int i=0; i<nb; i++ ) ans = min(ans, dp[now][i]);

		for( int i=0; i<nb; i++ ) dp[0][i] = Abs(b[i] - a[n-1]);
		now = 0;
		for( int i=n-2; i>=0; i-- ) {
			LL nmin = INF;
			for( int j=nb-1; j>=0; j-- ) {
				nmin = min(nmin, dp[now][j]);
				dp[now^1][j] = nmin + Abs(b[j] - a[i]);
			}
			for( int j=0; j<nb; j++ ) dp[now][j] = INF;
			now ^= 1;
		}
		for( int i=0; i<nb; i++ ) ans = min(ans, dp[now][i]);

		printf("%lld\n", ans);
	}
	return 0;
}

2.1 左偏树 
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <cstdlib>

using namespace std;

const int maxn = 2000 + 10;
#define B printf("BUG\n");

int a[maxn];
int ans[maxn];

class Node {
public :
	int v;
	int h;
	Node * ch[2];
	Node(int v) : v(v) { ch[0] = ch[1] = NULL; h = 0; }
};

class Seg {
public :
	int n;
	Node * rt;
	Seg(Node * rt, int n) : rt(rt), n(n) {}
};

class Leftist {
public : 

	stack<Seg *>S;

	Node * merge(Node * t1, Node * t2) {
		if(t1 == NULL) return t2;
		else if(t2 == NULL) return t1;
		if(t1->v < t2->v) swap(t1, t2);
		if(t1->ch[1] == NULL) {
			t1->ch[1] = t2;
			if(t1->ch[0] == NULL) { swap(t1->ch[0], t1->ch[1]); t1->h = 0; }
			else {
				if(t1->ch[0]->h < t1->ch[1]->h) swap(t1->ch[0], t1->ch[1]);
				t1->h = t1->ch[1]->h + 1;
			}
		}
		else {
			t1->ch[1] = merge(t1->ch[1], t2);
			if(t1->ch[0] == NULL) { swap(t1->ch[0], t1->ch[1]); t1->h = 0; }
			else {
				if(t1->ch[0]->h < t1->ch[1]->h) swap(t1->ch[0], t1->ch[1]);
				t1->h = t1->ch[1]->h + 1;
			}
		}
		return t1;
	}

	void solve(int x) {
		int num = 1;
		Node * t1 = new Node(x);
		while(!S.empty()) {
			Seg * s2 = S.top();
			if(t1->v < s2->rt->v) {
				int flag = false;
				if(num % 2 && s2->n % 2) flag = true;
				t1 = merge(t1, s2->rt);
				num += s2->n;
				if(flag) {
					Node * tmp = t1;
					t1 = merge(t1->ch[0], t1->ch[1]);
					delete tmp;
				}
				S.pop();
				delete s2;
			}
			else break;
		}
		Seg * s2 = new Seg(t1, num);
		S.push(s2);
	}

	void removetree(Node * rt) {
		if(rt->ch[0] == NULL && rt->ch[1] == NULL) {
			delete rt;
			rt = NULL;
			return ;
		}
		if(rt->ch[0]) removetree(rt->ch[0]);
		if(rt->ch[1]) removetree(rt->ch[1]);
		delete rt;
		rt = NULL;
	}

	void remove() {
		while(!S.empty()) {
			removetree(S.top()->rt);
			delete S.top();
			S.pop();
		}
	}
};

int main() {
	freopen("in", "r", stdin);
	int n;
	while(scanf("%d", &n) != EOF) {
		Leftist lt;
		for( int i=0; i<n; i++ ) {
			scanf("%d", &a[i]);
			lt.solve(a[i]);
		}

		int k = 0;
		while(!lt.S.empty()) {
			Seg * f = lt.S.top(); lt.S.pop();
			for( int i=0; i<f->n; i++ ) {
				ans[k++] = f->rt->v;
			}
		}
		int res = 0;
		for( int i=k-1; i>=0; i-- ) res += abs(ans[i] - a[n-i-1]);
		lt.remove();
		Leftist lt2;
		for( int i=0; i<n/2; i++ ) swap(a[i], a[n-i-1]);
		for( int i=0; i<n; i++ ) lt2.solve(a[i]);
		k = 0;
		while(!lt2.S.empty()) {
			Seg * f = lt2.S.top(); lt2.S.pop();
			for( int i=0; i<f->n; i++ ) {
				ans[k++] = f->rt->v;
			}
		}
		int res2 = 0;
		for( int i=k-1; i>=0; i-- ) res2 += abs(ans[i] - a[n-i-1]);
		lt2.remove();
		res = min(res, res2);
		printf("%d\n", res);
	}
	return 0;
}

2.2 划分树 
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <cstdlib>
#include <algorithm>

using namespace std;

const int maxn = 2000 + 10;
#define B printf("BUG\n");

int a[maxn], b[maxn], A[maxn];
int ans[maxn];
int n, N;

class Seg {
public :
	int l, r;
	int nmid;
	Seg(int l, int r, int nmid) : l(l), r(r), nmid(nmid) {}
};

int tree[20][2010], movel[20][2010];

class DivTree {
public : 

	void build(int rt, int l, int r) {
		if(l == r) { tree[rt][l] = tree[rt-1][l]; return ; }
		int mid = (l+r)>>1;
		int c = 0, d = 0;
		for( int i=l; i<=r; i++ ) {
			int pos = tree[rt-1][i];
			movel[rt][i] = i==l?0:movel[rt][i-1];
			if(A[pos] <= mid) { 
				tree[rt][l+c] = pos;
				c++; movel[rt][i]++; 
			}
			else {
				tree[rt][mid+1+d] = pos;
				d++;
			}
		}
		build(rt+1, l, mid); build(rt+1, mid+1, r);
	}

	int query_mid(int rt, int l, int r, int L, int R, int k) {
		int mid = (l+r)>>1;
		if(l == r) return a[tree[rt][l]];
		int mlp1 = L==l?0:movel[rt][L-1];
		int mtol = movel[rt][R] - mlp1;
		if(mtol >= k) return query_mid(rt+1, l, mid, mlp1+l, mlp1+mtol-1+l, k);
		else return query_mid(rt+1, mid+1, r, L-l-mlp1+mid+1, L-l-mlp1+(R-L+1-mtol)-1+mid+1, k-mtol);
	}
}dt;

stack<Seg *>S;
void solve(int x) {
	int num = 1;
	Seg * t1 = new Seg(x, x, a[x]);
	while(!S.empty()) {
		Seg * s2 = S.top();
		if(t1->nmid < s2->nmid) {
			t1->nmid = dt.query_mid(1, 0, n-1, s2->l, t1->r, (t1->r-s2->l+1+1)/2); 
			//printf("x = %d nmid = %d %d-> %d\n", x+1, t1->nmid, s2->l, t1->r);
			t1->l = s2->l;
			S.pop();
			delete s2;
		}
		else break;
	}
	S.push(t1);
}

bool cmp(const int & lhs, const int & rhs) {
	return a[lhs] < a[rhs];
}

int main() {
	freopen("in", "r", stdin);
	while(scanf("%d", &n) != EOF) {
		for( int i=0; i<n; i++ ) {
			scanf("%d", &a[i]);
			b[i] = i;
		}
		sort(b, b + n, cmp);
		for( int i=0; i<n; i++ ) A[b[i]] = i;
		for( int i=0; i<n; i++ ) tree[0][i] = i;
		dt.build(1, 0, n-1);
		
		for( int i=0; i<n; i++ ) solve(i);
		int k = 0;
		while(!S.empty()) {
			Seg * f = S.top(); S.pop();
			for( int i=0; i<f->r-f->l+1; i++ ) {
				ans[k++] = f->nmid;
			}
		}
		int res = 0;
		for( int i=k-1; i>=0; i-- ) res += abs(ans[i] - a[n-i-1]);

		while(!S.empty()) S.pop();
		for( int i=0; i<n/2; i++ ) swap(a[i], a[n-i-1]);
		for( int i=0; i<n; i++ ) b[i] = i;
		sort(b, b + n, cmp);
		for( int i=0; i<n; i++ ) A[b[i]] = i;

		dt.build(1, 0, n-1);
		for( int i=0; i<n; i++ ) solve(i);
		k = 0;
		while(!S.empty()) {
			Seg * f = S.top(); S.pop();
			for( int i=0; i<f->r-f->l+1; i++ ) {
				ans[k++] = f->nmid;
			}
		}
		int res2 = 0;
		for( int i=k-1; i>=0; i-- ) res2 += abs(ans[i] - a[n-i-1]);
		res = min(res, res2);
		printf("%d\n", res);
	}
	return 0;
}

2.3 函数式线段树 
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <cstdlib>
#include <algorithm>

using namespace std;

const int maxn = 2000 + 10;
#define B printf("BUG\n");

int a[maxn], b[maxn];
int ans[maxn];
int n, N;

class Seg {
public :
	int l, r;
	int nmid;
	Seg(int l, int r, int nmid) : l(l), r(r), nmid(nmid) {}
};

class Node {
public :
	Node * ch[2];
	int n;
	Node(int n) : n(n) { ch[0] = ch[1] = NULL; }
	Node() {}
};

class SegTree {
public : 
	Node * tree[maxn];
	void insert(Node *& rt, Node * pre, int l, int r, int x) {
		if(x == 0) {
		}

		if(l == r) {
			if(pre != NULL) rt->n += pre->n;
			rt->n++;
			return ;
		}
		int mid = (l+r)>>1;
		if(x <= mid) { 
			rt->ch[0] = new Node(0);
			if(pre == NULL) insert(rt->ch[0], NULL, l, mid, x);
			else { rt->ch[1] = pre->ch[1]; insert(rt->ch[0], pre->ch[0], l, mid, x); }
		}
		else {
			rt->ch[1] = new Node(0);
			if(pre == NULL) insert(rt->ch[1], NULL, mid+1, r, x);
			else { rt->ch[0] = pre->ch[0]; insert(rt->ch[1], pre->ch[1], mid+1, r, x); }
		}
		rt->n = (rt->ch[0] == NULL ? 0 : rt->ch[0]->n) + (rt->ch[1] == NULL ? 0 : rt->ch[1]->n);
	}

	void build() {
		tree[0] = new Node(0);
		for( int i=1; i<=n; i++ ) {
			tree[i] = new Node(0);
			int x = lower_bound(b, b + N, a[i-1]) - b;
			insert(tree[i], tree[i-1], 0, N-1, x);
		}
	}

	int query(Node * L, Node * R, int l, int r, int k) {
		if(l == r) {
			return b[l];
		}
		int tL = ((L == NULL || L->ch[0] == NULL) ? 0 : L->ch[0]->n);
		int tR = ((R == NULL || R->ch[0] == NULL) ? 0 : R->ch[0]->n);
		int tn = tR - tL;
		if(k <= tn) return query(L==NULL?NULL:L->ch[0], R->ch[0], l, (l+r)/2, k);
		else return query(L==NULL?NULL:L->ch[1], R->ch[1], (l+r)/2 + 1, r, k - tn);
	}

	int query_mid(int L, int R) { // 询问区间 [L, R] 的中位数
		int mid = (R-L+1+1)>>1;
		return query(tree[L], tree[R+1], 0, N-1, mid);
	}
}st;

stack<Seg *>S;
void solve(int x) {
	int num = 1;
	Seg * t1 = new Seg(x, x, a[x]);
	while(!S.empty()) {
		Seg * s2 = S.top();
		if(t1->nmid < s2->nmid) {
			t1->nmid = st.query_mid(s2->l, t1->r); 
			t1->l = s2->l;
			S.pop();
			delete s2;
		}
		else break;
	}
	S.push(t1);
}

int main() {
	//freopen("in", "r", stdin);
	while(scanf("%d", &n) != EOF) {
		for( int i=0; i<n; i++ ) {
			scanf("%d", &a[i]);
			b[i] = a[i];
		}
		sort(b, b + n);
		int tb = unique(b, b + n) - b;
		N = tb;
		st.build();
		for( int i=0; i<n; i++ ) solve(i);
		int k = 0;
		while(!S.empty()) {
			Seg * f = S.top(); S.pop();
			for( int i=0; i<f->r-f->l+1; i++ ) {
				ans[k++] = f->nmid;
			}
		}
		int res = 0;
		for( int i=k-1; i>=0; i-- ) res += abs(ans[i] - a[n-i-1]);

		while(!S.empty()) S.pop();
		for( int i=0; i<n/2; i++ ) swap(a[i], a[n-i-1]);
		st.build();
		for( int i=0; i<n; i++ ) solve(i);
		k = 0;
		while(!S.empty()) {
			Seg * f = S.top(); S.pop();
			for( int i=0; i<f->r-f->l+1; i++ ) {
				ans[k++] = f->nmid;
			}
		}
		int res2 = 0;
		for( int i=k-1; i>=0; i-- ) res2 += abs(ans[i] - a[n-i-1]);
		res = min(res, res2);
		printf("%d\n", res);
	}
	return 0;
}


yunyouxi0
关注
专栏目录
poj 3016 K-Monotonic 左偏树+动态规划
翊月之影
12-10 1344
又是一个神奇而又优美的数据结构——左偏树 左偏树是什么？左偏树是一棵二叉树，是可合并的堆，它具有“左偏”的性质——简单地说就是左儿子比右儿子“长”，以来维持一定的效率 左偏树能做什么？刚才说了，左偏树是可合并的堆，堆能干的他基本都能干，而合并操作可以达到O(logn)的时间复杂度，而且作为可合并堆，左偏树的实现非常简单 具体的内容就不在这赘述了，百度上有很多更好的资料可以参考 题目
POJ 3666 Making the Grade（数列变成非降序/非升序数组的最小代价，dp）
Y先森0.0
07-21 688
&#13; 传送门： http://poj.org/problem?id=3666 Making the Grade Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 9468   Accepted: 4406 Description A straight dirt roa...
POJ 3666 Making the Grade（左偏树）
Just One Last Coding~♬
03-02 2077
题意：给出一串数，改变当个数字的大小的代价是改动的绝对值（比如2变成5，代价是3），求让这个数串变成非递减（或非递增）数列的最小代价。 下面只讨论非递减的情况（非递增类似）： 做法非常神奇，是黄源河前辈论文中的例题：左偏树的特点及其应用 对于一个非递减序列，最小代价是把每个数都变成这个序列的中位数。 而有增有减的序列，可以分段，划分成阶梯状。 至于为什么可以扩展到有增有减，论文里面的解释更为想详细！^ ^ 大体思想是：用左边树保存每一段部分的中位数。 把每个数单独建一颗左偏树。因为只有一个数，当然中位数
[poj3666]Making the Grade（DP/左偏树）
weixin_30345577的博客
03-25 73
题目大意：给你一个序列a[1....n],让你求一个序列b[1....n],满足 bi <= bj, i=a && b<=c，则不需调整； 如果bc,则最小的调整可以是把b变成c. 所以归纳可知上面结论成立。 dp[i][j] 表示考虑前i个元素，最后元素为序列中 第j小元素的最优解，a[]数组存原始数组，b[]是对a从小到大排序...
poj3016 K-Monotonic，左偏树，dp
Necs的小窝
08-12 698
今天学习了一下左偏树（Leftist Tree）。 左偏树是个二叉树，满足堆性质，它最神奇的地方就是右边比较短( 嗯，然后他就可以往最右边递归合并，这样合并的复杂度也就是O(logn)级别 插入就是将要插入节点作为一个树合并。弹出呢，只要把根节点的两个儿子合并一下就好了。   貌似这个东西应用不是很多啊。 做了个poj3016练手。 这个题问的是将一个数列变成k个严格单调串需要的总变
【左偏树】 poj3016
cjoilmd的专栏
02-22 1735
ps： 难道我天生程序就写得丑么=。=！有一个算法在我手上变慢了(⊙o⊙)…           左偏树主要优点是支持堆合并，当然，它牺牲了树的平衡，牺牲了树的平衡使得左偏树仅仅对最值的操作比较方便，对其他值的操作往往要借助lazy标记。        左偏树并不极力维护树的平衡，而是以树的左偏为代价，保证从根节点一直往右走到达“外节点”的路径长度不超过logn,这样各种操作仍然保证了log
POJ3277.rar_3277 poj_poj3277_多个面积_线段树
最新发布
09-24
标题中的“POJ3277.rar_3277 poj_poj3277_多个面积_线段树”是指一个与编程竞赛相关的压缩文件，特别提到了POJ（Problemset Online Judge）的第3277号问题。POJ是一个著名的在线编程竞赛平台，参与者需要解决各种...
poj2823.cpp.tar.gz_线段树
09-20
线段树是一种数据结构，主要用于高效地处理区间（或段）上的查询与更新操作。在题目"poj2823"中，我们看到它被应用于寻找区域间的最大值和最小值。线段树通常用于解决动态规划问题，特别是在数组或序列上执行范围...
线段树进阶-染色问题 附poj-2777题解
iwts
08-12 4616
区域染色覆盖问题 假设某大学有一面文化墙，各个学院都可以在上面涂色，要求涂色区域高必须和墙一样，宽度任意但必须是整数（以米为单位）。涂色可以覆盖其他学院的涂色。现在若干个学院涂色之后最终这面墙上能看见多少种颜色。 这就是简单的染色问题了。当然有很多种不同的说法，但整体上离不开这两个问题：1.区域覆盖。2.多种染色方式。既然是区域操作，那么用线段树是比较合理了。用...
线段树练习POJ 3264
04-14
线段树是一种数据结构，常用于处理区间查询与更新的问题，它能高效地支持动态维护区间最值、求和等问题。在本题“POJ 3264”中，我们可能面临的是一个区间最值或者区间求和的计算任务。线段树的基本思想是将数组或...
poj 3666 Making the Grade (线性结构上的DP )
GejinZ
04-10 678
题意： 给定n个数，问你将他们修改成非增或非减序列的最小花费。最小花费的定义是  假设原数组为 a[1] a[2] a[3] .... a[n] 修改后数组为 b[1] b[2] b[3] .... b[n] 那么最小花费为|a[1]-b[1]|+|a[2]-b[2]|+| a[3] - b[3] |+.....| a[n] - b[n] |. 思路： 线性结构上的动态规划 定义状态d
【题解】Making The Grade(DP+结论)
weixin_30239339的博客
05-14 423
【题解】Making The Grade(DP+结论) VJ:Making the Grade HNOI-D2-T3 原题，禁赛三年。 或许是我做过的最简单的DP题了吧(一遍过是什么东西) 之前做过关于绝对值的题目，这种要求绝对值最小的题目，有一个很普遍的结论，最优解的集合中，一定有一个满足所有元素一定是所给定的元素中的元素，具体证明或许就是把括号拆开或者反证法吧。 然后就是这种看起来是\(O(n...
poj 3666 Making the Grade & zoj 3512 Financial Fraud 左偏树 or dp
diufeng0879的博客
02-02 98
//poj 3666 //分析：只是在2005年集训队论文黄源河提到的题目上略微有一点点变化 1 #include"iostream" 2 #include"cstdio" 3 using namespace std; 4 const int maxn = 2100; 5 int v[maxn],l[maxn],r[maxn],d[maxn]; //节点信...
Making the Grade (bzoj1592)题解
weixin_33781606的博客
08-02 415
　　 问题 A: Making the Grade (bzoj1592) 时间限制:1 Sec内存限制:128 MB 题目描述 FJ打算好好修一下农场中某条凹凸不平的土路。按奶牛们的要求，修好后的路面高度应当单调上升或单调下降，也就是说，高度上升与高度下降的路段不能同时出现在修好的路中。 整条路被分成了N段，N个整数A_1, ... , A_N (1 <= N...
可并堆 poj3016 不平衡的美
huyuncong的专栏
07-25 1509
左偏树
POJ-3666 Making the Grade 【动态规划DP+滚动数组】
君兮月影的博客
11-05 224
题目传送门 题目：输入n个数，第i个数字的值为a[i]，把第i个数变为j的代价为a[i]-j的绝对值，求把这n个数组成的数列变成单调数列的最小代价。 题解：dp[i][j]表示前i个数最大值为b[j]时的最小代价，即第i个数在总数列中的值为第j小的时候的最小代价。 动态转移方程：dp[i][j]=minn+Abs(a[i]-b[j])。 其中minn=min(dp[i-1][1]，dp[i...
poj3666(dp逻辑的重要性)
摆渡人的博客
12-20 623
思路：不知道为啥中间有一段时间没搞清楚状态时怎么转移的，想了好久，不过最后还是想明白了。在想状态转移的时候一定要牢牢抓住状态，通过状态来思考如何转移；第一次提交得到了完美的TLE，因为复杂度是n^3(其实当时也想到了，不过抱着侥幸的心理提交了)；上网查了查题解，别的都是一样的，就在判断最小dp值时，每次都历遍造成了重复计算，优化一下，每次都记录最小值minn，那么后面一个直接跟minn比，就得到了...
POJ 3666 Making the Grade（DP）
AC_Arthur的专栏
02-12 2673
题目链接：点击打开链接 题意：给n个数， 要求把这个数列变成非减或者非增数列， 求最小该变量之和。 思路：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值