算法备赛模板（临时）

已于 2023-09-08 08:01:24 修改
阅读量9.4k 收藏
点赞数
分类专栏： # PTA 文章标签： 数据结构 后端 算法
于 2022-04-08 23:55:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46833224/article/details/124053710
版权

⭐简单说两句⭐

作者：后端小知识

CSDN个人主页：后端小知识

🔎GZH：后端小知识

🎉欢迎关注🔎点赞👍收藏⭐️留言📝

文章目录

基础算法

一些技巧算法

前缀和

#include<bits/stdc++.h>
#define ll long long 
#define maxn 1000010
using namespace std; 
int sum[maxn]; 
int main(){
	int n,m;	cin>>n>>m;
	for(int i=1;i<=n;i++){
		int x;	cin>>x;
		sum[i]=sum[i-1]+x; 
	}
	while(m--){
		int l,r;	cin>>l>>r;
		cout<<sum[r]-sum[l-1]<<"\n"; 
	}
	return 0; 
}

差分

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int a[N],b[N];//b数组为差分数组  a 数组是 b 数组的前缀和
int n,m;
int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=n;i++) { cin>>a[i]; b[i]=a[i]-a[i-1]; }
    while(m--){
        int l,r,c;  cin>>l>>r>>c;
        b[l]+=c; b[r+1]-=c;  //这里一定要记住 要给 b[r+1]减去 c ,
    }
    for(int i=1;i<=n;i++){
        a[i]=a[i-1]+b[i]; //求前缀和
        cout<<a[i]<<" ";
    }
    return 0;
}

字符串

回文字符串

#include <bits/stdc++.h>
using namespace std; 
int main() {
    //freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    string s;
    cin >> s;
    int n = s.length();
    bool is = true; //bool 类型的值只有 true 和 false
    for (int i = 0; i < n / 2; i++) {
        if (s[i] != s[n - 1 - i]) {
            is = false;
        }
    }
    cout << (is ? "Yes" : "No") << "\n";
    return 0;
}

数学

前言：

求n的因子：从 1到 sqrt(n) 循环判断即可，不需要从 1 到 n

快速幂模板

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
int ans;//存结果 
//求  a的b次方 对 mode 求余的结果  即  (a^b)%mod 
//思路是将 b 转成二进制 
// 2^16次方  就是 2^8 * 2^8   ,2^8 就是 2^4 * 2^4  ... 
int quickPow(int a,int b,int mod){
	int res=1;
	while(b){
		if(b&1) res=res*a%mod;
		b>>=1;
		a=a*a%mod; 
	}
	return res; 
} 
int main(){
	int a,b,mod;
	cin>>a>>b>>mod;
	ans = quickPow(a,b,mod);
	cout<<ans; 
	return 0; 
}

矩阵快速幂

看不懂就不看

struct Mat
{
    LL m[101][101];
};//存储结构体
Mat a,e; //a是输入的矩阵，e是输出的矩阵
Mat Mul(Mat x,Mat y)
{
    Mat c;
    for(int i=1;i<=n;++i){
        for(int j=1;j<=n;++j){
            c.m[i][j] = 0;
        }
    }
    for(int i=1;i<=n;++i){
        for(int j=1;j<=n;++j){
            for(int k=1;k<=n;++k){
                c.m[i][j] = c.m[i][j]%mod + x.m[i][k]*y.m[k][j]%mod;
            }
        }
    }
    return c;
}
Mat pow(Mat x,LL y)//矩阵快速幂
{
    Mat ans = e;
    while(y){
        if(y&1) ans = Mul(ans,x);
        x = Mul(x,x);
        y>>=1;
    }
    return ans;
}

gcd与lcm

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
// 定理  gcd(a,b)*lcm(a,b) = a*b  
//最大公约数  求 a 与 b 的最大公约数 
int gcd(int a,int b){
	if(b==0) return a;
	return gcd(b,a%b);
}
//最小公倍数 
int lcm(int a,int b){
	return a*b/gcd(a,b); // 
} 
int main(){
	int a,b;
	cin>>a>>b;
	int ans1=gcd(a,b);
	int ans2=lcm(a,b);
	cout<<ans1; 
	cout<<"\n"; 
	cout<<ans2;
	return 0; 
}

闰年判断

#include<bits/stdc++.h>
using namespace std;
int main(){
	ios::sync_with_stdio(false);
	int n;	cin>>n;
	if( (n%4==0&&n%100!=0) || n%400==0) cout<<"yes";
  	else cout<<"no";
	return 0; 
}

质数

判断是不是质数

int f(int x){ //判断 x 是不是质数  
	if(x==1) return 0;
	for(int i=2;i<=sqrt(x);i++) if(x%i==0) return 0;
	return 1;
}

质因数分解

#include<bits/stdc++.h>
using namespace std;
int a,b;
int prime[1000010];//存储质数
int ht[1000010];
struct tx{
	int x,y;
}c[20];
int ans[100];
int ct1=0;
int main(){
	ios::sync_with_stdio(false);
	cin>>a>>b;
	int ct=0;
	for(int i=2;i<=b;i++){//预处理质数
		if(!ht[i]){
			prime[ct++]=i;// 将质数加入到 数组中
			for(int j=i*i;j<b;j=j+i) ht[j]=true;  //将 改质数的倍数全部 标记为合数
		}
	}
	//分解质因数 
	for(int i=a;i<=b;i++){ //对 a  到 b 的每一数进行分解
		int t=i;
		int len=0;
		for(int j=0;j<ct;j++){ //这里是核心
			if(t%prime[j]==0){
				c[len].x=prime[j];
				c[len].y=0;
				while(t%prime[j]==0){
					c[len].y++;
					t/=prime[j];
				}
				len++;
			}
		}
		cout<<i<<"=";
		for(int j=0;j<len;j++){
			int t2 = c[j].y;
			for(int k=0;k<t2;k++){
				ans[ct1++]=c[j].x;
			}
		}
		for(int j=0;j<ct1;j++){
			if(j!=0) cout<<"*"; cout<<ans[j];
		}
		ct1=0;
		cout<<"\n";
//		memset(c,0,sizeof(c));
		memset(ans,0,sizeof(ans));
	}
    return 0;
}

组合

image-20220408231820834

图片来自acwing

https://www.acwing.com/problem/content/887/

普通版的递推求法，还没有优化

#include<bits/stdc++.h>
#define ll long long 
#define maxn 2010 
using namespace std; 
int n;
int mod = 1e9+7;
int c[maxn][maxn];//和数学中的求组合一样， 表示几个中选几个的结果 
void init(){
	for(int i=0;i<=2000;i++){
		for(int j=0;j<=i;j++){
			if(!j) c[i][j]=1;
			else c[i][j]=(c[i-1][j]+c[i-1][j-1])%mod;
		}
	}
} 
int main(){
	init(); 
	cin>>n;
	while(n--){
		int a,b;	cin>>a>>b;
		cout<<c[a][b]<<"\n";
	}
	return 0; 
}

卡特兰数

image-20220409073253643

1 2 5 14 42 132 429

class Solution {
public:
    int numTrees(int n) {
        long long C = 1;
        for (int i = 0; i < n; ++i) {
            C = C * 2 * (2 * i + 1) / (i + 2);
        }
        return (int)C;
    }
};

杨辉三角

普通法

#include<bits/stdc++.h>
using namespace std;
int n;
int a[100][100];//存储杨辉三角每一行的内容
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){//控制行
		for(int j=1;j<=i;j++){
			if(i==j||j==1) a[i][j]=1;//根据观察得出的
			else a[i][j]=a[i-1][j]+a[i-1][j-1]; //根据观察易得
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=i;j++){
			cout<<a[i][j]<<" ";
		}
		cout<<"\n";
	}
	return 0;
}

搜索

全排列

#include<bits/stdc++.h>
using namespace std;
int n;
int a[10];
bool b[10];
int dfs(int x){
    if(x==n){
        for(int i=0;i<n;i++) cout<<a[i]<<" ";
        cout<<"\n";
        return 0;
    }
    for(int i=1;i<=n;i++){
        if(!b[i]){
            a[x]=i;
            b[i]=true;
            dfs(x+1);
            b[i]=false;
        }
    }
}
int main(){
    cin>>n;
    dfs(0);
    return 0;
}

组合

#include<bits/stdc++.h>
using namespace std;
int a[10],b[10];
int n;
void dfs(int x,int st){
    if(x>=3){
        for(int i=0;i<3;i++) cout<<a[i];
        cout<<"\n";
        return ;
    }
    for(int i=st;i<=n;i++){
        if(!b[i]){
            a[x]=i;
            b[i]=true;
            dfs(x+1,st+1);
            b[i]=false;
        }
    }
}
int main(){
    cin>>n;
    dfs(0,1);
    return 0;
}

迷宫

#include<bits/stdc++.h>
using namespace std;
int n,m;
typedef pair<int,int> PII; //用来存点，用pair方便点点
const int N=110; //数据范围
int g[N][N],d[N][N];// g数组装整个图，  d数组表示某点到原点的距离
int bfs(){
    queue<PII> q;
    q.push({0,0});//首先起点入队
    memset(d,-1,sizeof d);//将最开始的所有点到起点的距离都设置为-1
    d[0][0]=0;//起点到起点的距离设置为0,
    int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0}; /*方向数组，随便向那个方向扩展都得行，
    我的是上(x不变，y会加1)右（x会加1，y不变）下（x不变，y会减1）左（x会减1，y不变）*/
    while(!q.empty()){
        auto t = q.front();//取出队首元素
        q.pop();//队首出队
        for(int i=0;i<4;i++){//向4个方向扩展
            // x,y 为扩展后的， t装的是拓展前的坐标
            int x=t.first+dx[i];
            int y=t.second+dy[i];
            //满足边界条件，拓展的点的位置没有障碍，在之前没有被访问过（距离为-1就表示没访问过）
            if(x>=0&&x<n&&y>=0&&y<m&&g[x][y]==0&&d[x][y]==-1){
                d[x][y]=d[t.first][t.second]+1;//更新距离
                q.push({x,y});//将成功扩展的点入队
            }
        }
    }
    return d[n-1][m-1];//最终 d[n-1][m-1] 就是右下角到左上角的需要移动的最短距离
}
int main(){
    cin>>n>>m;
    //读入图的信息
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
            cin>>g[i][j];
    cout<<bfs()<<"\n";//输出结果
}

并查集

#include<bits/stdc++.h>
using namespace std;
// const int n=1000010;
int m,n;
int p[1000010];//存储节点的父亲
int findX(int x){//采用了路径压缩
    if(x!=p[x]) p[x]=findX(p[x]);
    return p[x];
}
int main(){
//    cin.tie(0);
//    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=n;i++) p[i]=i;
    while(m--){
        string x;
        int a,b;
        cin>>x>>a>>b;
        if(x=="M") p[findX(a)] = findX(b);
        else{
            if(findX(a)==findX(b)) cout<<"Yes\n";
            else cout<<"No\n";
        }
    }

    return 0;
}

图

spfa求最短路

#include<bits/stdc++.h>
using namespace std;
#define maxn 1000010
int n,m;
//dist表示某点到起点的距离  
//st表示某个点是否加入队列 true表示没加入,反之则加入 
int dist[maxn],st[maxn];  
// h:头结点  w:权重  e:边  ne:下一个点   idx就表示节点 
int h[maxn],w[maxn],e[maxn],ne[maxn],idx;
void add(int a,int b,int c){//邻接表  模板，背到就可以   
	e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int spfa(){
	memset(dist,0x3f,sizeof(dist));//将初始距离设为很大的数 
	queue<int> q;
	dist[1]=0;// 初始化第一个点到第一个点的距离为 0 ,方便后面的计算 
	q.push(1);// 先将第一个点加入队列 
	st[1]=true;//第一个点加入了队列，所以 st[1] = true 
	while(!q.empty()){//广搜的模板 
		int t = q.front();//取出第一个节点 
		q.pop();//取出了后，就要出队列 
		st[t]=false;//取出后，没在队列了，设置为 false 
		for(int i=h[t];i!=-1;i=ne[i]){//更新t的出边 
			int j = e[i];//获得和t相连的点
			if(dist[j]>dist[t]+w[i]){//如果可以距离变得更短，则更新距离
				dist[j]=dist[t]+w[i];
				if(!st[j]){//如果没在队列中,可以入队 
					q.push(j);
					st[j]=true;//入队了，设置为false 
				} 
			}
		}
	}
	return dist[n]==0x3f3f3f3f?-2:dist[n];
}
int main(){
	cin>>n>>m;
	memset(h,-1,sizeof(h));//这一步不能忘记 
	while(m--){
		int x,y,z;	cin>>x>>y>>z;
		add(x,y,z);
	}
	int ans=spfa();
	if(ans!=-2) cout<<dist[n];
	else cout<<"impossible"; 
	
	return 0;
}

参考了博客：https://www.acwing.com/solution/content/105508/

动态规划

01背包

https://www.acwing.com/problem/content/2/

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
#define maxn 10010
int N,V;// N件物品，V为背包体积 
int v[maxn],w[maxn];// v数组装物品的体积 , w数组装物品的价值 
int dp[10010];
int main(){
	cin>>N>>V;
	for(int i=1;i<=N;i++) cin>>v[i]>>w[i];
	for(int i=1;i<=N;i++){
		for(int j=V;j>=v[i];j--){//dp[j]为 容量为j的背包所背的最大价值 
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);	
		}
	} 
	cout<<dp[V]; 
	return 0; 
}

完全背包

https://www.acwing.com/problem/content/description/3/

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
#define maxn 10010
int N,V;// N件物品，V为背包体积 
int v[maxn],w[maxn];// v数组装物品的体积 , w数组装物品的价值 
int dp[10010];
int main(){
	cin>>N>>V;
	for(int i=1;i<=N;i++) cin>>v[i]>>w[i];
	for(int i=1;i<=N;i++){
		for(int j=v[i];j<=V;j++){//dp[j]为 容量为j的背包所背的最大价值 
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);	
		}
	} 
	cout<<dp[V]; 
	return 0; 
}

多重背包

https://www.acwing.com/problem/content/description/4/

强制拆分成 01 背包来做

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
#define maxn 100010
int N,V;// N件物品，V为背包体积 
int v[maxn],w[maxn];// v数组装物品的体积 , w数组装物品的价值 
int dp[10010];
int len=0;//用来记录 v 与 w 数组的长度 
int main(){
	cin>>N>>V;
	for(int i=1;i<=N;i++){
		int vi,wi,s;	cin>>vi>>wi>>s;
		while(s--){//拆成 01 背包来做
			v[++len]=vi;
			w[len]=wi; 
		} 
	} 
	for(int i=1;i<=len;i++){//这里就是有 len 个物品了
		for(int j=V;j>=v[i];j--){//dp[j]为 容量为j的背包所背的最大价值 
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);	
		}
	} 
	cout<<dp[V]; 
	return 0; 
}

分组背包

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
#define maxn 150
int N,V;// N件物品，V为背包体积 
int v[maxn][maxn],w[maxn][maxn],s[maxn];// v数组装物品的体积 ,w数组装物品的价值 ,s数组表示第每组物品的个数 
int dp[10010];
int len=0;//用来记录 v 与 w 数组的长度 
int main(){
	cin>>N>>V;
	for(int i=1;i<=N;i++){
		cin>>s[i];
		for(int j=0;j<s[i];j++){
			cin>>v[i][j]>>w[i][j];
		}
	} 
	for(int i=1;i<=N;i++){// n组 
		for(int j=V;j>=0;j--){
			for(int k=0;k<s[i];k++){
				if(v[i][k]<=j) dp[j]=max(dp[j],dp[j-v[i][k]]+w[i][k]);
			}
		}
	} 
	cout<<dp[V]; 
	return 0; 
}

【都看到这了，点点赞点点关注呗，爱你们】😚😚

抽象工厂 引导关注

结语

谢谢你的阅读，由于作者水平有限，难免有不足之处，若读者发现问题，还请批评，在留言区留言或者私信告知，我一定会尽快修改的。若各位大佬有什么好的解法，或者有意义的解法都可以在评论区展示额，万分谢谢。
写作不易，望各位老板点点赞，加个关注!😘😘😘

💬

作者：后端小知识

CSDN个人主页：后端小知识

🔎GZH：后端小知识

🎉欢迎关注🔎点赞👍收藏⭐️留言📝

小叮当撩编程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法竞赛模板（背熟）
qq_55092161的博客
03-06 256
模板
分治算法 （模板）
三哥今天没AC
08-03 1092
在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序。一个排列中逆序的总数就称为这个排列的逆序数。 如2 4 3 1中，2 1，4 3，4 1，3 1是逆序，逆序数是4。给出一个整数序列，求该序列的逆序数。 Input 第1行：N，N为序列的长度（n &lt;= 50000)  第2 - N + 1行：序列中的元素（0 &lt;= Aii &lt;...
0基础蓝桥杯60天备赛
2301_79204394的博客
02-13 131
15届蓝桥杯第二期模拟赛题单。
0基础蓝桥杯50天备赛(算法篇）
2301_79204394的博客
02-22 269
（1）全排列：给定一个数字n，请按照字典序输出排列[1,2,...,n]的全排列。1.直接枚举（ for+if )
算法竞赛 Linux操作 Linux 备赛
10-05
介绍Linux系统下vscode的命令 准备CCF相关比赛的OIer 赛前复习 记得保存~~
数据结构与算法比赛常用核心模板板子
04-18
大学四年打比赛用的所有板子，数据结构与算法中常用的核心算法，大家在拿到之后使用最好加以理解，这样才能真正内化到自己的知识库里，量多且实惠，背住你就无敌了
算法比赛模板
03-16
通过一些宏定义等，降低写代码的数量
用于 ACM 类比赛的算法代码模板.zip
06-06
ACM 类比赛的算法代码模板.zip用于 ACM 类比赛的算法代码模板.zip用于 ACM 类比赛的算法代码模板.zip用于 ACM 类比赛的算法代码模板.zip用于 ACM 类比赛的算法代码模板.zip用于 ACM 类比赛的算法代码模板.zip用于 ...
建议收藏算法基础课模板大全
08-12
基础算法 —— 代码模板链接 常用代码模板1——基础算法 排序 二分 高精度 前缀和与差分 双指针算法 位运算 离散化 区间合并 数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 ...
学习记录day18——数据结构 算法
最新发布
weixin_64918301的博客
07-24 293
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
数据结构-＞线性结构-＞顺序存储-＞静态链表
qq_68495605的博客
07-20 260
【代码】数据结构-＞线性结构-＞顺序存储-＞静态链表。
Linux嵌入式学习——数据结构——线性表的链式结构
m0_71703182的博客
07-24 471
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
插入和选择排序
c23856的博客
07-20 501
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
数据结构(5.2_3)——二叉树的存储结构
m0_65240792的博客
07-19 357
1%29%5D1。
数据结构（二叉树-1）
2401_83968713的博客
07-20 1038
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 946
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
数据结构（特殊二叉树-平衡二叉树）
weixin_65029285的博客
07-23 705
待删除节点左右子树非空，则根据左右子树的高度，选择高的一边子树，如果是左子树高，选择左子树中的最大节点赋值给待删除节点，然后再左子树中继续删除该最大节点，相当于继续处理情况1或情况2；由于节点的位置要受到相互之间值的影响，并且在往平衡二叉树中添加节点或者删除节点前，二叉树本身是平衡的，所以只可能在最后操作的节点附近不满足平衡条件，因此需要在该过程中对该节点进行判断并调整。如果一个搜索二叉树呈现或接近单支状，它的查找效率很低，很接近链表，因此如果能让它平衡时，查找效率最高。待删除的节点是叶子节点，直接删除。
数据结构——二叉树定义
鲸落博客
07-23 237
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
ACM-ICPC算法比赛模板大全
"该资源是ACM/ICPC竞赛的算法模板集合，涵盖了广泛的编程技巧和数据结构。" ACM/ICPC（国际大学生程序设计竞赛）是全球性的编程竞赛，对参赛者的算法理解与实现能力有很高要求。这份模板集合提供了一个全面的学习...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小叮当撩编程

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

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

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

打赏作者

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

抵扣说明：

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

余额充值