XUPT_ACM2021寒假训练第二周练习记录

最新推荐文章于 2022-03-15 20:34:45 发布
最新推荐文章于 2022-03-15 20:34:45 发布
阅读量207 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 贪心算法 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45554010/article/details/113741438
版权

试题链接：第二周训练题 - Virtual Judge
这周事情比较多，没有把20道题全部写完，只写了14道题。

目录

B - 补提交卡

语言：C++

#include <iostream>
#define MAXSIZE 105
using namespace std;

int a[MAXSIZE];

int main() {
    int T;
    cin >> T;
    while (T--) {
        int N, M;
        cin >> N >> M;
        int ans = N <= M ? 100 : 0;
        for (int i = 0; i < N; i++) {
            cin >> a[i];
        }
        for (int i = 0; i <= N - M; i++) {
            int start = i > 0 ? a[i - 1] + 1 : 1;
            int end = i + M < N ? a[i + M] - 1 : 100;
            ans = max(ans, end - start + 1);
        }
        cout << ans << endl;
    }
    return 0;
}

C - 热血格斗场

语言：C++

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

int main() {
    map<int, int> m;
    map<int, int>::iterator it;
    m[1000000000] = 1;
    int n;
    cin >> n;
    while (n--) {
        int id, strength;
        cin >> id >> strength;
        it = m.upper_bound(strength);
        if (it == m.end()) {
            it--;
            cout << id << " " << it->second << endl;
        } else if (it == m.begin()) {
            cout << id << " " << it->second << endl;
        } else {
            int t1 = abs(it->first - strength);
            it--;
            int t2 = abs(it->first-strength);
            if (t2 > t1) {
                it++;
            }
            cout << id << " " << it->second << endl;
        }
        m.insert(pair<int, int>(strength, id));
    }
    return 0;
}

D - 背包包

语言：C++

#include <iostream>
#define MAXSIZE 1005
using namespace std;

int w[MAXSIZE];
int v[MAXSIZE];

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, V;
        int maxN = 0;
        int maxV = 0;
        int dp[MAXSIZE] = {0};
        cin >> n >> V;
        for (int i = 1; i <= n; i++) {
            cin >> w[i];
        }
        for (int i = 1; i <= n; i++) {
            cin >> v[i];
        }
        dp[v[1]] = w[1];
        for (int i = 2; i <= n; i++) {
            for (int j = V; j >= v[i]; j--) {
                if (j == v[i] || dp[j - v[i]] != 0) {
                    dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
                }
            }
        }
        for (int i = V; i > 0; i--) {
            if (dp[i] > maxN) {
                maxN = dp[i];
                maxV = i;
            }
        }
        cout << maxN << " " << maxV << endl;
    }
    return 0;
}

E - 数列极差

语言：C++

#include <iostream>
#include <algorithm>
#define MAXSIZE 50005
using namespace std;

int arr1[MAXSIZE];
int arr2[MAXSIZE];

bool cmp1(int a, int b);
bool cmp2(int a, int b);
int Max(int n);
int Min(int n);

int main() {
    int n;
    while (cin >> n && n != 0) {
        for (int i = 0; i < n; i++) {
            cin >> arr1[i];
            arr2[i] = arr1[i];
        }
        cout << Max(n) - Min(n) << endl;
    }
    return 0;
}

bool cmp1(int a, int b) {
    return a > b;
}

bool cmp2(int a, int b) {
    return a < b;
}

int Max(int n) {
    while (n > 2) {
        sort(arr1, arr1 + n, cmp1);
        arr1[n - 2] = arr1[n - 2] * arr1[n - 1] + 1;
        n--;
    }
    return arr1[0] * arr1[1] + 1;
}

int Min(int n) {
    while (n > 2) {
        sort(arr2, arr2 + n, cmp2);
        arr2[n - 2] = arr2[n - 2] * arr2[n - 1] + 1;
        n--;
    }
    return arr2[0] * arr2[1] + 1;
}

G - 过河

语言：C++

#include <iostream>
#include <algorithm>
#define MAXSIZE 1005
using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        int a[MAXSIZE] = {0};
        cin >> n;
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
        }
        sort(a + 1, a + n + 1);
        int ans = 0;
        while (n > 0) {
            if (n > 3) {
                int s1 = 2 * a[1] + a[n - 1] + a[n];
                int s2 = 2 * a[2] + a[1] + a[n];
                ans += min(s1, s2);
                n -= 2;
            } else if (n == 3) {
                ans += a[1] + a[2] + a[3];
                break;
            } else {
                ans += a[n];
                break;
            }
        }
        cout << ans << endl;
    }
    return 0;
}

H - 超市

解法1
语言：C++

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#define MAXSIZE 10005
using namespace std;

pair<int, int> goods[MAXSIZE];
priority_queue<int, vector<int>, greater<int>> q;

int main() {
    int n;
    while (cin >> n) {
        int ans = 0;
        memset(goods, 0, sizeof(goods));
        for (int i = 0; i < n; i++) {
            cin >> goods[i].second >> goods[i].first;
        }
        sort(goods, goods + n);
        for (int i = 0; i < n; i++) {
            if (goods[i].first > q.size()) {
                q.push(goods[i].second);
            } else if (goods[i].first == q.size() && goods[i].second > q.top()) {
                q.pop();
                q.push(goods[i].second);
            }
        }
        while (!q.empty()) {
            ans += q.top();
            q.pop();
        }
        cout << ans << endl;
    }
    return 0;
}

解法2
语言：C++

#include <algorithm>
#include <cstdio>
using namespace std;

struct data {
    int p;
    int d;
} h[10010];

bool cmp(data a, data b);

int main() {
    int n, p, d;
    while (~scanf("%d", &n)) {
        for (int i = 1; i <= n; i++) {
            scanf("%d %d", &h[i].p, &h[i].d);
        }
        sort(h + 1, h + n + 1, cmp);
        int count = 0;
        int c[10010] = {0};
        for (int i = 1; i <= n; i++) {
            if (c[h[i].d] == 0) {
                c[h[i].d] = 1;
                count += h[i].p;
            } else {
                for (int j = h[i].d - 1; j > 0; j--) {
                    if (c[j] == 0) {
                        c[j] = 1;
                        count += h[i].p;
                        break;
                    }
                }
            }
        }
        printf("%d\n", count);
    }
    return 0;
}

bool cmp(data a, data b) {
    return a.p > b.p;
}

I - 放苹果

语言：C++

#include <iostream>
using namespace std;

int fun(int m, int n);

int main() {
    int t;
    cin >> t;
    while (t--) {
        int m, n;
        cin >> m >> n;
        cout << fun(m, n) << endl;
    }
    return 0;
}

int fun(int m, int n) {
    if (m == 0 || m == 1) {
        return 1;
    }
    if (n == 0 || n == 1) {
        return 1;
    }
    if (m >= n) {
        return fun(m, n - 1) + fun(m - n, n);
    } else {
        return fun(m, m);
    }
}

J - 滑雪

语言：C++

#include <iostream>
#define MAXSIZE 105
using namespace std;

int R, C;
int h[MAXSIZE][MAXSIZE];
int visited[MAXSIZE][MAXSIZE];
int di[2][4] = {
        {0, 0, -1, 1},
        {-1, 1, 0, 0}
};

bool check(int i, int j);
int longestPath(int i, int j);

int main() {
    int ans = 0;
    cin >> R >> C;
    for (int i = 0; i < R; i++) {
        for (int j = 0; j < C; j++) {
            cin >> h[i][j];
        }
    }
    for (int i = 0; i < R; i++) {
        for (int j = 0; j < C; j++) {
            longestPath(i, j);
            ans = max(ans, visited[i][j]);
        }
    }
    cout << ans << endl;
    return 0;
}

bool check(int i, int j) {
    if (i >= 0 && i < R && j >= 0 && j < C) {
        return true;
    } else {
        return false;
    }
}

int longestPath(int i, int j) {
    if (visited[i][j] != 0) {
        return visited[i][j];
    }
    visited[i][j] = 1;
    for (int k = 0; k < 4; k++) {
        int i_next = di[0][k] + i;
        int j_next = di[1][k] + j;
        if (check(i_next, j_next) && h[i_next][j_next] < h[i][j]) {
            longestPath(i_next, j_next);
            visited[i][j] = max(visited[i][j], visited[i_next][j_next] + 1);
        }
    }
    return visited[i][j];
}

L - 贫穷的ACM

语言：C++

#include <iostream>
#define MAXSIZE 10005
#define INF 2000000000
using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int E, F;
        cin >> E >> F;
        int w = F - E;
        int N;
        cin >> N;
        int P[MAXSIZE], W[MAXSIZE];
        int dp[MAXSIZE];
        for (int i = 0; i < N; i++) {
            cin >> P[i] >> W[i];
        }
        for (int i = 0; i <= w; i++) {
            dp[i] = INF;
        }
        dp[0] = 0;
        for (int i = 0; i < N; i++) {
            for (int j = W[i]; j <= w; j++) {
                dp[j] = min(dp[j], dp[j - W[i]] + P[i]);
            }
        }
        if (dp[w] != INF) {
            cout << "The minimum amount of money in the piggy-bank is " << dp[w] << "." << endl;
        } else {
            cout << "This is impossible." << endl;
        }
    }
    return 0;
}

M - I NEED A OFFER!

语言：C++

#include <cstdio>
#include <iostream>
#define MAXSIZE 10005
using namespace std;

int main() {
    int n, m;
    while (cin >> n >> m) {
        if (n == 0 && m == 0) {
            break;
        }
        double a[MAXSIZE];
        double b[MAXSIZE];
        for (int i = 1; i <= m; i++) {
            cin >> a[i] >> b[i];
        }
        double dp[MAXSIZE];
        for (int i = 0; i <= n; i++) {
            dp[i] = 1;
        }
        for (int i = 1; i <= m; i++) {
            for (int j = n; j >= a[i]; j--) {
                dp[j] = min(dp[j], dp[j - int(a[i])] * (1 - b[i]));
            }
        }
        printf("%.1lf%%\n", (1 - dp[n]) * 100);
    }
    return 0;
}

N - 今年暑假不AC

语言：C++

#include <iostream>
#include <algorithm>
#define MAXSIZE 105
using namespace std;

typedef struct {
    int Ts;
    int Te;
} Time;

bool cmp(Time a, Time b);

int main() {
    int n;
    while (cin >> n && n != 0) {
        Time T[MAXSIZE];
        for (int i = 0; i < n; i++) {
            cin >> T[i].Ts >> T[i].Te;
        }
        sort(T, T + n, cmp);
        int tmp = T[0].Te;
        int ans = 1;
        for (int i = 1; i < n; i++) {
            if (tmp <= T[i].Ts) {
                ans++;
                tmp = T[i].Te;
            }
        }
        cout << ans << endl;
    }
    return 0;
}

bool cmp(Time a, Time b) {
    return a.Te < b.Te;
}

O - 拯救X先生

语言：C++

#include <iostream>
#include <algorithm>
#define MAXSIZE 105
using namespace std;

struct treasure {
    int p;
    int m;
} a[MAXSIZE];

bool cmp(treasure x, treasure y);

int main() {
    int v, n;
    while (cin >> v && v != 0) {
        cin >> n;
        for (int i = 0; i < n; i++) {
            cin >> a[i].p >> a[i].m;
        }
        sort(a, a + n, cmp);
        int ans = 0;
        for (int i = 0; i < n; i++) {
            if (v - a[i].m >= 0) {
                ans += a[i].m * a[i].p;
                v -= a[i].m;
            } else {
                ans += a[i].p * v;
                break;
            }
        }
        cout << ans << endl;
    }
    return 0;
}

bool cmp(treasure x, treasure y) {
    return x.p > y.p;
}

Q - 奇怪的电梯

语言：C++

#include <iostream>
#include <queue>
#define MAXSIZE 205
using namespace std;

typedef struct {
    int step;
    int floor;
} qElem;

int main() {
    int n;
    while (cin >> n && n != 0) {
        int A, B;
        int k[MAXSIZE];
        cin >> A >> B;
        for (int i = 1; i <= n; i++) {
            cin >> k[i];
        }
        queue<qElem> q;
        bool flag[MAXSIZE] = {0};
        bool tag = false;
        qElem start, end;
        start.step = 0;
        start.floor = A;
        q.push(start);
        while (!q.empty()) {
            start = q.front();
            q.pop();
            if (start.floor == B) {
                cout << start.step << endl;
                tag = true;
                break;
            }
            if (start.floor + k[start.floor] <= n && !flag[start.floor + k[start.floor]]) {
                end.floor = start.floor + k[start.floor];
                end.step = start.step + 1;
                flag[end.floor] = true;
                q.push(end);
            }
            if (start.floor - k[start.floor] > 0 && !flag[start.floor - k[start.floor]]) {
                end.floor = start.floor - k[start.floor];
                end.step = start.step + 1;
                flag[end.floor] = true;
                q.push(end);
            }
        }
        if (!tag) {
            cout << -1 << endl;
        }
    }
    return 0;
}

R - 小火车

语言：C++

#include <iostream>
#include <string>
#include <stack>
using namespace std;

int main() {
    int n;
    while (cin >> n) {
        stack<int> st;
        string s1, s2;
        cin >> s1 >> s2;
        string ans;
        int cur = 0;
        bool flag = true;
        for (int i = 0; i < n; i++) {
            while (st.empty() || st.top() != s2[i]) {
                if (cur >= n) {
                    break;
                }
                st.push(s1[cur++]);
                ans += '1';
            }
            if (st.top() == s2[i]) {
                st.pop();
                ans += '0';
            } else {
                flag = false;
            }
        }
        if (flag) {
            cout << "Yes." << endl;
            for (char an : ans){
                cout << (an == '1' ? "in" : "out") << endl;
            }
        } else {
            cout << "No." << endl;
        }
        cout << "FINISH" << endl;
    }
    return 0;
}
CCH²¹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[XUPT_ACM]寒假第二次比赛题解
Radium_1209
02-23 409
写在前面：本次比赛共12题，比赛总体难度相比第一次比赛略有提高，但是整体难度依旧不难，本次比赛打乱了题目，题目难度随机，导致了简单题出题人数减少。本次比赛的题目难度跨度不是特别大，但是题目类型增多，由于每个人擅长的领域不同，可能对结果有一定影响。 比赛地址：https://vjudge.net/contest/284308 下面就对比赛的题目做一下简单的解答（题目方法不唯一，给出的解法仅供参考...
[XUPT_ACM]寒假第一次比赛题解
Radium_1209
02-02 751
写在前面：本次比赛共11题，设计的是A-E是简单题，F-H为中等题，I-K为难题，考虑到比赛的友好性，我们并没有将题目难度打乱，而是基本上按照从简单到难来排序。比赛的总体出题和预期的差不多，其中B题出题数较少而实际上B题是比较简单的一道题（可能是题目没看懂吧），而J题的过题数比预计的要多很多（看来大家数学都不错）。 比赛地址：https://vjudge.net/contest/280657 ...
XUPT_ACM2021寒假训练第一周练习记录
CCH²¹的博客
01-27 402
试题链接：第一周训练题 目录A - 查成绩B - 放暑假C - 展开字符串D - 回文数猜想E - 宇航员F - 买鸡问题G - 水贴H - 最小新整数I - 赶时间J - 暖气坏了K - 完美立方L - N对数的排列问题M - 母牛的故事N - 无限的路O - 统计元音P - 求数列的和Q - 数字游戏R - 轻重搭配S - Powered AdditionT - Puzzle From the Future A - 查成绩 语言：C++ #include <iostream> #incl.
２０１９XUPT_ACM 寒假训练第二期
zhouyuan930的专栏
01-30 438
 http://space.bilibili.com/397279709  　　　　２０１９XUPT_ACM 寒假集训，唐阳的讲解视频 已经上传，大家下载学习!
2019XUPT_ACM校赛总结
森世
04-14 392
好久没有写博客了，上次写博客还是上一学期的事情，感觉最近自己天天被各种琐事缠身，自己本身也有些懈怠，很烦。。。 虽然比赛的结果还可以接受，但感觉有些东西学得太不扎实了。。。 题目 A 给定一个循环括号序列（括号环），可以从任何一个地方断开，给定一个括号环，问是否可以断开成为一个合法的环 我一开始的想法是枚举断开的位置，判断这个序列是否合法 虽然可以过，但是正解如下 判断左右括号的数量，如果相等就...
XUPT 寒假算法集训第二周
m0_63188530的博客
02-13 455
A - 金银岛 某天KID利用飞行器飞到了一个金银岛上，上面有许多珍贵的金属，KID虽然更喜欢各种宝石的艺术品，可是也不拒绝这样珍贵的金属。但是他只带着一个口袋，口袋至多只能装重量为w的物品。岛上金属有s个种类, 每种金属重量不同，分别为n1, n2, ... , ns，同时每个种类的金属总的价值也不同，分别为v1,v2, ..., vs。KID想一次带走价值尽可能多的金属，问他最多能带走价值多少的金属。注意到金属是可以被任意分割的，并且金属的价值和其重量成正比。 Input 第1行是测试数据的组数
XUPT 寒假算法集训第三周
m0_63188530的博客
02-20 203
A - 金银岛 某天KID利用飞行器飞到了一个金银岛上，上面有许多珍贵的金属，KID虽然更喜欢各种宝石的艺术品，可是也不拒绝这样珍贵的金属。但是他只带着一个口袋，口袋至多只能装重量为w的物品。岛上金属有s个种类, 每种金属重量不同，分别为n1, n2, ... , ns，同时每个种类的金属总的价值也不同，分别为v1,v2, ..., vs。KID想一次带走价值尽可能多的金属，问他最多能带走价值多少的金属。注意到金属是可以被任意分割的，并且金属的价值和其重量成正比。 Input 第1行是测试数据的组数
XUPT 寒假算法集训第一周
m0_63188530的博客
02-13 472
A - 连续数的和 给你一个整数nn，你需要找到两个整数ll和rr，它们的范围是：-10^18 ≤l<r≤10^18并且使得l + (l + 1) +... + (r - 1) + r =n. Input 第一行输入一个单独的整数t(-10^4≤t≤10^4)— 表示测试用例的组数。 每组测试用例只有一行，每行只有一个整数n(-10^18≤n≤10^18). Output 对于每组测试用例，输出两个整数l和r，令l + (l + 1) + ...+ (r - 1)...
杭电ACM 第2023题
PeixinYe的博客
03-10 1160
#include &lt;iostream&gt; #include &lt;iomanip&gt; using namespace std; int main() { int n, s[50][5], m, i, j; while (cin &gt;&gt; n &gt;&gt; m) { double a1[50] = { 0.0 }, a2[5] ...
XUPT第二周PPT 222.pptx
02-05
贪心,动态规划,stl学习当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。运用贪心策略在每一次转化时都取得了最优解。问题的最优子结构性质是该问题可用贪心算法或动态规划算法求解的关键...
xupt小插件
09-15
西邮小插件好用又实惠，特别好，快来下吧！
xupt-telecom.exe
02-18
xupt-telecom.exe
XUPT - Rference MAterials.zip
最新发布
06-07
XUPT - Rference MAterials.zip
C语言考研复试题目XUPT2020
08-08
主要包括C语言的一些笔记。以及前几年的复试题。还有408的相关科目总结。同时包括严蔚敏C语言程序设计课后习题答案。以及学校C语言期末考试题。还有自己总结的一些知识点。文件很全面，比较实用。...
【数据结构】扩展先序序列建立二叉树以及对二叉树的一系列操作
CCH²¹的博客
11-06 8566
题目要求 输入二叉树的扩展先序序列，以二叉链表作为存储结构，建立二叉树。 输出这棵二叉树的先序、中序和后序遍历序列，其中后序遍历使用非递归算法实现。 统计二叉树中非叶子结点的个数。 计算二叉树的高度。 非递归后序遍历二叉树思路   在后序遍历中，左、右子树均访问完成后，从右子树返回时，上一层结点才能退栈并被访问。那么，当从子树返回时，如何判断是从左子树返回还是从右子树返回，进而确定栈顶的上一层结点是否应出栈。   其中一种方法是，每个结点入栈时设置一个标记位flag同时入栈，进入左子树访问时，令flag
分治算法、贪心算法和动态规划的典型例题
CCH²¹的博客
01-06 1613
目录Part 1 - 分治算法例1 - 洛谷P1908 逆序对DescriptionInputOutputSample InputSample OutputAccepted Code 1Accepted Code 2Part 2 - 贪心算法例2.1 - Codeforces 1339C Powered AdditionDescriptionInputOutputSample InputSample OutputAccepted Code例2.2 - 洛谷P1090 \[NOIP2004 提高组\] 合并果
【算法积累】计蒜客迷宫三问 (DFS & BFS)
CCH²¹的博客
08-09 1299
计蒜客T1595 - 迷宫（一） 题目链接 一天蒜头君掉进了一个迷宫里面，蒜头君想逃出去，可怜的蒜头君连迷宫是否有能逃出去的路都不知道。 看在蒜头君这么可怜的份上，就请聪明的你告诉蒜头君是否有可以逃出去的路。 输入格式 第一行输入两个整数 nnn 和 mmm，表示这是一个 n×mn \times mn×m 的迷宫。 接下来的输入一个 nnn 行 mmm 列的迷宫。其中S表示蒜头君的位置，*表示墙，蒜头君无法通过，.表示路，蒜头君可以通过.移动，T表示迷宫的出口（蒜头君每次只能移动到四个与他相邻的位置——上，
【计算机考研·数据结构】线性表的顺序表示·程序设计题
CCH²¹的博客
03-15 1181
题目出处：王道考研2022年数据结构考研复习指导 1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删函数的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。 遍历顺序表，记录最小值元素及其位置，遍历结束后用最后一个元素填补到记录的位置，顺序表长度减1。 bool del_min(SqList& L, ElemType& value) { if (L.length == 0) { // 显示出错信息 retu.
package xupt.se.ttms.service; import xupt.se.ttms.idao.DAOFactory; import xupt.se.ttms.idao.iResourceDAO; import xupt.se.ttms.model.Resource; import java.util.List; public class ResourceSrv { private iResourceDAO resourceDAO= DAOFactory.creatResourceDAO(); public int add(Resource resource){ return resourceDAO.insert(resource); } public int modify(Resource resource){ return resourceDAO.update(resource); } public int delete(int Id){ return resourceDAO.delete(Id); } public List<Resource> Fetch(String condt){ return resourceDAO.select(condt); } public List<Resource> FetchAll(){ return resourceDAO.select(""); } }
06-03
这段代码是一个资源服务类的代码，主要负责与资源相关的数据库操作。具体解释如下： 1. 导入相关的类和接口 ```java import xupt.se.ttms.idao.DAOFactory; import xupt.se.ttms.idao.iResourceDAO; import xupt.se.ttms.model.Resource; import java.util.List; ``` 2. 定义资源服务类 ```java public class ResourceSrv { private iResourceDAO resourceDAO= DAOFactory.creatResourceDAO(); // ... } ``` 3. 定义资源添加方法 ```java public int add(Resource resource){ return resourceDAO.insert(resource); } ``` 4. 定义资源修改方法 ```java public int modify(Resource resource){ return resourceDAO.update(resource); } ``` 5. 定义资源删除方法 ```java public int delete(int Id){ return resourceDAO.delete(Id); } ``` 6. 定义资源查询方法 ```java public List<Resource> Fetch(String condt){ return resourceDAO.select(condt); } public List<Resource> FetchAll(){ return resourceDAO.select(""); } ``` 其中，Fetch方法可以根据条件查询资源，FetchAll方法可以查询所有的资源。 7. 总结 该服务类主要实现了对资源的增删改查操作，其中使用了DAOFactory工厂类和iResourceDAO接口，实现了解耦和灵活性，可以方便地更换数据库或DAO实现类。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值