实验04 队列应用2022

最新推荐文章于 2024-04-25 10:19:17 发布
最新推荐文章于 2024-04-25 10:19:17 发布
阅读量315 收藏
点赞数
分类专栏： 数据结构实验 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62431082/article/details/127643564
版权

A. DS队列之银行排队

在银行营业大厅共服务3种客户，类型为A\B\C，大厅分别设置了3个窗口分别服务三种客户，即每个窗口只服务一种客户。现有一批客户来银行办理业务，每个客户都有类型和办理业务时间。每个窗口按照客户到来的顺序进行服务。

编程实现它们的办理流程，请使用C++自带的queue必须使用队列实现，其他方法0分！

队列queue的用法如下：

1.包含头文件：#include <queue>

2.定义一个整数队列对象：queue<int>  myQe;

3.定义一个整数队列对象数组：queue<int>  myQA[10];

4.入队操作：myQe.push(itemp); //把整数itemp进入队列

5.出队操作：myQe.pop();  //把队头元素弹出队列，注意本操作不获取队头元素

6.获取队头元素： itemp = myQe.front(); // 把队头元素放入itemp中，注意本操作不弹出元素

7.判断队列是否为空：myQe.empty();//队列空则返回true，不空则返回false

输入

第一行输入先输入n表示客户数量

第二行输入每个客户的类型，数据之间用用空格隔开

第三行输入每个客户的办理时间，数据之间用用空格隔开

输出

第一行输出A类客户的平均办理时间

第二行输出B类客户的平均办理时间

第三行输出C类客户的平均办理时间

输入：
8
A B C B C A A A
10 20 30 40 50 60 70 80
输出：
55
30
40

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

int main() {
    int n;
    cin >> n;
    queue<int> q[3];
    vector<char> v;
    for (int i = 0; i < n; i++) {
        char a;
        cin >> a;
        v.push_back(a);
    }
    for (int i = 0; i < n; i++) {
        int a;
        cin >> a;
        if (v[i] == 'A') {
            q[0].push(a);
        } else if (v[i] == 'B') {
            q[1].push(a);
        } else {
            q[2].push(a);
        }
    }
    for (int i = 0; i < 3; i++) {
        int sum = 0;
        int count = q[i].size();
        while (!q[i].empty()) {
            sum += q[i].front();
            q[i].pop();
        }
        cout << sum / count << endl;
    }
    return 0;
}

B. DS队列+堆栈--数制转换

对于任意十进制数转换为k进制，包括整数部分和小数部分转换。整数部分采用除k求余法，小数部分采用乘k取整法例如x=19.125，求2进制转换

整数部分19，					小数部分0.125
19 / 2 = 9 … 1					0.125 * 2 = 0.25 … 0
9 / 2 = 4 … 1					0.25 * 2 = 0.5   … 0
4 / 2 = 2 … 0 					0.5 * 2 = 1     … 1
2 / 2 = 1 … 0
1 / 2 = 0 … 1

所以整数部分转为 10011，小数部分转为0.001，合起来为10011.001

提示整数部分可用堆栈，小数部分可用队列实现

注意：必须按照上述方法来实现数制转换，其他方法0分

输入

第一行输入一个t，表示下面将有t组测试数据。

接下来每行包含两个参数n和k，n表示要转换的数值，可能是非整数；k表示要转换的数制，1<k<=16

输出

对于每一组测试数据，每行输出转换后的结果，结果精度到小数点后3位

输出小数点后几位的代码如下：

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
double r = 123.56789;
cout<<fixed<<setprecision(4)<<r<<endl;   //输出小数点后4位。

输入：
2
19.125 2
15.125 16
输出:
10011.001
F.200

#include <iostream>
#include <stack>
#include <queue>

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t--) {
        double num;
        int sign;
        cin >> num >> sign;
        stack<int> st;
        queue<int> qu;
        int zheng = num;
        double xiao = num - zheng;
        while (zheng) {
            st.push(zheng % sign);
            zheng /= sign;
        }
        for (int i = 0; i < 3; i++) {
            xiao *= sign;
            qu.push(xiao);
            xiao -= (int) xiao;
        }
        if (st.empty()) {
            cout << "0";
        } else {
            while (!st.empty()) {
                if (st.top() < 10) {
                    cout << st.top();
                } else {
                    cout << (char) (st.top() - 10 + 'A');
                }
                st.pop();
            }
        }
        cout << ".";
        while (!qu.empty()) {
            if (qu.front() < 10) {
                cout << qu.front();
            } else {
                cout << (char) (qu.front() - 10 + 'A');
            }
            qu.pop();
        }
        cout << endl;
    }
    return 0;
}

【20分】C. DS队列--组队列

组队列是队列结构中一种常见的队列结构，在很多地方有着广泛应用。组队列是是指队列内的元素分组聚集在一起。组队列包含两种命令：

1、 ENQUEUE，表示当有新的元素进入队列，首先会检索是否有同一组的元素已经存在，如果有，则新元素排在同组的最后，如果没有则插入队列末尾。

2、 DEQUEUE，表示队列头元素出队

3、 STOP，停止操作

建议使用C++自带的队列对象queue，编程更方便

输入

第1行输入一个t(t<=10)，表示1个队列中有多少个组

第2行输入一个第1组的元素个数和数值

第3行输入一个第2组的元素个数和数值

以此类推输入完t组以定义同组元素之后，开始输入多个操作命令(<200)，对空的组队列进行操作，例如输入ENQUEUE 100，表示把元素100插入队列

输出

DEQUEUE出队的元素

输入：
2
3 101 102 103
3 201 202 203
ENQUEUE 101
ENQUEUE 201
ENQUEUE 102
ENQUEUE 202
ENQUEUE 103
ENQUEUE 203
DEQUEUE
DEQUEUE
DEQUEUE
STOP
输出：
101 102 103
输入：
3
3 101 102 103
3 201 202 203
3 301 302 303
ENQUEUE 201
ENQUEUE 301
ENQUEUE 102
DEQUEUE
DEQUEUE
DEQUEUE
ENQUEUE 101
ENQUEUE 203
ENQUEUE 302
ENQUEUE 301
DEQUEUE
DEQUEUE
DEQUEUE
STOP
输出：
201 301 102 101 203 302
#include <iostream>
#include <list>
#include <queue>
#include <set>
#include <vector>

using namespace std;

int main() {
    int n;
    cin >> n;
    queue<int> *q = new queue<int>[n];
    set<int> *s = new set<int>[n];
    deque<int> v;
    for (int i = 0; i < n; i++) {
        int m;
        cin >> m;
        for (int j = 0; j < m; j++) {
            int x;
            cin >> x;
            s[i].insert(x);
        }
    }
    int cnt = 0;
    while (true) {
        string op;
        cin >> op;
        if (op == "STOP") {
            break;
        } else if (op == "ENQUEUE") {
            int x;
            cin >> x;
            int i = 0;
            for (; i < n; i++) {
                if (s[i].find(x) != s[i].end()) {
                    break;
                }
            }
            auto it = v.begin();
            for (; it != v.end(); it++) {
                if (*it == i) {
                    break;
                }
            }
            if (it == v.end()) {
                v.push_back(i);
            }
            q[i].push(x);
        } else if (op == "DEQUEUE") {
            if (cnt) {
                cout << " " << q[v.front()].front();
            } else {
                cout << q[v.front()].front();
            }
            cnt++;
            q[v.front()].pop();
            if (q[v.front()].empty()) {
                v.pop_front();
            }
        }
    }
    cout << endl;
    return 0;
}

D. DS栈+队列—排队游戏

幼儿园中，老师安排小朋友做一个排队的游戏。首先老师精心的把数目相同的小男孩和小女孩编排在一个队列中，每个小孩按其在队列中的位置发给一个编号（编号从0开始）。然后老师告诉小朋友们，站在前边的小男孩可以和他后边相邻的小女孩手拉手离开队列，剩余的小朋友重新站拢，再按前后相邻的小男孩小女孩手拉手离开队列游戏，如此往复。由于教师精心的安排，恰好可以保证每两个小朋友都能手拉手离开队列，并且最后离开的两个小朋友是编号最小的和最大的两个小朋友。（注：只有小男孩在前，小女孩在后，且他们两之间没有其他的小朋友，他们才能手拉手离开队列）。请根据老师的排队，按小女孩编号从小到大的顺序，给出所有手拉手离开队列的小男孩和小女孩的编号对。

输入

用一个字符串代表小朋友队列。字符串中只会出现两个字符，分别代表小男孩和小女孩，首先出现的字符代表小男孩，另一个字符代表小女孩。小孩总数不超过100。

输出

按小女孩编号顺序，顺序输出手拉手离开队列的小男孩和小女孩的编号对，每行一对编号，编号之间用一个空格分隔。

输入：
((()(())())(()))
输出：
2 3
5 6
4 7
8 9
1 10
12 13
11 14
0 15

#include <iostream>
#include <list>
#include <queue>
#include <set>
#include <vector>

using namespace std;

int main() {
    int n;
    cin >> n;
    queue<int> *q = new queue<int>[n];
    set<int> *s = new set<int>[n];
    deque<int> v;
    for (int i = 0; i < n; i++) {
        int m;
        cin >> m;
        for (int j = 0; j < m; j++) {
            int x;
            cin >> x;
            s[i].insert(x);
        }
    }
    int cnt = 0;
    while (true) {
        string op;
        cin >> op;
        if (op == "STOP") {
            break;
        } else if (op == "ENQUEUE") {
            int x;
            cin >> x;
            int i = 0;
            for (; i < n; i++) {
                if (s[i].find(x) != s[i].end()) {
                    break;
                }
            }
            auto it = v.begin();
            for (; it != v.end(); it++) {
                if (*it == i) {
                    break;
                }
            }
            if (it == v.end()) {
                v.push_back(i);
            }
            q[i].push(x);
        } else if (op == "DEQUEUE") {
            if (cnt) {
                cout << " " << q[v.front()].front();
            } else {
                cout << q[v.front()].front();
            }
            cnt++;
            q[v.front()].pop();
            if (q[v.front()].empty()) {
                v.pop_front();
            }
        }
    }
    cout << endl;
    return 0;
}

E. 银行排队问题之单队列多窗口服务

假设银行有K个窗口提供服务，窗口前设一条黄线，所有顾客按到达时间在黄线后排成一条长龙。当有窗口空闲时，下一位顾客即去该窗口处理事务。当有多个窗口可选择时，假设顾客总是选择编号最小的窗口。

本题要求输出前来等待服务的N位顾客的平均等待时间、最长等待时间、最后完成时间，并且统计每个窗口服务了多少名顾客。

输入

输入第1行给出正整数N（≤1000），为顾客总人数；随后N行，每行给出一位顾客的到达时间T和事务处理时间P，并且假设输入数据已经按到达时间先后排好了顺序；最后一行给出正整数K（≤10），为开设的营业窗口数。这里假设每位顾客事务被处理的最长时间为60分钟。

输出

在第一行中输出平均等待时间（输出到小数点后1位）、最长等待时间、最后完成时间，之间用1个空格分隔，行末不能有多余空格。

在第二行中按编号递增顺序输出每个窗口服务了多少名顾客，数字之间用1个空格分隔，行末不能有多余空格。

 

输入：
9
0 20
1 15
1 61
2 10
10 5
10 3
30 18
31 25
31 2
3
输出：
6.2 17 61
5 3 1
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <queue>

using namespace std;

int main() {
    int n;
    cin >> n;
    queue<pair<int, int>> q;
    int i;
    for (i = 0; i < n; i++) {
        int a, b;
        cin >> a >> b;
        q.push(make_pair(a, min(60, b)));
    }
    int k;
    cin >> k;
    int *w = new int[k];
    int *num = new int[k];
    for (i = 0; i < k; i++) {
        w[i] = 0;
        num[i] = 0;
    }
    int wait = 0, maxn = -9999, sum = 0;
    while (!q.empty()) {
        int flag = 0;
        int minn = 9999, imin = 0;
        for (i = 0; i < k; i++) {
            if (w[i] <= q.front().first) {
                w[i] = q.front().first + q.front().second;
                num[i]++;
                flag = 1;
                q.pop();
                break;
            }
            if (minn > w[i]) {
                minn = w[i];
                imin = i;
            }
        }
        if (flag == 0) {
            wait = w[imin] - q.front().first;
            w[imin] += q.front().second;
            maxn = max(maxn, wait);
            sum += wait;
            num[imin]++;
            q.pop();
        }
    }
    int last = w[0];
    for (i = 0; i < k; i++) {
        last = max(last, w[i]);
    }
    cout << fixed << setprecision(1) << sum * 1.0 / n * 1.0 << " " << maxn << " " << last << endl;
    for (i = 0; i < k; i++) {
        cout << num[i];
        if (i != k - 1) cout << " ";
        else cout << endl;
    }
    return 0;
}

 

F. 银行排队问题之单队列多窗口加VIP服务

假设银行有K个窗口提供服务，窗口前设一条黄线，所有顾客按到达时间在黄线后排成一条长龙。当有窗口空闲时，下一位顾客即去该窗口处理事务。当有多个窗口可选择时，假设顾客总是选择编号最小的窗口。

有些银行会给VIP客户以各种优惠服务，例如专门开辟VIP窗口。为了最大限度地利用资源，VIP窗口的服务机制定义为：当队列中没有VIP客户时，该窗口为普通顾客服务；当该窗口空闲并且队列中有VIP客户在等待时，排在最前面的VIP客户享受该窗口的服务。同时，当轮到某VIP客户出列时，若VIP窗口非空，该客户可以选择空闲的普通窗口；否则一定选择VIP窗口。

本题要求输出前来等待服务的N位顾客的平均等待时间、最长等待时间、最后完成时间，并且统计每个窗口服务了多少名顾客。

输入

输入第1行给出正整数N（≤1000），为顾客总人数；随后N行，每行给出一位顾客的到达时间T、事务处理时间P和是否VIP的标志（1是VIP，0则不是），并且假设输入数据已经按到达时间先后排好了顺序；最后一行给出正整数K（≤10）—— 为开设的营业窗口数，以及VIP窗口的编号（从0到K−1）。这里假设每位顾客事务被处理的最长时间为60分钟。

输出

在第一行中输出平均等待时间（输出到小数点后1位）、最长等待时间、最后完成时间，之间用1个空格分隔，行末不能有多余空格。

在第二行中按编号递增顺序输出每个窗口服务了多少名顾客，数字之间用1个空格分隔，行末不能有多余空格。

输入：
10
0 20 0
0 20 0
1 68 1
1 12 1
2 15 0
2 10 0
3 15 1
10 12 1
30 15 0
62 5 1
3 1
输出：
15.1 35 67
4 5 1
#include <iostream>
#include <vector>
#include <iomanip>

using namespace std;

typedef struct client {
    int T;
    int P;
    int vip;
} client;

int main() {
    int N;
    cin >> N;
    vector<client> person;
    for (int i = 0; i < N; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        person.push_back({ a, min(60, b), c });
    }
    int num, vipwindows;
    cin >> num >> vipwindows;
    int* windows = new int[num];
    int* sum = new int[num];
    for (int i = 0; i < num; i++) {
        windows[i] = 0, sum[i] = 0;
    }
    int maxtime = 0, avgtime = 0;
    int now = 0;
    while (true) {
        if (windows[vipwindows] == 0) {
            for (int i = 0; i < person.size(); i++) {
                if (now >= person[i].T) {
                    if (person[i].vip == 1) {
                        windows[vipwindows] += person[i].P;
                        sum[vipwindows]++;
                        avgtime += now - person[i].T;
                        if (now - person[i].T > maxtime)
                            maxtime = now - person[i].T;
                        person.erase(person.begin() + i);
                        break;
                    }
                }
                else
                    break;
            }
        }
        for (int i = 0; i < num; i++) {
            if (person.empty())
                break;
            if (windows[i] == 0) {
                for (int j = 0; j < person.size(); j++) {
                    if (now >= person[j].T) {
                        windows[i] += person[j].P;
                        sum[i]++;
                        avgtime += now - person[j].T;
                        if (now - person[j].T > maxtime)
                            maxtime = now - person[j].T;
                        person.erase(person.begin());
                        break;
                    }
                    else
                        break;
                }
            }
        }
        int flag = 0;
        for (int i = 0; i < num; i++) {
            if (windows[i] > 0)
                windows[i]--;
            if (windows[i] > 0)
                flag = 1;
        }
        now++;
        if (flag == 0 && person.empty())
            break;
    }
    cout << fixed << setprecision(1) << (avgtime * 1.0) / N;
    cout << " " << maxtime << " " << now << endl;
    for (int i = 0; i < num; i++) {
        cout << sum[i];
        if (i != num - 1)
            cout << " ";
    }
    return 0;
}

要被ddl噶辣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++队列相关内容（题目+解析）
linghies的博客
04-22 2880
队列相关内容 0. 简述 先简述一下queue容器的使用： 队列queue的用法如下： 1.包含头文件：#include 2.定义一个整数队列对象：queue myQe; 3.定义一个整数队列对象数组：queue myQA[10]; 4.入队操作：myQe.push(itemp); //把整数itemp进入队列 5.出队操作：myQe.pop(); //把队头元素弹出队列，注意本操作不获取队头元素 6.获取队头元素： itemp = myQe.front(); // 把队头元素放入itemp中，注
C++-queue头文件-队列常用函数-#include＜queue＞新手入门
KIDaptx4869的博客
07-20 1万+
在front，即队头，允许删除操作，进行出列操作，在rear，即队尾，允许插入操作，进行入列操作。在建立的队列q中压入5,10，15，三个整型数据，此时队列按照先进先出的原则，pop出队首的数据后，此时队列队首的数据应为10。在建立的队列q中压入5,10，15，三个整型数据，此时队列按照先进先出的原则，队首的数据应为5。在未压入数据时，此时列表q为空，true，输出为1，当压入数据后，列表不为空，输出为0.队列为空时，q的size为0，当压入三个数据之后，队列的size为3.队尾的数据应为15。...
队列实验代码
最新发布
盧瞳的代码博客
04-25 147
【代码】队列实验代码。
C++大一基础知识
m0_73804671的博客
06-18 2048
大一C++基础知识汇总~
#include ＜queue＞
2301_78942489的博客
02-07 648
/结构体rec中必须定义小于号。头文件queue主要包括循环队列queue和优先队列priority_queue两个容器。top 查询堆顶元素（最大值）front 返回队头元素。back 返回队尾元素。push 把元素插入堆。push 从队尾插入。pop 删除堆顶元素。
#include<queue> 【c++】
记事本
08-10 4253
#include #include using namespace std; //这几个头文件必不可少 int main() { queue q; //使用前需定义一个queue变量，且定义时已经初始化 while(!q.empty()) q.pop(); //重复使用时，用这个初始化 q.push(1); //进队列 q.pop(); //出队列 int v=q.fro
【数据结构实验】队列的应用
06-15
1.实验目的： 熟悉队列的定义，队列的特点以及队列的基本操作。能够根据实际情况选择合适的存储结构，解决实际问题。 2.实验内容： 利用循环队列模拟舞伴配对问题： 1、利用循环队列模拟舞伴配对问题。在舞会上，...
数据结构实验 堆栈和队列的应用
12-07
实验五 堆栈和队列的应用 一、实验目的 掌握堆栈和队列的使用。 二、实验内容 1、计算数学表达式的值。 输入数学表达式，输出表达式的计算结果。数学表达式由单个数字和运算符“+”、“-”、“*”、“/”、“(、...
C++数据结构实验二：栈与队列的应用
03-31
1．熟练掌握栈和队列的基本运算。 2．掌握在两种存储结构上对栈和队列所施加的入栈、出栈、入队和出队的实现。 3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列...
实验4 队列.zip
05-23
本实验的主题是“队列”，一个基础且重要的数据结构。队列是一种线性数据结构，遵循“先进先出”（FIFO，First In First Out）的原则，类似于现实生活中的排队等候。 队列的基本操作包括： 1. **入队（Enqueue）**...
C++栈和队列（详解+刷题）
IT OR 考公？
07-10 2161
顺序栈，链栈，顺序队列，链队列
[C++基础]队列<queue>中的常用函数
now
03-18 652
转载于：https://www.cnblogs.com/xuning/p/3321733.html 在C++中只要#include&lt;queue&gt;即可使用队列类，其中在面试或笔试中常用的成员函数如下（按照最常用到不常用的顺序） 1. push 2. pop 3. size 4. empty 5. front 6. back 接下来逐一举例说明： 1. push 队列中...
#include<queue>使用方法简介
热门推荐
wardseptember的博客
06-10 1万+
队列的定义 队列是一种容器适配器，专门设计用于在FIFO上下文（先进先出）中操作，其中元素插入容器的一端并从另一端提取。 队列被实现为容器适配器，它是使用特定容器类的封装对象作为其基础容器的类，提供一组特定的成员函数来访问其元素。 元素被推入特定容器的“背部”并从其“前”弹出。 成员函数 Member functions (constructor)Construct queue (p...
问题 A: 算法3-7：银行排队
weixin_51988154的博客
07-02 1551
时间限制:1 Sec内存限制:32 MB 提交:751解决:509 题目描述 我们大多都有在银行排队的经历，唉，那坑爹的排队啊！现在就让我们来算算我们这些客户平均需要等多久吧。 每天刚开始时银行会开m个窗口来为我们total个客户办理业务，当有客户需要办理业务时，先选择可以办理业务的窗口，如果有多个窗口可以办理业务就选择空闲时间最长的窗口，如果有多个窗口空闲的时间一样长，则选择序号小的窗口办理业务。假设我们每个人来到的时间和办理业务所需要的时间（为了简化问题，采用整数表示时间）都知道...
C语言【数据结构】栈和队列【OJ题（C++）、选择题】
冰果滴的博客
06-12 2180
目录一.OJ题1.225. 用队列实现栈2.232. 用栈实现队列3.622. 设计循环队列4.20. 有效的括号二.选择题1.下列关于栈的叙述正确的是（B）2.一个栈的入栈序列为ABCDE，则不可能的出栈序列为（D）3.链栈与顺序栈相比，比较明显的优点是（C）4.下列关于用栈实现队列的说法中错误的是（B）5.用无头单链表存储队列，其头指针指向队头结点，尾指针指向队尾结点，则在进行出队操作时（C）6.以下不是队列的基本运算的是（B）7.下面关于栈和队列的说法中错误的是（AB）8.下列关于顺序结构实现循环队列
c++stl之queue（队列）oj题目练习
zhoucheng_123的博客
01-14 2753
nefu 1632 周末舞会-队列 熟悉语法题，不难 #include <bits/stdc++.h> using namespace std; int main() { int m,n,k; cin>>n>>m>>k; queue<int>q1,q2; for(int i=1;i<=n;i++)...
#include <queue>
B1334628598的博客
08-07 175
双端队列deque比向量vector更有优势 双端队列(deque) 连续存储的指向不同元素的指针所组成的数组<deque> 队列(queue) 先进先出的值的排列 <queue> 优先队列(priority_queue) 元素的次序是由作用于所存储的值对上的某种谓词决定的的一种队列 <queue> 1 back(); 返...
容器适配器之queue用法总结
陈实Yepper
12-23 1114
只能访问 queue 容器适配器的第一个和最后一个元素。只能在容器的末尾添加新元素，只能从头部移除元素。 许多程序都使用了 queue 容器。queue 容器可以用来表示超市的结账队列或服务器上等待执行的数据库事务队列。对于任何需要用 FIFO 准则处理的序列来说，使用 queue 容器适配器都是好的选择。 图 1 展示了一个 queue 容器及其一些基本操作： queue 的生成方式和 sta...
栈、队列的应用实验原理
05-27
通过实验，我深入理解了栈和队列的原理和应用场景，并掌握了相应的编程技巧。同时，我也认识到了数据结构在实际应用中的重要性，需要在编写程序时根据实际情况选择合适的数据结构，以提高程序的效率和可靠性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值