东华oj121-129

最新推荐文章于 2024-07-14 11:30:37 发布
最新推荐文章于 2024-07-14 11:30:37 发布
阅读量389 收藏 3
点赞数 1
文章标签： 动态规划 贪心算法 算法 东华oj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51183095/article/details/123169837
版权

在这里插入图片描述
在这里插入图片描述
算法概述：这个题的关键是“二进制无进位的加法”实际上说的是异或，也就是
二进制中的“同0异1”的操作。
先判断所有糖果价值的异或（符号为^）是不是0，
如果是0，那么肯定能分成“价值”
相等的两堆（因为两个相同二进制数的异或为0），而如果异或结果为0，那么肖恩
能得到的最大的价值的情况一定是“一堆放那个最小价值的，另一堆放除了最小以外的”
因为如果所有糖果价值的异或为0，那么【最小的糖果价值】和【除了最小之外的其他
糖果】的一定是“价值”（也就是二进制）相等的（因为如果”价值“不等的话所有
糖果的异或不可能是0），所以只需要把最小的那个揪出来把其他的加起来就是肖恩
能得到的最大的价值了
如果是1，那么不可能分成“价值”相等的两堆

#include <bits/stdc++.h>
using namespace std; 
#define MAX_SIZE 12

int main() {
	int i = 0;
	int sum = 0;// 糖果真正价值总和 
	int min = 105; 
	int T = 0, N = 0;
	int C[MAX_SIZE] = {0};
	int xorSum = 0;// 糖果价值的异或和 
	
	scanf("%d", &T);
	while (T--) {
		min = 105, sum = 0;
		
		scanf("%d", &N);
		scanf("%d", &C[0]);
		sum += C[0];
		if (C[0] < min)
			min = C[0];
		xorSum = C[0];
		for (i = 1; i < N; i++) {// 累加糖果价值的异或 
			scanf("%d", &C[i]);
			sum += C[i]; 
			xorSum ^= C[i]; 
			if (C[i] < min)
				min = C[i];// 更新最小 
		}
		
		if (xorSum == 0)// 能分成价值相等的两堆 
			printf("%d\n", sum - min);
		else 
			printf("NO\n");
	}
	
	return 0;
}

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std; 
#define MAX_SIZE 10

int isLoopingNum(int n);

int main() {
	int M = 0, i = 0;
	
	scanf("%d", &M);
	i = M + 1;
	while (1) {
		if (isLoopingNum(i)) {
			printf("%d\n", i);
			break;
		}
		else 
			i++;
	}
	
	return 0;
} 

// 判断循环数
int isLoopingNum(int n) {
	int i = 0, j = 0;
	int num = 0;// 前一个被选中的数 
	int temp = 0;
	int count = 0;// 已选的数字个数 
	int digitAmt = 0;// 一个数包含的数字个数 
	int flag[10] = {0};// flag[i]=1表示数字i在某个数的已经出现 
	int stack[MAX_SIZE] = {0};// 保存一个数的各个位 
	
	while (n) {
		if (flag[n % 10] == 1 || n % 10 == 0)// 有重复数字或者有零，不是循环数 
			return 0;
		
		stack[i++] = n % 10;
		flag[n % 10] = 1;// 标记某个数字已经出现 
		n /= 10; 
	} 
	digitAmt = i; 
	
	for (j = 0; j < i / 2; j++) {// 翻转各位数字 
		temp = stack[j];
		stack[j] = stack[i - j - 1];
		stack[i - j - 1] = temp;
	}
	
	i = 0;
	count++;
	num = stack[i];
	memset(flag, 0, sizeof(flag));// 重置标记 
	flag[num] = 1; 
	while (count < digitAmt) {// 循环取数 
		i = (i + num) % digitAmt;
		count++;
		if (flag[stack[i]] == 1)// 数字已经出现，不是循环数 
			return 0; 
		else {
			num = stack[i];
			flag[num] = 1;// 标记数字 
		}
	}
	if ((i + num) % digitAmt != 0)// 没有回到起点，不是循环数
		return 0;
	return 1; 
}

在这里插入图片描述

#include <bits/stdc++.h>
#include <iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<stack>
#define M 25
#define INF 0x7fffffff
typedef long long ll;
using namespace std;
int n;
int num[M][M];
void solve()
{
    memset(num,-1,sizeof(num));
    int i,j,t=1,t1,t2;
    for(i=1; i<=n+1; ++i)
    {
        int x,k=0;
        if(i&1)     //若为奇数组则首项为n+i，
        {
            x=n+i;
            t1=x;
            num[i][k++]=t1;
            for(j=0; j<i-1; ++j)
            {
                x-=2;
                t1=x;
                num[i][k++]=t1;
            }
            }
        else       //偶数组则首项为n-i+2
        {
            x=n-i+2;
            t2=x;
            num[i][k++]=t2;
            for(j=0; j<i-1; ++j)
            {
                x+=2;
                t2=x;
                num[i][k++]=t2;
            }
        }
    }
    for(i=2;i<=n+1;++i){
        for(j=0;num[i][j]!=-1;++j){
          //  printf("%d",)
            if(t%20==0)printf("%d\n",num[i][j]);
            else
                printf("%d ",num[i][j]);
            t++;
        }
    }
    if(t%20==0)
        printf("\n%d",num[n][0]);
    else
        printf("%d",num[n][0]);
    for(i=n;i>=1;--i)
    {
        for(j=0;num[i][j]!=-1;++j)
        {
            if(i==n&&j==0) continue;
             if(t%20==0)printf("\n%d",num[i][j]);
            else
                printf(" %d",num[i][j]);
            t++;
        }
    }
    printf("\n");
}
int main()
{
   // freopen("xx.in","r",stdin);
  //  freopen("xx.out","w",stdout);
    while(scanf("%d",&n),n)
    {
       // printf("%d=\n",n);
       solve();
    }
    //cout << "Hello world!" << endl;
    return 0;
}

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;

#define lowbit(a) (a&(-a))
#define _mid(a,b) ((a+b)/2)
#define _mem(a,b) memset(a,0,(b+3)<<2)
#define fori(a) for(int i=0;i<a;i++)
#define forj(a) for(int j=0;j<a;j++)
#define ifor(a) for(int i=1;i<=a;i++)
#define jfor(a) for(int j=1;j<=a;j++)
#define mem(a,b) memset(a,b,sizeof(a))
#define IN freopen("in.txt","r",stdin)
#define OUT freopen("out.txt","w",stdout)
#define IO do{\
    ios::sync_with_stdio(false);\
    cin.tie(0);\
    cout.tie(0);}while(0)
#define mp(a,b) make_pair(a,b)
#define debug(a) cout <<(a) << endl
using namespace std;
typedef long long ll;
const int maxn =  2*1e5+9;
const int INF = 0x3f3f3f3f;
const int inf = 0x3f;
const double EPS = 1e-7;
const double Pi = acos(-1);
const int MOD = 1e9+7;
int c[maxn];
pair <int,int>buf;
map< pair<int,int>,int>q;   //标记数对是否出现，如果a/b为纯循环小数的话，<a,b>这个数对一定会反复出现

int getnum(int a,int b,int flag) {      //flag = 1时计算循环部分，否则计算非循环部分
    mem(c,0);
    q.clear();
    int cnt = 0;
    while(cnt <= 1e5) {             //迭代相除      
        buf.first = a;
        buf.second = b;
        if(q[buf]) {            //如果数对用过，则证明从这里开始循环了
            if(flag)
                return cnt-1;
            break;
        }
        q[buf] = cnt;
        /*相除*************/
        if(a > b)
            c[cnt++] = a/b,a %= b;
        else if(a==b) {
            buf.first = 0;
            c[cnt++] = 1;
            return cnt;
        } else
            c[cnt++] = 0;
        a *= 10;
        /****************/
    }
    return q[buf];
}

int jugecnt(int a){int ans = 0;while(a) ans++,a/=10;return ans?ans:1;}  //判断数组内存的数字位数
int main() {
    int a,b;
    int cnt = 0;
    bool flag = false;
    cin >>a >> b;
    int cntline = 0;            //记录每行输出了几个字符

    int e = getnum(a,b,0);      //算出不循环部分，然后剩下的两个数相除一定是循环小数
    fori(e) {
        if(i==1)
            cout <<".",cntline++;
        cout << c[i],cntline+=jugecnt(c[i]);
    }
    if(e >= 2)
        flag = true;
    if(e <= 1)
        cout <<".",cntline++;


    e = getnum(buf.first,buf.second,1); // 计算循环部分
    if(!(e<=1&&c[e-1]==0)){
        cout <<"(",cntline++;
        fori(e){
            cout << c[i],cntline+=jugecnt(c[i]);
            if(cntline ==76){
                cout << endl;
                cntline = 0;
            }
        }
        cout <<")",cntline++;
    }
    else if(!flag)
        fori(e){
            cout << c[i],cntline++;
            if(cntline ==76){
                cout << endl;
                cntline = 0;
            }
        }
    cout <<endl;
    return 0;
}

在这里插入图片描述
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
#define CHAR_MAX_SIZE 25

// 每个字母和数字对应的镜面字母（如果没有就用空格表示） 
char charMirror[] = "A   3  HIL JM O   2TUVWXY5", digitMirror[] = "O1SE Z  8 "; 
int isPalin(char str[]);
int isMirror(char str[]); 

int main() {
	char str[CHAR_MAX_SIZE] = "";
	int palinTag = 0, mirrorTag = 0;// 回文、镜面回文标记 

	while (scanf("%s", str) != EOF) {// 测试用例NOTAPALINDROME结果不对 
		palinTag = isPalin(str);
		mirrorTag = isMirror(str);
		
		if (!palinTag && !mirrorTag) 
			printf("%s -- is not a palindrome.\n\n", str);
		if (palinTag && !mirrorTag) 
			printf("%s -- is a regular palindrome.\n\n", str);
		if (!palinTag && mirrorTag) 
			printf("%s -- is a mirrored string.\n\n", str);
		if (palinTag && mirrorTag) 
			printf("%s -- is a mirrored palindrome.\n\n", str);
	} 	
	
	return 0;
}

// 判断回文字符串
int isPalin(char str[]) {
	int i = 0;
	char strCopy[CHAR_MAX_SIZE] = "";
	strcpy(strCopy, str); 
	int len = strlen(strCopy); 
		
	for (i = 0; i < len / 2; i++) {
		if (strCopy[i] != strCopy[len - i - 1])
			return 0;
	}
	
	return 1;
}

// 判断镜面回文
// 只要处于对称位置的两个字符互为镜面字符就可以了 
int isMirror(char str[]) {
	int i = 0;
	int len = strlen(str);
	for (i = 0; i < len / 2; i++) {
		if (str[i] >= 'A' && str[i] <= 'Z') {// 当前字符为字母
			if (str[len - i - 1] != charMirror[str[i] - 'A'])
				return 0;
		} 
		else {// 当前字符为数字
			if (str[len - i - 1] == '0' && 'O' != digitMirror[str[i] - '0'])
				return 0;
			if (str[len - i - 1] != digitMirror[str[i] - '0'])
				return 0;
		} 
	}
	
	return 1; 
}

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;

void DFS(int sum, int index, int nowk);
int k,n,type=0,num[100];
int main()
{
	int i;

	 while (scanf("%d",&n) != EOF)
    {
		for (i = 0; i < n; i++)
			 scanf("%d", &num[i]);

        type=0;
         for(k=1;k<=n;k++)
         {
               DFS(0, 0, 0);
         }

             printf("%d\n",type);


    }
return 0;

}

void DFS(int sum, int index, int nowk)
{

    if(nowk==k&&sum%11==0&&sum!=0)
    {
        type++;
        return ;
    }
    if(index==n||nowk>k)
        return ;//死胡同 

	DFS(sum , index + 1,nowk);  //不选择第index件物品
	DFS(sum+num[index], index + 1, nowk+1); //选择第index件物品     
}

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;

int purePrimes[10][100];// 存放所有的纯素数，如nums[1][2]表示的是一维的第二个纯素数   
int count_number[100];
int pure_prime(int number){
		if(number==1)
		return 0;
	int i;
	for(i=2;i<=number/2;i++)
		if(number%i==0)
			return 0;
	if(i>number/2)
		return 1;
}
//x代表纯素数 dimen代表维数  count_number代表当前维数第几个 
void dfs(int x,int dimen,int number)
{
	if(dimen>8)
		return ;
	purePrimes[dimen][number]=x;
	int i;
	for(i=1;i<10;i++) //if 10*x+i是素数  那么舍去尾数i 则10*x+1必是纯素数 
	{
			if(pure_prime(10*x+i))
			dfs(10*x+i,dimen+1,++count_number[dimen+1]);
		}
}
int main(){
		int N;
		scanf("%d",&N);
		int i;
		//count_number[100]={0};
			for(i=2;i<10;i++)
		{	if(pure_prime(i))	// 先将所有的纯素数求出来 
			dfs(i,1,++count_number[1]);
			} 
		while(N--)
		{	
			int T;
			scanf("%d",&T);	//不能提前输入 否则会超时	
		for( i=1;i<=count_number[T];i++)
			printf("%d\n",purePrimes[T][i]);
	}
	return 0;
}

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;

int step=0;
int m=0;
int flag=0;
void move(int id,char X,char Y){
	step++;
	if(step==m){
		printf("%c--%c\n",X,Y);
		flag=1;
	}
}
void hanoi(int n,char A,char B,char C){
	if(n==0)return;
	hanoi(n-1,A,C,B);
	move(n,A,C);
	hanoi(n-1,B,A,C);
	
}
 
int main(){
	int N;
	while(scanf("%d %d",&N,&m)!=EOF){
		flag=0;step=0;
		hanoi(N,'A','B','C');
		if(!flag){
			printf("none\n");
		}
	}
	return 0;
}

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;

char str[55][1000];

int cmp(const void *a ,const void *b)
{
    char p1[1000],p2[1000]; // 比賽中因為數組開小了，而...... 
    strcpy(p1,(char *)a);   // 做臨時存儲，這是由於數組即指針常量的關係 
    strcpy(p2,(char *)b);
    strcat(p1,(char *)b);   // 不要在 a,b 上直接拼接啊。 
    strcat(p2,(char *)a);
    return strcmp(p2,p1);
}

int main()
{
    int N;
    while(scanf("%d",&N),N)
    {
        for(int i=0;i<N;++i)
            scanf("%s",str[i]);
        qsort(str,N,sizeof(str[0]),cmp);
        for(int i=0;i<N;++i)
            printf("%s",str[i]);
        printf("\n");
    }
    return 0;
}
澜莲Alice
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
A2OJ Enhancer-crx插件
04-03
**A2OJ Enhancer-crx插件**是一款专为编程爱好者和竞赛程序员设计的Chrome浏览器扩展程序，它增强了A2OJ（Algorithm Online Judge）网站的用户体验，使其更具交互性和可视化效果。A2OJ是一个在线编程练习平台，用户...
东华大学2020考研计算机OJ题目解答分享——进阶篇（11）
qq_38344326的博客
03-03 447
11 abc数字 作者: Turbo时间限制: 10S章节: 循环 问题描述 : 明明的爸爸是一位著名的数学家同时也是一位著名的数学启蒙老师。他经常出一些简单而有趣的数学题目来给刚刚接触数学的小朋友做，培养他们对数学的兴趣。一天，明明的爸爸想到了这样一个题目。如果有a、b、c三个1位的正整数，那么按以下的方法构成2个三位数：第一种方法是a为百位，b为十位，c为个位，构成的数就是abc；第二种方法是...
东华oj-进阶题第90题-循环数
qq_41409120的博客
03-21 426
89 分糖果 作者: xxx时间限制: 10S章节: 一维数组 问题描述 : 肖恩和帕特里克是兄弟，他们从他们的父母那里得到了很多糖果。每一块糖具有一个正整数的价值，孩子们希望分他们得到的糖果。首先，肖恩将这些糖果分成两堆，并选择一堆给帕特里克。然后，帕特里克将尝试计算每堆的价值，其中每堆的价值是那堆糖果价值的总和，如果他觉得没有平等的价值，他将开始哭了起来。 不幸的是，帕特里克太小了，所以不能...
东华oj系统 126 数列2
weixin_50336369的博客
02-16 283
126 数列2 作者: frankhuhu时间限制: 10S章节: 一维数组 问题描述 : 思维的严密性是相当重要的，尤其是在程序设计中，一个小小的错误，就可能导致无法想象的后果。明明的爸爸是一名富有经验的程序设计专家，深知思维严密的重要性，于是在明明很小的时候，就通过游戏的方式，训练明明的思维严密性。今天，明明的爸爸和明明做了一个数列的游戏。这个游戏很简单，就是有一数列，现在需要在这数列中选出一个或者若干个数（可以不连续），要求这些数的和能被11整除。明明的爸爸想锻炼明明思维的严密性，因此要求明明尽可能多
东华OJ 进阶11 abc数字
Sanbai__的博客
02-26 472
问题描述 : 明明的爸爸是一位著名的数学家同时也是一位著名的数学启蒙老师。他经常出一些简单而有趣的数学题目来给刚刚接触数学的小朋友做，培养他们对数学的兴趣。一天，明明的爸爸想到了这样一个题目。如果有a、b、c三个1位的正整数，那么按以下的方法构成2个三位数：第一种方法是a为百位，b为十位，c为个位，构成的数就是abc；第二种方法是c为百位，b为十位，a为个位，构成的数就是cba；然后将这两个三位...
C语言基础-计算各个位数之差大于0的数
黑盒科技的博客
07-25 502
题目描述 给定若干个四位数，求出其中满足以下条件的数的个数： 个位数上的数字减去千位数上的数字，再减去百位数上的数字， 再减去十位数上的数字的结果大于零。 输入 输入为两行，第一行为四位数的个数n，第二行为n个的四位数，数与数之间以一个空格分开。(n <= 100) 输出 输出为一行，包含一个整数，表示满足条件的四位数的个数。 样例输入 5 1234 1349 6119 2123 5017 样例输出 3 代码实现 #include "stdio.h" bool checkNum(int nu
农大OJ 1-163.zip
01-03
【农大OJ 1-163.zip】是一个压缩包文件，包含了河南农业大学在线判题系统（Online Judge，简称OJ）中的1到163号编程题目对应的Java语言解决方案。在线判题系统是教育机构常用的一种工具，用于检验学生编程能力，它...
OJ IRC-开源
04-30
**OJ IRC 开源项目详解** `OJ IRC` 是一个基于Java开发的开源IRC（Internet Relay Chat）客户端，旨在为用户提供便捷、功能丰富的在线聊天体验。IRC是一种实时的网络通信协议，主要用于创建多用户聊天室，允许用户...
课程资源 杭电OJ1000-1099答案
07-23
《杭电OJ1000-1099答案：探索编程竞赛的智慧宝典》 编程竞赛，特别是杭州电子科技大学（简称杭电）的在线判题系统（Online Judge，简称OJ），是锻炼和提升编程技能的重要平台。这个压缩包文件包含了杭电OJ1000至...
HP officejet 5200系列打印机初始固件 OJ5200-1904A
11-23
全网唯一HP officejet 5200系列打印机初始固件 OJ5200_1904A，用于固件退回，专治升级固件后无法识别墨盒问题
16 数字串处理
HurryBen的博客
10-15 310
16数字串处理 作者:ZhouMingLiang时间限制:10S章节:循环 问题描述 : 明明的爸爸经常对明明进行数学启蒙教育。有一天他和明明做了一个游戏，对一串数字进行处理。明明的爸爸首先给明明一串数字，在这串数字中有很多数字会连续重复出现很多次，爸爸就要求明明把其中连续重复出现次数最多的那个数字找出来。如果有很多个数字连续出现的次数相同，即重复出现次数最多的数字不止一个，那就要明...
算法学习day10（贪心算法）
2301_78191305的博客
07-10 1887
贪心算法
217.贪心算法：加油站(力扣)
weixin_63779802的博客
07-12 366
【代码】217.贪心算法：加油站(力扣)
数据结构与算法-09贪心算法&动态规划
qq_40469712的博客
07-11 936
贪心算法（Greedy Algorithm）是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致结果是全局最好或最优的算法。贪心算法通常用于解决优化问题，如最小化成本、最大化收益等。然而，贪心算法并不总是能够得到全局最优解，但它具有直观、高效、易于实现等优点，因此在许多实际问题中得到了广泛应用。基本思想贪心算法总是从问题的某一个初始解出发。在每一步决策中，它总是做出在当前状态下最好或最优的选择，即局部最优解。通过每一步的局部最优选择，希望能够导致全局最优解。
贪心算法案例
最新发布
weixin_69039908的博客
07-14 278
的区间 (li​,ri​] 使得如下的等式最大化，res = (prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0]) = prices[3] - prices[0]。假如元素把比他小，赋值给该变量，否则让该元素减去minPrice当前最小元素，如果比已知的最大利润大，那就赋值给最大利润。解法：遍历数组每一个元素，设置一个变量为minPrice为整数类型最大数，让每个元素跟他比较，如果你不能获取任何利润，返回。
218.贪心算法：分发糖果（力扣）
weixin_63779802的博客
07-12 998
在这个循环中，如果当前孩子的评分比他后一个孩子的评分高（`ratings[i]>ratings[i+1]`），则当前孩子的糖果数应该是他后一个孩子的糖果数加1和他当前糖果数中的较大值（`candyNum[i]=max(candyNum[i+1]+1,candyNum[i]);在这个循环中，如果当前孩子的评分比他前一个孩子的评分高（`ratings[i]>ratings[i-1]`），则当前孩子的糖果数应该比前一个孩子的糖果数多1（`candyNum[i]=candyNum[i-1]+1;
函数模板与类模板
程序员_小兵
07-12 1552
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
36. Adam 算法详解
qq_41238579的博客
07-10 969
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
基于Big-Bang-Big-Crunch(BBBC)算法的目标函数最小值计算matlab仿真
熟悉python,matlab,C,C++,JAVA等
07-12 373
BBBC算法的核心思想模拟了宇宙从大爆炸（Big Bang）开始，经历扩张，再到可能的大收缩（Big Crunch）的过程，以此类比于在解空间中从初始分散的解集出发，通过一系列搜索过程逐步集中并接近最优解的过程。：一个简化的聚集方法可以是xi′′​=xbest​+β⋅(xi′​−xbest​)，其中xbest​是最优解，β是一个小于1的收缩因子，控制收缩速度。：每个解xi​依据一定的规则在解空间中移动，这个移动可以是随机的，也可以基于某种策略，比如基于目标函数梯度的方向或者利用当前解与其他解的相对位置。
杭电oj1000-1100
11-10
杭州电子科技大学在线评测系统（杭电OJ）中的题目1000-1100是一系列编程题，我将分别进行回答。 1000题是一个简单的入门题，要求计算两个整数的和。我们可以使用一个简单的算法，读取输入的两个整数，然后将它们...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值