ACM常用模板 ver1.0

最新推荐文章于 2024-06-04 22:50:27 发布
最新推荐文章于 2024-06-04 22:50:27 发布
阅读量603 收藏
点赞数
分类专栏： 模板 文章标签： 算法 贪心算法 字符串 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csxylrf/article/details/124117475
版权

ACM模板（临时）

ver1.0,待更新

文章目录

一.数据结构

KMP
#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+7;
int ne[N];
string s1,s2;
int len1 ,len2;
void init(){
    int ix1 = 0,ix2= -1;
    ne[0] = -1;
    while(ix1<len1){
        if(ix2==-1||s1[ix2]==s1[ix1]){
            ne[++ix1]=++ix2;
        }
        else ix2 = ne[ix2]; 
    }
}
void KMP(){
    int ix1 = 0,ix2 =0;
    while(ix1<len2){
        if(ix2==-1||s2[ix1]==s1[ix2]) ix1++,ix2++;
        else ix2 = ne[ix2];
        if(ix2 == len1){
            cout<< ix1-len1<<" " ;
        }
    }
}
int main(){
    int n;
    cin>>n>>s1>>n>>s2;
    len1 = s1.length();
    len2 = s2.length();
    init();
    KMP();
    return 0;
}
Trie 树
const int N = 1e6+7;
int son[N][26],cnt[N],idx=0;
void insert(string str){
    int p = 0;
    for(int i = 0;str[i];i++){
        int u = str[i] - 'a';
        if(!son[p][u]) son[p][u] = ++idx;
        p = son[p][u];
    }
    cnt[p]++;
}
int query(string str){
    int p = 0;
    for(int i = 0;str[i];i++){
        int u = str[i] - 'a';
        if(!son[p][u]) return 0;
        p = son[p][u];
    }
    return cnt[p];
}
带权并查集
食物链

动物王国中有三类动物 A,B,C，A 吃 B，B 吃 C，C 吃 A。现有 N 个动物，以 1∼N 编号。

每个动物都是 A,B,C 中的一种，但是我们并不知道它到底是哪一种。

第一种说法是 1 X Y，表示 X 和 Y 是同类。

第二种说法是 2 X Y，表示 X 吃 Y。

此人对 N 个动物，用上述两种说法，一句接一句地说出 K 句话，这 K 句话有的是真的，有的是假的。

当一句话满足下列三条之一时，这句话就是假话，否则就是真话。

当前的话与前面的某些真的话冲突，就是假话；
当前的话中 X 或 Y 比 N 大，就是假话；
当前的话表示 X 吃 X，就是假话。
你的任务是根据给定的 N 和 K 句话，输出假话的总数。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+7;
int A[N],d[N];
int find(int x){
    if(A[x]!=x) {
        int t = find(A[x]);
        d[x] += d[A[x]];
        A[x] = t; 
    }
    return A[x]; 
}
int main(){
    int n,m;
    cin>>n>>m;
    for(int i = 1;i<=n;i++) A[i] = i;
    int res = 0;
    for(int i = 1;i<=m;i++){
        int t,x,y;
        cin>>t>>x>>y;
        int px = find(x),py = find(y);
        if(x>n||y>n) res++;
        else {
            if(t==1) {
                if(px==py&&(d[x]-d[y])%3)res++;
                else if(px!=py){
                    A[px] =py;
                    d[px] = d[y]-d[x];
                }
            }
            else {
                if(px==py&&(d[x]-d[y]-1)%3) res++;
                else if(px!=py){
                    A[px] = py;
                    d[px] = d[y]-d[x]+1;
                }
            }
        }
    } 
    cout<<res<<endl;
    return 0;
}
字符串哈希
841. 字符串哈希

给定一个长度为 n 的字符串，再给定 m 个询问，每个询问包含四个整数 l1,r1,l2,r2，请你判断 [l1,r1] 和 [l2,r2] 这两个区间所包含的字符串子串是否完全相同。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+7;
typedef unsigned long long ull;
const int I = 131;
ull p[N]={1},h[N],n,q;
char s[N]; 
ull check(int l,int r){
    return h[r]-h[l-1]*p[r-l+1];
}
int main(){
    scanf("%d%d%s",&n,&q,s+1); 
    for(int i = 1;i<=n;i++){
        p[i] = p[i-1]*I;
        h[i] = I*h[i-1] + s[i];
    }
    while(q--){
        int l,r,ll,rr;
        cin>>l>>r>>ll>>rr;
        if(check(l,r)==check(ll,rr)) cout<<"Yes"<<endl;
        else cout<<"No\n";  
    }
    return 0;
}
线段树
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+7;
typedef long long ll;
ll A[N];
ll n,m,p;
struct TREE{
	ll val,lazy=0,mul=1;
}tree[N*4];
void pushup(ll rt){
	tree[rt].val = (tree[rt*2].val+tree[rt*2+1].val)%p;
} 
void build(ll l,ll r,ll rt){
	if(l==r) {
		tree[rt].val = A[l];
		return ;
	}
	ll mid = (l+r)/2;
	build(l,mid,rt*2);build(mid+1,r,rt*2+1);
	pushup(rt);
}
void pushdown(ll l,ll r,ll rt){
	tree[rt*2].val = (tree[rt].mul*tree[rt*2].val+tree[rt].lazy*l)%p;
	tree[rt*2+1].val = (tree[rt].mul*tree[rt*2+1].val+tree[rt].lazy*r)%p;
	tree[rt*2].mul = (tree[rt].mul*tree[rt*2].mul)%p;
	tree[rt*2+1].mul = (tree[rt].mul*tree[rt*2+1].mul)%p;
	tree[rt*2].lazy =  (tree[rt*2].lazy*tree[rt].mul+tree[rt].lazy)%p;
	tree[rt*2+1].lazy =  (tree[rt*2+1].lazy*tree[rt].mul+tree[rt].lazy)%p;
	tree[rt].lazy = 0;
	tree[rt].mul = 1;	
}
void updata1(ll L,ll R,ll C,ll l,ll r,ll rt){
	if(l>=L&&r<=R){
		tree[rt].lazy = (C+tree[rt].lazy)%p;
		tree[rt].val = (tree[rt].val+C*(r-l+1))%p;
		return;
	} 	
	ll mid = (l+r)/2;
	pushdown(mid-l+1,r-mid,rt);
	if(mid>=L) updata1(L,R,C,l,mid,rt*2);
	if(mid<R) updata1(L,R,C,mid+1,r,rt*2+1);
	pushup(rt); 
}
void updata2(ll L,ll R,ll C,ll l,ll r,ll rt){
	if(l>=L&&r<=R){
		tree[rt].lazy = tree[rt].lazy*C%p;
		tree[rt].mul = tree[rt].mul*C%p;
		tree[rt].val = (tree[rt].val*C)%p;
		return;
	} 	
	ll mid = (l+r)/2;
	pushdown(mid-l+1,r-mid,rt);
	if(mid>=L) updata2(L,R,C,l,mid,rt*2);
	if(mid<R) updata2(L,R,C,mid+1,r,rt*2+1);
	pushup(rt); 
}
ll ask(ll L,ll R,ll l,ll r,ll rt){
	if(l>=L&&r<=R){
		return tree[rt].val%p;
	} 	
	ll mid = (l+r)/2;
	if(l>R||r<L)return 0;
	pushdown(mid-l+1,r-mid,rt);
	return (ask(L,R,l,mid,rt*2)+ask(L,R,mid+1,r,rt*2+1))%p;
}

int main(){
	cin>>n>>p;
	for(ll i = 1;i<=n;i++){
		cin>>A[i];
	}
	cin>>m;
	build(1,n,1);
	while(m--){
		ll x,y,a,c;
		cin>>a>>x>>y;
		if(a==1) {
			cin>>c;
			updata2(x,y,c,1,n,1);
		}
		else if(a==2){
			cin>>c;
			updata1(x,y,c,1,n,1);
		}
		else cout<<ask(x,y,1,n,1)%p<<'\n';
	}
	return 0;
}

二.数学

欧拉函数

求单个

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e6+7;
int main(){
    int T;
    cin>>T;
    while(T--){
        ll x;
        cin>>x;
        ll res = x;
        for(ll i = 2;i<=x/i;i++){
            if(x%i==0){
                while(x%i==0) x/=i;
                res = res/i*(i-1); 
            }
        }
        if(x>1) res = res/x*(x-1);
        cout<<res<<endl;
    }
    return 0;
}

线性求

void get_eulers(int n)
{
    phi[1] = 1;
    for (int i = 2; i <= n; i++)
    {
        if (!st[i])
        {
            primes[cnt++] = i;
            phi[i] = i - 1; 
        }
        for (int j = 0; primes[j] <= n / i; j++)
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0)
            {
                phi[primes[j] * i] = phi[i] * primes[j]; 
                break;
            }
            phi[primes[j] * i] = phi[i] * (primes[j] - 1);
        }
    }
}
求逆元

1.费马小定理 inv[i] = pow(i,p-2) p为质数
2.exgcd

ll exgcd(ll a,ll b,ll & x,ll &y)
{
	if(!b){
		x = 1;
		y = 0;
		return a;
	}
	ll d = exgcd(b,a%b,y,x);
	y -= x*(a/b);
	return d;
}

3 . 线性递推

void init(){
	inv[1] = 1;
	for(int i = 2;i <= N;i++){
	inv[i] = (p - p / i) * inv[p % i] % p;
	}
}
组合数
  1. 递推
void init(){
    for(int i=0;i<4000;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;
        }
    }
}

2.公式 Cba=a!/b!(a−b)!=a!∗b!−1∗(a−b)!−1
即求（b!）逆元和（a-b)!-1的逆元，递推即可
3.卢卡斯公式

int quick_power(int a, int k, int p)
{
    int res = 1;
    while (k) {
        if (k & 1) {
            res = (ll)res * a % p;
        }
        k >>= 1;
        a = (ll)a * a % p;
    }
    return res;
}

int C(int a, int b, int p)
{
    if (b > a) {
        return 0;
    }
    int res = 1;
    for (int i = 1, j = a; i <= b; i++, j--) {
        res = (ll)res * j % p;
        res = (ll)res * quick_power(i, p - 2, p) % p;
    }
    return res;
}
int lucas(ll a, ll b, int p)//a个里面调b个
{
    if (a < p && b < p) {
        return C(a, b, p);
    }
    return (ll)C(a % p, b % p, p) * lucas(a / p, b / p, p) % p;
}
矩阵加速

斐波那契求和

#include<bits/stdc++.h>
using namespace std;
const int N = 3;
typedef long long ll;
ll n,m;
ll A[N][N] =    // 上述矩阵 A
{
    {2, 0, -1},
    {1, 0, 0},
    {0, 1, 0}
};
ll S[N] = {2,1,0};
void cal(ll A[][N],ll B[][N]){
    ll nw[N][N]={0};
    for(ll i = 0;i<N;i++){
        for(ll j = 0;j<N;j++){
            for(ll k = 0;k<N;k++){
                nw[i][j] += A[i][k]*B[k][j]%m;
            }
        }
    }
    for(ll i = 0;i<N;i++){
        for(ll j = 0;j<N;j++){
            A[i][j] = nw[i][j]%m;
        }
    } 
}
void cal(ll A[],ll B[][N]){
    ll nw[N] = {0};
    for(ll i = 0;i<N;i++){
        for(ll j = 0;j<N;j++){
            nw[i] += A[j]*B[i][j]%m;
        }
    }
    for(ll i = 0;i<N;i++){
        A[i] = nw[i] % m;
    }
}
int  main(){
    cin>>n>>m;
    while(n){
        if(n&1){
            cal(S,A);
        }
        cal(A,A);
        n>>=1; 
    }
    cout<<((S[2]%m+m)%m)<<endl;
    return 0;
}
三.基础算法
RMQ
ll A[N];
ll n;
ll fa[N][30];
int main(){
    cin>>n;
    for(int i = 1;i<=n;i++){
        cin>>A[i];
        fa[i][0] = A[i];
    }
    for(int i = 1;i<25;i++){
        for(int j = 1;(1<<(i-1))+j<=n;j++){
            fa[j][i] = max(fa[j][i-1],fa[j+(1<<(i-1))][i-1]);
        }
    }
    int m;
    cin>>m;
    while(m--){
        ll x,y;
        cin>>x>>y;
        int t=log2(y-x+1);
        cout<<max(fa[x][t],fa[y-(1<<t)+1][t])<<endl;
    }
    return 0;
}
高精度
#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+7;
vector<int> A(N),B(N),C(N);
string s,s2;
int len ,len2;
void input(vector<int > A,int ix){
    if(ix<0) cout<<"0";
    for(int i = ix;i>=0;i--)  
     cout<<A[i]; 
    cout<<endl;
}
bool cmp(vector<int > A,vector<int > B){
    if(len!=len2) return len>len2;
    else {
        for(int i = len-1;i>=0;i--){
            if(A[i]>B[i]) return 1;
            if(A[i]<B[i]) return 0; 
        }
    }
    return 1;
}
void add(){
    int s = 0,i;
    for( i = 0;i<=max(len,len2)+1;i++){
        A[i] = s+A[i]+B[i];
        s = A[i]/10;
        A[i]%=10;
    }
    while(!A[i])i--;
    input(A,i);
}
void sub(){
    int s = 0,i;
    if(cmp(A,B)==0) { C = B;
    B = A;
    A = C; 
    cout<<"-"; 
    }
    for( i = 0;i<max(len,len2);i++){
        if(A[i]-B[i]-s<0) A[i] = (A[i]-s+10-B[i]),s=1;
        else A[i]= A[i]-s-B[i],s=0;
    }
    while(!A[i])i--;
    input(A,i);
} 
void mul(){
    for(int i = 0;i<len;i++){
        for(int j = 0;j<len2;j++){
            C[i+j] += A[i]*B[j];
            C[i+j+1] += C[i+j]/10;
            C[i+j]%=10;  
        }
    }
    int k = len+len2;
    while(!C[k]&&k>0) k--;
    input(C,k);
}
int main(){
    cin>>s>>s2;
    len = s.length();
    len2 = s2.length();
    A.resize(N),B.resize(N),C.resize(N);
    for(int i = len-1,k=0;i>=0;i--,k++) A[k] = s[i]-'0';
    for(int i = len2-1,k=0;i>=0;i--,k++) B[k] = s2[i]-'0';
    return 0;
}
离散化
int C[MAXN], L[MAXN];
// 在main函数中...
memcpy(C, A, sizeof(A)); // 复制
sort(C, C + n); // 排序
int l = unique(C, C + n) - C; // 去重
for (int i = 0; i < n; ++i)
    L[i] = lower_bound(C, C + l, A[i]) - C + 1; // 查找
__int128 手写输入输出
__int128 read(){
	__int128 res = 0;
	int sign = 1;
	char ch;
	if((ch=getchar())=='-1') sign = -1;
	else res = res*10 + ch-'0';
	while((ch=getchar())>='0'&&ch<='9'){
		res = res*10 + ch-'0';
	}
	res *= sign;
	return res;
} 
void print(__int128 x ){
	if(x<0){
		x = -x;
		printf("-");
	}
	if(x>9) print(x/10);
	putchar(x%10 + '0');
}
二分

1答案的最大值，[l, r]划分成[l, mid]和[mid + 1, r]

int bsearch_1(int l, int r)
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;
        else l = mid + 1;
    }
    return l;
}

2.答案的最小值,[l, r]划分成[l, mid - 1]和[mid, r]

int bsearch_2(int l, int r)
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    return l;
}

四.DP

数位DP
int dp[2000][10],A[N]; 
long long dfs(int pos ,int limit,int lead,int pre){
    long long ans = 0;
    if(pos<0) return 1;
    if(!limit&&!lead&&dp[pos][pre]!=-1) return dp[pos][pre];
    int up = limit?A[pos]:9;
    for(int i = 0;i<=up;i++){
        if(lead||abs(pre-i)>=2) ans+=dfs(pos-1,limit&&i==up,lead&&i==0,i);
    }
    if(!limit&&!lead) dp[pos][pre] = ans;
    return ans;
}
long long slove(long long x){
    int pos = 0;
    memset(dp,-1,sizeof(dp));
    while(x){
        A[pos++] = x%10;
        x/=10;
    } 
    return dfs(pos-1,1,1,-2);
}
CCSU__LRF
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法模板-2022
m0_51678367的博客
05-12 577
目录:树和图字符串和字典树记忆化搜索排序及逆序对离散化树链剖分素数筛法:同余定理单调栈数学期望LCA 树和图 Acwing285. 没有上司的舞会 Ural 大学有 N 名职员，编号为 1～N。 他们的关系就像一棵以校长为根的树，父节点就是子节点的直接上司。 每个职员有一个快乐指数，用整数 Hi 给出，其中 1≤i≤N。 现在要召开一场周年庆宴会，不过，没有职员愿意和直接上司一起参会。 在满足这个条件的前提下，主办方希望邀请一部分职员参会，使得所有参会职员的快乐指数总和最大，求这个最大值。 输入格式 第一行
解题报告（十七）概率与期望（概率论）（ACM / OI）
繁凡さん的博客
05-10 4012
繁凡出品的全新系列：解题报告系列 —— 超高质量算法题单，配套我写的超高质量题解和代码，题目难度不一定按照题号排序，我会在每道题后面加上题目难度指数（1∼51 \sim 51∼5），以模板题难度 111 为基准。 这样大家在学习算法的时候就可以执行这样的流程： % 阅读我的【学习笔记】 / 【算法全家桶】学习算法 ⇒\Rightarrow⇒ 阅读我的相应算法的【解题报告】获得高质量题单 ⇒\Rightarrow⇒ 根据我的一句话题解的提示尝试自己解决问题 ⇒\Rightarrow⇒ 点开我的详细题解链.
ACM 算法模板
昔拉的博客
02-07 979
ACM 算法模板 Dinic算法求网络流 #include #include <string.h> #include using namespace std; int const inf = 0x3f3f3f3f; int const MAX = 205; int n, m; int c[MAX][MAX], dep[MAX];//dep[MAX]代表当前层数 int bfs(in...
ACM常用模板V2.0
csxylrf的博客
02-18 284
ACM常见模板
acm模板小结
urp
12-25 619
向量 #include "bits/stdc++.h" using namespace std; const double eps=1e-6; const double PI=acos(-1.0); #define ll long long template<class T> bool scan(T &ret){//快读 char c; int sgn; if(c=getchar(),c==EOF)return 0; while(c!='-'&&(c<'0
刷题常用模板 by flytosky2015
你那么爱笑，家里人知道吗？
02-10 3116
声明模板：#include <iostream> #include <cstdio> #include <cstdlib> #include <cmath> #include <iomanip> #include <algorithm> #include <climits> #include <cstring> #include <string> #include <set> #include <
模板记录——赛前准备
Wa的博客
10-17 550
模板大法好1.素数筛（1）线性筛（欧拉筛）（2）区间筛（）2.并查集（2）种类并查集（3）区间并查集（4）带权并查集3.RMQ（1）基础RMQ（区间最大最小）（2） 区间最频繁次数（只有模板，尚未理解）4.欧拉函数（1）求欧拉函数（2）多次幂下的扩展欧拉降幂5.最长上升子序列（最长下降） 1.素数筛 （1）线性筛（欧拉筛） 取出素数版本外加判断表 int p[maxn]; 保存素数 bool v...
现场赛经验 by CQU ACM/ICPC
acdart
07-29 642
ACM-ICPC现场赛参赛经验 ver1.0 -- CQU-JKi Wang 2013.5 正确的开局：三人分读题目，切记每开始阅读一个新的题目时一定告诉队友，作上标记，以防重复阅 读，浪费资源；开局并非需要一个队员负责调整 IDE，打开 PC^2，写好头文件甚至一些常用模板。(队员α:我英语考试从未及格过… 队员β
【学习笔记】《概率与期望全家桶》（ACM / OI）概率与期望 / 概率论知识小结
繁凡さん的博客
02-25 3586
整理的算法模板合集： ACM模板 点我看算法全家桶系列！！！ 实际上是一个全新的精炼模板整合计划 这块知识很少，但是题很难… 目录0x00 概率0x01 基本概念0x02 古典概率0x03 条件概率0x03.1 乘法公式0x03.2 全概率公式0x03.3 贝叶斯公式0x10 期望0x11 期望的线性性质0x12 利用递推或动态规划解决0x13 建立线性方程组解决 0x00 概率 0x01 基本概念 大量小学数学概念来袭 随机试验： 可在相同条件下重复进行，每次试验的结果可以不止一个且能事先明确所有结
acm常用模板.rar
03-01
C++语言，算法竞赛常用
ACM常用模板 ACM常用模板
07-04
ACM常用模板 ACM常用模板 ACM常用模板 ACM常用模板
acm常用模板-morejarphone2.0.pdf
10-13
某已退役的acm选手的算法模板，欢迎大家来学习交流并提出您宝贵的意见。
ACM常用算法模板.docx
05-20
本文件是一个word文档，ACM竞赛常用的算法、数据结构模板。
ACM常用模板
04-21
涉及一些常用的ACM比赛模板，相对来讲很实用。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。...
Leecode---347：输出前k个高频元素（使用unordered_map）
qq_41920323的博客
05-30 359
unordered_map实现输出前k个高频元素
回溯之分割回文串
最新发布
JINbigXIA的博客
06-04 202
思路：直接看回溯函数的内容，首先我们是取段的，如果这一段不行那就往后面加1，直到加道循环结束。如果可以取端，并且取到了最后一段，也就是开始的startIndex大于等于size那么就代表这一条都是回文字符串。然后需要一个判断函数，判断字符串是否为回文字符串，如果是往path里面加。学到的新函数：array.substr( a ,b) a表示字符串的开始，b表示数量 含义：选取字符串array从a开始往后的b个数。难点：这里用到一个很取段的思路，其实和取点的内容差不多，但是取端更难理解。
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
2201_75456895的博客
05-30 1233
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
算法-找出N个数组的共同元素
Python领域优质萌新创作者
06-02 460
3.1、使用集合的intersection_update方法，将当前编辑的新闻编号集合与common_news_set取交集，并更新common_news_set。1.1、使用集合的交集操作找出被所有编辑共同编辑过的新闻：遍历每个新闻集合进行交集操作，时间复杂度为O(K)，其中K为所有编辑操作的总数。3.2、这样，common_news_set中将保留与当前编辑共同编辑过的新闻编号，即找到所有编辑共同编辑过的新闻编号的交集。news_ids: 一个包含N个列表的列表，每个列表包含一个编辑编辑过的新闻编号。
上海交通大学acm 模板
09-10
上海交通大学ACM模板是指为了方便上海交通大学ACM队伍在参加ACM国内外比赛时，准备的一份包含常用算法模板和数据结构实现的文件。这份模板是ACM队伍日常训练和比赛中必备的工具和参考资料。 ACM模板通常包括多个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值