PAT A 1026 Table Tennis 模拟

于 2019-07-21 16:39:31 发布
阅读量128 收藏
点赞数
分类专栏： PAT 文章标签： PAT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chch1996/article/details/96733852
版权

PAT A 1026 Table Tennis 解题报告

还不熟悉markdown语法，就先不在意格式了。
刷了一个多月的PAT，第一篇解题报告就献给A1026这个对我而言非常复杂的模拟题吧。
题目的主要设定有以下几点：
(1) 玩的时间不能超过2h。
(2) 优先选择序号小的空桌。
(3) 在21:00之后（含21：00）还没玩上的玩家不需要输出。
(4) 玩家有是否vip之分，桌子也有是否vip之分。vip玩家优先选择序号小的vip空桌。
(5) 当vip玩家和非vip玩家都在排队，且有vip桌子空出时，vip玩家优先，并选择空出的vip桌子。如果是非vip桌子空出，那么仍按照到达时间顺序优先。

解题思路：我个人想出的解题思路不是很好，代码也非常冗长，但还是记录一下表示纪念（好不容易ac了）。

首先很正常的想到根据到达时间顺序将玩家进行排序。
由于有设定(5)：“排队时vip可以插队”的存在， 不能简单按照到达时间顺序对玩家进行一个一个的处理，而要考虑到非vip玩家和vip玩家都在排队这一情况。考虑这一情况的方法是将vip玩家和非vip玩家分开，分别按到达时间排序，并与所有桌子中最小的空出时间比较。
使用vector<player> isVip, notVip来记录两种玩家，并按到达时间顺序排序。之后，一个一个进行处理。可以使用两个队列，每次处理完 pop 一个，循环终止条件是两个队列都空。我这里用的是vector, 每次处理完将对应组的下标++，初始时对应组的下标都是0， 表示当前处理的元素的位置是队首。 循环终止条件是已经处理的人数 cnt 等于总人数N。然后就是循环处理：

step1: 遍历所有桌子，找到最小的空出时间 minTime， 以及空出时间是minTime的最小序号桌子 i 和最小序号vip桌子 j ， j 的初值设为 -1。

step2: 取 isVip 和 notVip 的对应下标指向元素， 记为 firstVip 和 firstNotVip。

step3: 根据 firstVip 和 firstNotVip 的到达时间 与 minTime 的大小关系，分为以下四种情况：

  • (1) firstVip 的到达时间和 firstNotVip 的到达时间都小于等于 minTime。说明firstVip 和 firstNotVip 之前都在排队等待空桌。这时再根据空出桌子的情况进一步细分：
    • 如果 j >-1， 说明有vip桌子空出，那么直接将firstVip分配到该桌子，更新桌子的空出时间， cnt++， vip组下标++，这一轮循环结束。
    • 如果没有vip桌子空出，那么根据 firstVip 和 firstNotVip 的到达顺序，将桌子 i 分配给对应先到者，更新桌子的空出时间， cnt++， 先到者所在组的下标++，这一轮循环结束。
  • (2) firstVip 的到达时间 小于等于minTime， firstNotVip的到达时间大于minTime, 说明 firstVip 在排队，并且要给 firstVip 分配空桌， 如果 j > -1， 说明有vip桌子空出，将firstVip分配到桌子 j , 否则将firstVip分配到桌子 i 。更新桌子的空出时间， cnt++, vip组下标++， 这一轮循环结束。
  • (3) firstVip 的到达时间大于minTime, firstNotVip 的到达时间小于 minTime, 说明firstNotVip 在排队， 直接将firstNotVip 分配到桌子 i , 更新桌子的空出时间， cnt++, notvip组下标++， 这一轮循环结束。
  • (4) firstVip 和 firstNotVip 的到达时间都大于 minTime, 那么为先到者分配最小序号空桌。但是这时需要注意桌子 i 可能不是最小序号的空出桌子了，因为其他桌也可能已经空出，只是空出时间不是minTime而已。这里的最小序号空出桌子需要根据先到者的到达时间重新遍历所有桌子来寻找。同时，如果先到者是vip，还需要寻找是否有空出的vip桌子，如果有就分配到vip桌。 最后更新桌子的空出时间，cnt++, 先到者所在组下标++, 这一轮循环结束。

需要注意的是用这种思路，需要在 isVip 和 notVip两个vector或队列的末尾加上一个到达时间24：00：00的无效元素，否则处理完某组的最后一个有效元素后，下标会越界，加上之后不影响原思路并且防止了越界。

最后就是输出结果了，注意等待时间需要四舍五入用round函数再强制转换成 int 就好。

根据这个思路写的代码非常冗长，也没有用到任何数据结构（虽然这题看起来很像是要用优先队列，奈何太菜了）。还没有观摩其他简洁的解法，将来有时间再补充到这篇报告里。

以下是我的代码，非常冗长：

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
using namespace std;

int timeToSec(int h, int m, int s)
{
    return h * 3600 + m * 60 + s;
}

void secToTime(int sec)
{
    int h = sec / 3600, m = sec % 3600 / 60, s = sec %3600 %60;
    printf("%02d:%02d:%02d ", h, m, s);
}

struct player
{
    int arriveTime;
    int playTime;
    int startPlayTime;
    player(int _arriveTime, int _playTime, int _isVIP)
    {
        arriveTime = _arriveTime;
        startPlayTime = 0x7FFFFFFF;
        playTime = _playTime;
    }
    player()
    {

    }
};

bool cmpPlayer(player a, player b)
{
    return a.arriveTime < b.arriveTime;
}

struct table
{
    int index;
    int endTime;
    int serveNum;
    int isVIP;
    table()
    {
        endTime = timeToSec(8,0,0);
        serveNum = 0;
        isVIP = 0;
    }
};

int waitTime(int arriveTime, int startTime)
{
    return (int)round((startTime - arriveTime) / 60.0);
}

vector<player> notVip, isVip, vp;
int main() {

    int N;
    cin >> N;
    int cnt = 0, ptrIsVip = 0, ptrNotVip = 0;
    for (int i = 0; i < N; ++i)
    {
        int h, m, s, p, isvip;
        scanf("%d:%d:%d %d %d", &h, &m, &s, &p, &isvip);
        if(p > 120) p = 120;
        if(isvip) isVip.push_back(player(timeToSec(h, m, s), p*60, isvip));
        else notVip.push_back(player(timeToSec(h, m, s), p*60, isvip));
    }
    int K, M;
    cin >> K >> M;
    vector<table> tables;
    tables.resize(K);
    for (int i = 0; i < K; ++i)
    {
        tables[i].index = i;
    }
    for (int i = 0; i < M; ++i)
    {
        int num;
        scanf("%d", &num);
        tables[num-1].isVIP = 1;
    }
    isVip.push_back(player(24 * 3600, 0, 1));
    notVip.push_back(player(24 * 3600, 0, 0));
    sort(isVip.begin(), isVip.end(), cmpPlayer);
    sort(notVip.begin(), notVip.end(), cmpPlayer);
    while(cnt < N && ptrIsVip < isVip.size() && ptrNotVip < notVip.size())
    {
        vector<table> emptyTable;
        int minTime = 0x7FFFFFF;
        for (int i = 0; i < K; ++i)
        {
            if(tables[i].endTime < minTime)
            {
                minTime = tables[i].endTime;
                emptyTable.clear();
                emptyTable.push_back(tables[i]);
            }
            else if(tables[i].endTime == minTime)
            {
                emptyTable.push_back(tables[i]);
            }
        }
        int firstEmptyTable = emptyTable[0].index;
        bool vipTableEmpty = 0;
        int firstEmptyVipTable = 0;
        for (int j = 0; j < emptyTable.size(); ++j)
        {
            if(emptyTable[j].isVIP == 1)
            {
                vipTableEmpty = 1;
                firstEmptyVipTable = emptyTable[j].index;
                break;
            }
        }
        player &firstVip = isVip[ptrIsVip];
        player &firstNotVip = notVip[ptrNotVip];
        if(firstVip.arriveTime <= minTime && firstNotVip.arriveTime <= minTime)
        {
            if(vipTableEmpty == 1)
            {
                firstVip.startPlayTime = minTime;
                if(firstVip.startPlayTime < 21 * 3600)
                {
                    tables[firstEmptyVipTable].endTime = minTime + firstVip.playTime;
                    tables[firstEmptyVipTable].serveNum++;
                    vp.push_back(firstVip);
                }
                cnt++;
                ptrIsVip++;
            }
            else
            {
                if(firstVip.arriveTime < firstNotVip.arriveTime)
                {
                    firstVip.startPlayTime = minTime;
                    if(firstVip.startPlayTime < 21 * 3600)
                    {
                        tables[firstEmptyTable].endTime = minTime + firstVip.playTime;
                        tables[firstEmptyTable].serveNum++;
                        vp.push_back(firstVip);
                    }
                    cnt++;
                    ptrIsVip++;
                }
                else
                {
                    firstNotVip.startPlayTime = minTime;
                    if(firstNotVip.startPlayTime < 21 * 3600)
                    {
                        tables[firstEmptyTable].endTime = minTime + firstNotVip.playTime;
                        tables[firstEmptyTable].serveNum++;
                        vp.push_back(firstNotVip);
                    }
                    cnt++;
                    ptrNotVip++;
                }
            }
        }
        else if(firstVip.arriveTime > minTime && firstNotVip.arriveTime <= minTime)
        {
            firstNotVip.startPlayTime = minTime;
            if(firstNotVip.startPlayTime < 21 * 3600)
            {
                tables[firstEmptyTable].endTime = minTime + firstNotVip.playTime;
                tables[firstEmptyTable].serveNum++;
                vp.push_back(firstNotVip);
            }
            cnt++;
            ptrNotVip++;
        }
        else if(firstVip.arriveTime <= minTime && firstNotVip.arriveTime > minTime)
        {
            firstVip.startPlayTime = minTime;
            if(firstVip.startPlayTime < 21 * 3600)
            {
                if(vipTableEmpty == 1) firstEmptyTable = firstEmptyVipTable;
                tables[firstEmptyTable].endTime = minTime + firstVip.playTime;
                tables[firstEmptyTable].serveNum++;
                vp.push_back(firstVip);
            }
            cnt++;
            ptrIsVip++;
        }
        else if(firstVip.arriveTime > minTime && firstNotVip.arriveTime > minTime)
        {
            if(firstVip.arriveTime < firstNotVip.arriveTime)
            {
                int firstEmptyVipTableTmp = -1;
                for (int i = 0; i < K; ++i)
                {
                    if(tables[i].endTime <= firstVip.arriveTime)
                    {
                        firstEmptyTable = i;
                        break;
                    }
                }
                for (int i = 0; i < K; ++i)
                {
                    if(tables[i].endTime <= firstVip.arriveTime && tables[i].isVIP == 1)
                    {
                        firstEmptyVipTableTmp = i;
                        break;
                    }
                }
                if(firstEmptyVipTableTmp > -1) firstEmptyTable = firstEmptyVipTableTmp;
                firstVip.startPlayTime = firstVip.arriveTime;
                if(firstVip.startPlayTime < 21 * 3600)
                {
                    tables[firstEmptyTable].endTime = firstVip.startPlayTime + firstVip.playTime;
                    tables[firstEmptyTable].serveNum++;
                    vp.push_back(firstVip);
                }
                cnt++;
                ptrIsVip++;
            }
            else
            {
                for (int i = 0; i < K; ++i)
                {
                    if(tables[i].endTime <= firstNotVip.arriveTime)
                    {
                        firstEmptyTable = i;
                        break;
                    }
                }
                firstNotVip.startPlayTime = firstNotVip.arriveTime;
                if(firstNotVip.startPlayTime < 21 * 3600)
                {
                    tables[firstEmptyTable].endTime = firstNotVip.startPlayTime + firstNotVip.playTime;
                    tables[firstEmptyTable].serveNum++;
                    vp.push_back(firstNotVip);
                }
                cnt++;
                ptrNotVip++;
            }
        }
    }
    for (int i = 0; i < vp.size(); ++i)
    {
        int arriveTime = vp[i].arriveTime, startTime = vp[i].startPlayTime;
        secToTime(arriveTime);
        secToTime(startTime);
        printf("%d\n", waitTime(arriveTime, startTime));
    }
    for (int i = 0; i < K; ++i)
    {
        printf("%d", tables[i].serveNum);
        if(i < K - 1) printf(" ");
    }
    return 0;
}
HackingGate
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【PAT】A1026 Table Tennis【快乐模拟】
elegant coder
08-31 868
A table tennis club has N tables available to the public. The tables are numbered from 1 to N. For any pair of players, if there are some tables open when they arrive, they will be assigned to the ava...
PAT1026 TableTennis
chem2cs的博客
08-26 307
PAT终于刷完了，很后悔没有一边刷一边写博客，希望以后空闲的时候能慢慢补齐。这道题是我完成的最后一道题，也是我最不擅长的模拟题，卡了许久，最后终于理清了逻辑，AC掉。其实模拟题最重要的是处理逻辑，只要逻辑理顺，代码实现自然不是问题。完成这道题后，我也搜了许多其他人的代码，发现讲思路的很少，或者我觉得不够直观，所以在此将自己的思路记录下来，一方面备忘，一方面希望帮助更多的人。先分析题意，总结要点如下：
PAT 甲级 1026 Table Tennis（模拟）
Dacc123的博客
05-31 828
PAT 甲级 1026 Table Tennis（模拟）
PAT甲级 1026 Table Tennis 模拟+排序
化身孤岛的鲸o的博客
05-16 459
Solution： 这道题的意思是有一家桌球俱乐部，这个俱乐部共有k个台球桌，其中m个是vip桌，剩余的是普通桌。这些桌子都有一个编号1~k。这家俱乐部的营业时间为8:00:00 ~ 21:00:00。共有n个顾客会来打桌球，它们的到来时间都不同。规则是，如果vip桌子有空闲，而且队列里面有vip成员，那么等待队列中的第一个vip球员会到最小的vip球桌训练。如果vip桌子空闲但是没有vip来...
C#例子代码 A0102_Path
06-17
C#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 A0102_PathC#例子代码 ...
C#例子代码 A4001_PathAna
06-17
C#例子代码 A4001_PathAnaC#例子代码 A4001_PathAnaC#例子代码 A4001_PathAnaC#例子代码 A4001_PathAnaC#例子代码 A4001_PathAnaC#例子代码 A4001_PathAnaC#例子代码 A4001_PathAnaC#例子代码 A4001_PathAnaC#例子...
pat甲级单词pat甲级单词pat甲级单词
06-12
pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词...
PAT乙级1022 D进制的A+B
06-06
PAT乙级1022源代码 codeblocks 输入两个非负10进制整数A和B()，输出A+B的D (1 )进制数。
PAT_Alevel:http
05-09
浙江大学的PAT（Programming Ability Test）是一项旨在考察计算机编程能力的考试，其中A Level部分主要面向非计算机专业的学生，涉及基础的算法和数据结构。本资料集"PAT_Alevel:http"是针对这一考试的一系列算法...
qt练习控件label控件-lineEdit控件样例代码
07-30
qt练习控件label控件-lineEdit控件样例代码
【JCR一区级】麻雀搜索算法SSA-CNN-LSTM-Attention故障诊断分类预测【含源码 5689期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Attention分类系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Attention分类 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Attention分类 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Attention分类 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Attention分类 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Attention分类
详解MATLAB Simulink通信系统建模与仿真
07-30
第1 章 MATLAB 基础与通信系统仿真 1.1 MATLAB 简介 1.2 MATLAB 程序设计 1.3 通信系统仿真 第2 章 Simulink 仿真基础 2.1 Simulink 简介 2.2 Simulink 工作环境 2.3 Simulink 仿真的基本方法 2.4 创建自己的模块库 2.5 S-函数的编写 第3 章 通信信号与系统分析 3.1 离散信号和系统 3.2 Fourier 分析 3.3 带通信号的低通等效 3.4 随机信号分析 第4 章 信道 4.1 加性高斯白噪声信道 4.2 多径衰落信道 第5 章 模拟调制 5.1 幅度调制 5.2 角度调制 第6 章 数字基带传输 6.1 概述 6.2 二进制基带信号传输 6.3 基带PAM 信号传输 6.4 带限信道的信号传输 第7 章 数字信号载波传输 7.1 概述 7.2 载波幅度调制（PAM） 7.3 载波相位调制（PSK） 7.4 正交幅度调制（QAM） 7.5 载波频率调制（FSK） 第8 章 信道编码和交织 8.1 概述 8.2 线性分组码
SCI一区】淘金算法GRO-CNN-BiLSTM-Mutilhead-Attention多变量时序预测含源码 5642.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-BiLSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-BiLSTM-Mutilhead-Attention回归预测
2020年首届“洪泽湖杯”中国人工智能掼蛋算法大赛第8名我就是掼蛋.zip
07-30
毕业设计是高等教育阶段学生完成学业的一个重要环节，通常在学士或硕士学业即将结束时进行。这是学生将在整个学业中所学知识和技能应用到实际问题上的机会，旨在检验学生是否能够独立思考、解决问题，并展示其专业能力的一项综合性任务。 毕业设计的主要特点包括： 独立性： 毕业设计要求学生具备独立思考和解决问题的能力。学生需要选择一个合适的课题，研究相关文献，进行实地调查或实验，并提出独立见解。 实践性： 毕业设计是将理论知识应用到实际问题中的一次实践。通过完成毕业设计，学生能够将所学的专业知识转化为实际的解决方案，加深对专业领域的理解。 综合性： 毕业设计往往要求学生运用多个学科的知识，综合各种技能。这有助于培养学生的综合素养，提高他们的综合能力。 导师指导： 学生在毕业设计过程中通常由一名指导老师或导师团队提供指导和支持。导师负责引导学生确定研究方向、制定计划、提供建议，并在整个过程中监督进展。 学术规范： 毕业设计要求学生按照学术规范完成研究，包括文献综述、研究设计、数据采集与分析、结论和讨论等环节。学生需要撰写一篇完整的毕业论文，并进行答辩。
网络音乐搜索引擎，音乐搜索器 - 多站合一音乐搜索,音乐在线试听
最新发布
07-30
网络音乐搜索引擎，音乐搜索器 - 多站合一音乐搜索,音乐在线试听 效果截图https://www.diyiyuanma.cn/3444.html 多站合一音乐搜索解决方案，数据调用的是各网站的API接口， 有的接口并不是开放的，随时可能失效，本项目相关代码仅供参考。 网络音乐搜索引擎，音乐搜索器 - 多站合一音乐搜索,音乐在线试听
这是一个旨在简化合约部署、验证、交互等操作用于生成区块链智能合约Foundry框架指令的 Web3.0开发者工具
07-30
这是一个旨在简化合约部署、验证、交互等操作用于生成区块链智能合约Foundry框架指令的 Web3.0开发者工具。
三种esprit算法实现doa估计 _rezip.zip
07-30
在信号处理领域，DOA（Direction of Arrival）估计是一项关键技术，主要用于确定多个信号源到达接收阵列的方向。本文将详细探讨三种ESPRIT（Estimation of Signal Parameters via Rotational Invariance Techniques）算法在DOA估计中的实现，以及它们在MATLAB环境中的具体应用。 ESPRIT算法是由Paul Kailath等人于1986年提出的，其核心思想是利用阵列数据的旋转不变性来估计信号源的角度。这种算法相比传统的 MUSIC（Multiple Signal Classification）算法具有较低的计算复杂度，且无需进行特征值分解，因此在实际应用中颇具优势。 1. 普通ESPRIT算法 普通ESPRIT算法分为两个主要步骤：构造等效旋转不变系统和估计角度。通过空间平移（如延时）构建两个子阵列，使得它们之间的关系具有旋转不变性。然后，通过对子阵列数据进行最小二乘拟合，可以得到信号源的角频率估计，进一步转换为DOA估计。 2. 常规ESPRIT算法实现 在描述中提到的`common_esprit_method1.m`和`common_esprit_method2.m`是两种不同的普通ESPRIT算法实现。它们可能在实现细节上略有差异，比如选择子阵列的方式、参数估计的策略等。MATLAB代码通常会包含预处理步骤（如数据归一化）、子阵列构造、旋转不变性矩阵的建立、最小二乘估计等部分。通过运行这两个文件，可以比较它们在估计精度和计算效率上的异同。 3. TLS_ESPRIT算法 TLS（Total Least Squares）ESPRIT是对普通ESPRIT的优化，它考虑了数据噪声的影响，提高了估计的稳健性。在TLS_ESPRIT算法中，不假设数据噪声是高斯白噪声，而是采用总最小二乘准则来拟合数据。这使得算法在噪声环境下表现更优。`TLS_esprit.m`文件应该包含了TLS_ESPRIT算法的完整实现，包括TLS估计的步骤和旋转不变性矩阵的改进处理。 在实际应用中，选择合适的ESPRIT变体取决于系统条件，例如噪声水平、信号质量以及计算资源。通过MATLAB实现，研究者和工程师可以方便地比较不同算法的效果，并根据需要进行调整和优化。同时，这些代码也为教学和学习DOA估计提供了一个直观的平台，有助于深入理解ESPRIT算法的工作原理。
细胞分割计数matlab程序 附GUI 1.zip
07-30
细胞分割计数matlab程序 附GUI 1
pat数据结构期中模拟2021
09-10
PAT数据结构期中模拟2021是一次针对数据结构知识的考试，旨在测试学生对于数据结构概念和应用的理解能力。该考试通常包含多种题型，如选择题、编程题等，考察学生对于树、图、队列、栈等数据结构的掌握程度以及解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值