第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛

最新推荐文章于 2018-03-29 09:41:38 发布
最新推荐文章于 2018-03-29 09:41:38 发布
阅读量220 收藏
点赞数
分类专栏： ACMer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36706625/article/details/79683304
版权

比赛链接：https://www.nowcoder.com/acm/contest/90#question

A：跳台阶

找规律、后面的台阶等于前面的台阶达到方式数+1、

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class A {
    static long [] num = new long [31];
    public static void main(String[] args) throws IOException {
        StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        
        num[0] = 0;
//        num[1] = 1;
//        num[2] = 2;
//        num[3] = 4;
        long sum = 0;
        for(int i = 0; i < 30; i++){
            sum += num[i];
            num[i + 1] = sum + 1; 
        }
        
        in.nextToken(); int t = (int)in.nval;
        while(t-- != 0){
            in.nextToken(); int n = (int)in.nval;
            out.println(num[n]);
            out.flush();
        }
        
    }
    
}

D：psd面试

最长公共子序列的题目

代码一：

import java.util.Scanner;

public class D_ {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        while (input.hasNext()) {
            String s = input.next();
            int len = s.length();
            s = s.toLowerCase();
            int[][] dp = new int[len + 1][len + 1]; // 第i字符到第j字符， 这个子串的最长回文子序列长度
            
            for(int i = 1; i <= len; i++){
                for(int j = 1; j <= len; j++){
                    if(s.charAt(i - 1) == s.charAt(len - j)){
                        dp[i][j] = dp[i - 1][j - 1] + 1;
                    }else{
                        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                    }
                }
            }
            System.out.println(len - dp[len][len]);
        }
    }
}

代码二：

import java.util.Scanner;

public class D {

    static int N = 1240;
    static int dp[][] = new int[N][N];
    static char c1[] = new char[N];
    static char c2[] = new char[N];

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while (input.hasNext()) {
            String s = input.next();
            s = s.toUpperCase();
            c1 = s.toCharArray();
            int n = s.length();
            for (int i = 0; i < n; i++) {
                c2[i] = c1[n - i - 1];
            }
            Init();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (c1[i] == c2[j]) {
                        dp[i + 1][j + 1] = dp[i][j] + 1;
                    } else {
                        dp[i + 1][j + 1] = Math.max(dp[i + 1][j], dp[i][j + 1]);
                    }
                }
            }
            System.out.println(n - dp[n][n]);
        }

    }

    public static void Init() {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                dp[i][j] = 0;
            }
        }
    }

}

E:回旋星空

枚举所有星星两两之间的距离、然后找两者相距相等的、有很多都是一样的、就这些中取2个 c (2, n) * 2 // 前后和后前算两种、

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;

public class E {

    public static void main(String[] args) throws IOException {
        StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        Node node[] = new Node[1005];
        for(int i = 0; i < 1005; i++){
            node[i] = new Node();
        }
        int d[] = new int[1005];
        in.nextToken();
        int T = (int) in.nval;
        int xx, yy;
        while (T-- != 0) {
            int ans = 0;
            in.nextToken();
            int n = (int) in.nval;
            for (int i = 1; i <= n; i++) {
                in.nextToken();
                node[i].x = (int) in.nval;
                in.nextToken();
                node[i].y = (int) in.nval;
            }

            for (int i = 1; i <= n; i++) {
                int cnt = 0;
                for (int j = 1; j <= n; j++) {
                    if (i == j) {
                        continue;
                    }
                    d[cnt++] = dis(node[i], node[j]);
                }
                Arrays.sort(d, 0, cnt);
                int res = 1;
                for (int k = 1; k < cnt; k++) {
                    if (d[k] == d[k - 1]) {
                        res++;
                    } else {
                        ans += res * (res - 1); //   从 res 个中选择2个、  （交换位置也算一个）、 res* (res- 1) / 2  *  2
                        res = 1;
                    }
                }
                ans += res * (res - 1);
            }
            if (ans == 0) {
                out.println("WA");
            } else {
                out.println(ans);
            }
            out.flush();
        }

    }

    public static int dis(Node a, Node b) {
        return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
    }

    public static class MyComparator implements Comparator<Node> {  // 自己定义的比较器、、、  

        @Override
        public int compare(Node a, Node b) {
            return (a.x == b.x) ? (a.y - b.y) : (a.x - b.x);
        }
    }

    static class Node {

        int x, y;

        public Node() {
        }

        public Node(int x, int y) {
            this.x = x;
            this.y = y;
        }

    }
}

F：等式


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Scanner;

public class F {

    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static String next() throws IOException {
        in.nextToken();
        return (String) in.sval;
    }

    public static void main(String[] args) throws IOException {
        int t = nextInt();
        while (t-- != 0) {
            int n = nextInt();
            long ans = 1;
            int sqrt = (int) Math.sqrt(n);

            for (int i = 2; i <= sqrt; i++) {
                if (n % i == 0) {
                    int tmp = 0;
                    while (n % i == 0) {
                        tmp++;
                        n /= i;
                    }
                    ans *= (2 * tmp + 1);
                }
            }
            if (n != 1) {
                ans *= 3;
            }
            out.println((ans + 1) / 2);
            out.flush();
        }

    }
}

G：旋转矩阵

模拟一遍即可（我的方向感好差啊）

import java.util.Scanner;

public class G {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int T = input.nextInt();
        while (T-- != 0) {
            int n = input.nextInt();
            int m = input.nextInt();
            char c[][] = new char[n][m];
            for (int i = 0; i < n; i++) {
                c[i] = input.next().toCharArray();
            }
            int turn = 0;

            char[] s = input.next().toCharArray();

            for (int i = 0; i < s.length; i++) {
                if (s[i] == 'L') {
                    turn--;
                } else {
                    turn++;
                }
            }
            turn = (turn % 4 + 4) % 4;
            if (turn == 0) {
                System.out.println(n + " " + m);
                for (int i = 0; i < n; i++) {
                    for (int j = 0; j < m; j++) {
                        System.out.print(c[i][j]);
                    }
                    System.out.println("");
                }
            } else if (turn == 2) {
                System.out.println(n + " " + m);
                for (int i = n - 1; i >= 0; i--) {
                    for (int j = m - 1; j >= 0; j--) {
                        System.out.print(c[i][j]);
                    }
                    System.out.println("");
                }
            } else if (turn == 1) { // R旋转、、
                System.out.println(m + " " + n);
                for (int i = 0; i < m; i++) {
                    for (int j = n - 1; j >= 0; j--) {
                        if(c[j][i] == '|'){
                            System.out.print("-");
                        }else if(c[j][i] == '-'){
                            System.out.print("|");
                        }else{
                            System.out.print(c[j][i]);
                        }
                    }
                    System.out.println("");
                }
            }else if(turn == 3){ // L旋转、、、
                System.out.println(m + " " + n);
                for(int i = m - 1; i >= 0; i--){
                    for(int j = 0; j < n; j++){
                        if(c[j][i] == '|'){
                            System.out.print("-");
                        }else if(c[j][i] == '-'){
                            System.out.print("|");
                        }else{
                            System.out.print(c[j][i]);
                        }
                    }
                    System.out.println("");
                }
            }
            System.out.println("");
        }
    }

}


J：强迫症的序列


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class J {

    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static String next() throws IOException {
        in.nextToken();
        return (String) in.sval;
    }

    public static void main(String[] args) throws IOException {
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            int t = (int) in.nval;
            while (t-- > 0) {
                int n = nextInt();
                int[] a = new int[n];
                int min = Integer.MAX_VALUE, max = -1;
                for (int i = 0; i < n; i++) {
                    a[i] = nextInt();
                    max = Math.max(max, a[i]);
                    min = Math.min(min, a[i]);
                }

                long step = 0;
                for (int i = 0; i < n; i++) {
                    step += (a[i] - min);
                }

                long ans = step + min;
                out.println(step + " " + ans);
                out.flush();
            }

        }
    }

}

K：密码

找规律、模拟、分别输出


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class K {

    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    static char c[] = new char[100005];

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static String next() throws IOException {
        in.nextToken();
        return (String) in.sval;
    }

    public static void main(String[] args) throws IOException {
        int t = nextInt();
        while (t-- != 0) {
            int n = nextInt();
            c = next().toCharArray();
//            for(int i = 0; i < c.length; i++){
//                out.print(c[i]);
//            }
//            out.println();
//            out.flush();
            if (n == 1) {
                System.out.println(String.valueOf(c));
            } else {
                int len = c.length; // 字符串的长度、、、
                int tmp = 2 * n - 2; // 完整的一列 隔壁的一列相距的字符数、
                for (int i = 0; i < len; i += tmp) { //　单独处理、第一行的、、、
                    out.print(c[i]);
                }
                int x = tmp;
                for (int i = 1; i < n - 1; i++) { // 处理中间的、、
                    x -= 2;
                    for (int j = i; j < len; j += tmp) {
                        out.print(c[j]);
                        if (j + x < len) {
                            out.print(c[j + x]);
                        }
                    }
                }

                for (int i = n - 1; i < len; i += tmp) {  //　处理最后一行的、、、
                    out.print(c[i]);
                }
                out.println();
            }
            out.flush();
        }
    }

}

L：用来作弊的药水 

解法一：枚举几个素数进行取模快速求解

解法二：分解质因数然后判断每个质因数的数量是否相等

解法三：取对数直接判断相等、注意误差

代码一：

import java.math.BigInteger;
import java.util.Scanner;

public class L {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int T = input.nextInt();
        BigInteger MOD = new BigInteger("100000007");
        while (T-- != 0) {
            BigInteger x, a, y, b, ans1, ans2;
            x = input.nextBigInteger();
            a = input.nextBigInteger();
            y = input.nextBigInteger();
            b = input.nextBigInteger();
            ans1 = x.modPow(a, MOD);
            ans2 = y.modPow(b, MOD);
//            System.out.println(ans1 + " " + ans2);
            if (ans1.compareTo(ans2) == 0) {
                System.out.println("Yes");
            } else {
                System.out.println("No");
            }
        }

    }

}

代码二：

import java.util.Scanner;

public class L_ {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int t = input.nextInt();
        while (t-- != 0) {
            int x, a, y, b;
            x = input.nextInt();
            a = input.nextInt();
            y = input.nextInt();
            b = input.nextInt();
            System.out.println(solve(x, a, y, b));
        }

    }

    public static String solve(int x, int a, int y, int b) {
        if (x > y && a > b) {
            return "No";
        }
        if (x < y && a < b) {
            return "No";
        }
        if (a < b) { // 大的开小的方、、
            solve(y, b, x, a);
        }
        if (Math.abs(Math.pow(x, a * (1.0) / b) - y) < 0.0000001) {
            return "Yes";
        }
        return "No";
    }
}

代码三：

import java.util.Scanner;

public class L_1 {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        int t = input.nextInt();
        while (t-- != 0) {
            int x, a, y, b;
            x = input.nextInt();
            a = input.nextInt();
            y = input.nextInt();
            b = input.nextInt();

            boolean flag = true;

            while (true) {
                if (x == y && a == b) {
                    break;
                } else if (x == y || a == b) {
                    flag = false;
                    break;
                }

                if (x < y) { // 交换 、 x 为大的、、
                    int tmp = x;
                    x = y;
                    y = tmp;
                    tmp = a;
                    a = b;
                    b = tmp;
                }

                if (x % y != 0) {
                    flag = false;
                    break;
                }
                if (a >= b) {
                    flag = false;
                    break;
                }
                x /= y;
                b -= a;
            }

            if (flag) {
                System.out.println("Yes");
            } else {
                if (x == y && x == 1) {
                    System.out.println("Yes");
                } else {
                    System.out.println("No");
                }
            }

        }

    }
}

代码四：

import java.util.Scanner;

public class L_2 {
    
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        
        int t = input.nextInt();
        while(t-- != 0){
            int x, a, y, b;
            x = input.nextInt();
            a = input.nextInt();
            y = input.nextInt();
            b = input.nextInt();
            
            double ans1,ans2;
            ans1 = a * Math.log(x);
            ans2 = b * Math.log(y);
            if(Math.abs(ans1 - ans2) < 0.00001){ // 需要说的是 牛客网的数据很水  只要 在0.1 -> 0.00001都可以通过
                System.out.println("Yes");
            }else{
                System.out.println("No");
            }
        }
    }
}

浮沉_y
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 K-密码
gdut_yy的博客
04-12 300
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 K-密码链接：https://www.nowcoder.com/acm/contest/90/K来源：牛客网题目描述ZiZi登录各种账号的时候，总是会忘记密码，所以他把密码都记录在一个记事本上。其中第一个密码就是牛客网的密码。牛客网专注于程序员的学习、成长及职位发展，连接C端程序员及B端招聘方，通过IT笔试面试题库、在线社区、在线课程等提高候选人
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛.A.跳台阶
红鲤鱼与绿鲤鱼与驴
03-24 423
链接：https://www.nowcoder.com/acm/contest/90/A来源：牛客网时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32768K，其他语言65536K 64bit IO Format: %lld题目描述 小明在坐景驰科技研发的无人车到达了目的地。 景驰科技（JingChi.ai）是一家由人工智能技术驱动、以无人驾驶技术为核心的智能出行公司。它将...
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 （题解）
张松超的博客
03-29 374
比赛链接：第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 A：斐波那契变形 规律：当前项 = 前面所有项之和 + 1，其实打表以后会发现是2^N，懒得改代码了直接交了。 #include &lt;bits/stdc++.h&gt; using namespace std; const int MAXN = 35; long long a[MAXN]; int main() { ...
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 C-平分游戏
hnust_Derker的博客
03-25 489
C - 平分游戏 思路：先看怎么处理一个圈有nnn个人只给相邻的人硬币的解法，保证总数整除nnn是必然的，有个很明显的情况就是如果AAA给了BBB，那么BBB将不会再给AAA，这样无疑是多余的步骤，所以相邻的两个人ABABAB之间要么是AAA给BBB，要么是BBB给AAA，那么相邻的第i−1i−1i-1，iii，i+1i+1i+1三个人，不妨假设第iii个人给了第i−1i−1i-1个人xixix...
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 E-回旋星空
albertluf的博客
03-26 363
链接：https://www.nowcoder.com/acm/contest/90/E来源：牛客网题目描述 曾经有两个来自吉尔尼斯的人(A和C)恋爱了,他们晚上经常在一起看头上的那片名为假的回旋星空, 有一天他们分手了,A想通过回旋星空测量他们之间的复合指数,测量的规则是, 计算回旋图标的个数,即选中三颗星星,分别作为回旋图标的起点,拐点和终点,假设现在有三个 星星分别为i,...
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛（A D F I J K L）
神回
03-24 543
链接 ：https://www.nowcoder.com/acm/contest/90#question A 跳台阶 类似斐波那契 #include &lt;bits/stdc++.h&gt; using namespace std; string a; int f[40]; int main() { int t; cin&gt;&gt;t; while(t--...
工训赛垃圾分类垃圾桶陶晶驰串口屏资源
03-15
按照工训赛垃圾分类要求设计的基于USART HMI 陶晶驰串口屏 可调节设备型号，有宣传视频，垃圾分类，满载报警，自动计数加一，音量调节，亮度调节等功能，完全符合工训赛比赛要求，可直接实用。
自动驾驶出租车竞赛,谁是最后赢家.pdf
09-20
这种服务利用无人驾驶技术，通过智能手机应用程序为用户呼叫和乘坐自动驾驶出租车。目前，包括Waymo、Uber、百度、滴滴等公司在内，全球范围内有众多企业正在积极布局这一市场，争夺未来出行市场的入场券。文章提到...
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛——旋转矩阵
dreamjay1997的博客
03-24 271
链接：https://www.nowcoder.com/acm/contest/90/G来源：牛客网时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32768K，其他语言65536K 64bit IO Format: %lld题目描述 景驰公司自成立伊始，公司便将“推动智能交通的发展，让人类的出行更安全，更高效，更经济，更舒适”作为公司使命，通过产业融合、建设智能汽车出行行业...
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 F 等式 （唯一分解定理）
深海沧澜的博客
03-25 310
题目描述 给定n，求1/x + 1/y = 1/n （x&lt;=y）的解数。（x、y、n均为正整数）输入描述:在第一行输入一个正整数T。接下来有T行，每行输入一个正整数n，请求出符合该方程要求的解数。（1&lt;=n&lt;=1e9）输出描述:输出符合该方程要求的解数。示例1输入31201801011000000000输出15181思路:1/x+1/y=1/n，设x=n+a,y=n+b,化简可得...
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 F 等式（数学）
wjmwsgj的博客
03-26 187
题意：中文题思路：给你一个1/x + 1/y = 1/n  ，两边同时乘上xyn之后得到式子 nx+ny = xy ，之后通过(自我感觉)非常非常非常敏锐的数学思想，两边同时加上n^2,得到(n-x)*(n-y) = n^2。由此可以看出我们现在要求出的是n^2的所有因子，因为n有1e9所以直接求因子会超时，这个时候我们引入一个非常吊的公式，所有数都可以化为几个质数次方和相加p = a1^x1+a...
牛客网 第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛-强迫症的序列
别止的博客
03-25 311
链接：https://www.nowcoder.com/acm/contest/90/J来源：牛客网时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32768K，其他语言65536K 64bit IO Format: %lld题目描述 牛客网是IT求职神器,提供海量C++、JAVA、前端等职业笔试题库,在线进行百度阿里腾讯网易等互联网名企笔试面试模拟考试练习,和牛人一起讨论经典试题...
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 - （D，E，F，J）
Orz
03-24 382
链接：https://www.nowcoder.com/acm/contest/90#questionDpsd面试题意：每组给出一个字符，问忽略字母大小写，这个字符串去掉最长的回文子序列后还有多长？解析：注意是最长的回文子序列不是最长回文子串，用字符串长度减去最长回文子序列长度就是答案。代码：#include &lt;iostream&gt; #include &lt;cstdio&gt; #in...
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 回旋星空
sugarbliss
03-28 261
题目描述 曾经有两个来自吉尔尼斯的人(A和C)恋爱了,他们晚上经常在一起看头上的那片名为假的回旋星空,有一天他们分手了,A想通过回旋星空测量他们之间的复合指数,测量的规则是,计算回旋图标的个数,即选中三颗星星,分别作为回旋图标的起点,拐点和终点,假设现在有三个星星分别为i,j,k,如果d(a[i],a[j]) == d(a[j],a[k])则表示找到了一个回旋图标,其中d(x,y)表示这两个点的欧...
第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛.L用来作弊的药水
红鲤鱼与绿鲤鱼与驴
03-24 623
链接：https://www.nowcoder.com/acm/contest/90/L来源：牛客网时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32768K，其他语言65536K 64bit IO Format: %lld题目描述    在一个风雨交加的夜晚，来自异世界的不愿透露姓名的TMK同学获得了两种超强药水A、B。根据说明书，TMK知道了这两种药水的作用：     (1)药...
广东工业大学第十三届景驰埃森哲杯程序设计竞赛
jackcily的博客
03-28 206
做第一题的时候一点思路都没有，看到第一眼就觉得应该用递归，因为我觉得是一种全排列，但是结果没做出来，最后队友用找规律的方法做了出来。 而且有一个点的取值我也不理解，为什么0级台阶时有一种跳法。其实这是个数学问题，类似于c（0，0） = 1, 从0个中取0个，有一种实现的方法，就是一个也不取。 代码如下： #include&lt;iostream&gt; using namespace ...
给我列出30个位于在北京海淀区的人工智能公司，并且利用到linux嵌入式技术
最新发布
04-08
13. Umbo CV (安波信息) 14. Eazytec (精选科技) 15. Neolix (新理想汽车) 16. RobSense (深驰智能) 17. MiroSot (全景图) 18. PerceptIn (感知天下) 19. Intellifusion (瑞丰光电) 20. Kuangshi Technology (矿湾...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值