A - 咕咕东的目录管理器
题目
咕咕东的雪梨电脑的操作系统在上个月受到宇宙射线的影响，时不时发生故障，他受不了了，想要写一个高效易用零bug的操作系统 —— 这工程量太大了，所以他定了一个小目标，从实现一个目录管理器开始。前些日子，东东的电脑终于因为过度收到宇宙射线的影响而宕机，无法写代码。他的好友TT正忙着在B站看猫片，另一位好友瑞神正忙着打守望先锋。现在只有你能帮助东东！
初始时，咕咕东的硬盘是空的，命令行的当前目录为根目录 root。
目录管理器可以理解为要维护一棵有根树结构，每个目录的儿子必须保持字典序。
现在咕咕东可以在命令行下执行以下表格中描述的命令：
- MKDIR s 操作 在当前目录下创建一个子目录 s，s 是一个字符串 创建成功输出 “OK”；若当前目录下已有该子目录则输出 “ERR”
- RM s 操作 在当前目录下删除子目录 s，s 是一个字符串 删除成功输出 “OK”；若当前目录下该子目录不存在则输出 “ERR”
- CD s 操作 进入一个子目录 s，s 是一个字符串（执行后，当前目录可能会改变） 进入成功输出 “OK”；若当前目录下该子目录不存在则输出 "ERR"特殊地，若 s 等于 “…” 则表示返回上级目录，同理，返回成功输出 “OK”，返回失败（当前目录已是根目录没有上级目录）则输出 “ERR”
- SZ 询问 输出当前目录的大小 也即输出 1+当前目录的子目录数
- LS 询问 输出多行表示当前目录的 “直接子目录” 名 若没有子目录，则输出 “EMPTY”；若子目录数属于 [1,10] 则全部输出；若子目录数大于 10，则输出前 5 个，再输出一行 “…”，输出后 5 个。
- TREE 询问 输出多行表示以当前目录为根的子树的前序遍历结果 若没有后代目录，则输出 “EMPTY”；若后代目录数+1（当前目录）属于 [1,10] 则全部输出；若后代目录数+1（当前目录）大于 10，则输出前 5 个，再输出一行 “…”，输出后 5 个。若目录结构如上图，当前目录为 “root” 执行结果如下，
- UNDO 特殊 撤销操作 撤销最近一个 “成功执行” 的操作（即MKDIR或RM或CD）的影响，撤销成功输出 “OK” 失败或者没有操作用于撤销则输出 “ERR”
输入
输入文件包含多组测试数据，第一行输入一个整数表示测试数据的组数 T （T <= 20）；
每组测试数据的第一行输入一个整数表示该组测试数据的命令总数 Q （Q <= 1e5）；
每组测试数据的 2 ~ Q+1 行为具体的操作 （MKDIR、RM 操作总数不超过 5000）；
面对数据范围你要思考的是他们代表的 “命令” 执行的最大可接受复杂度，只有这样你才能知道你需要设计的是怎样复杂度的系统。
输出
每组测试数据的输出结果间需要输出一行空行。注意大小写敏感。
时空限制
Time limit 6000 ms
Memory limit 1048576 kB
样例输入
1
22
MKDIR dira
CD dirb
CD dira
MKDIR a
MKDIR b
MKDIR c
CD ..
MKDIR dirb
CD dirb
MKDIR x
CD ..
MKDIR dirc
CD dirc
MKDIR y
CD ..
SZ
LS
TREE
RM dira
TREE
UNDO
TREE
样例输出
OK
ERR
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
9
dira
dirb
dirc
root
dira
a
b
c
dirb
x
dirc
y
OK
root
dirb
x
dirc
y
OK
root
dira
a
b
c
dirb
x
dirc
y
思路
这道题目着实复杂，有很多“关卡”需要闯。特别是tree操作的缓存以及undo过程的历史记录。
接下来写一下每个指令的具体过程：
- MKDIR：
- 首先判断目录是否存在
- 若不存在，则新建，并向上递归更新子节点数目和update标记
- 返回新建目录的指针
- RM：
- 断开目标目录与父目录的连接，但不能删除目录
- 递归地向上更新节点数目与update标记
- 将被删除的目录保存到历史记录中，以备恢复
- CD：
- 修改当前目录指针
- 将上一个目录的指针写入历史记录
- SZ：
- 输出当前节点为根的子树大小，因为我们对每个节点都有单独记录，因此只需要输出当前节点的成员即可。
- 这个指令不需撤销，不需要有历史记录。
- LS：
- 若没有子目录，则输出 “EMPTY”；
- 若子目录数属于 [1,10] 则全部输出；
- 若子目录数大于 10，则输出前 5 个，再输出一行 “…”，输出后 5 个。
- 这个指令不需撤销，不需要有历史记录。
- UNDO：
- 从记录的命令中取出最新的一条，执行撤销操作
- MKDIR删除创建的目录，因此这条命令也得记录被创建的文件夹
- RM把去掉的连接再加上，因此这条命令要记录被删除的文件夹
- CD：将now指针重新设置为之前保存的指针
心得
- 查多改少用缓存
- 遍历比较复杂
面向对象nb！
B - 东东学打牌
题目
最近，东东沉迷于打牌。所以他找到 HRZ、ZJM 等人和他一起打牌。由于人数众多，
东东稍微修改了亿下游戏规则：
所有扑克牌只按数字来算大小，忽略花色。
每张扑克牌的大小由一个值表示。A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K 分别指代 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13。如果存数字还好说，这字母代替数字直接提高了编码量
每个玩家抽得 5 张扑克牌，组成一手牌！（每种扑克牌的张数是无限的，你不用担心，东东家里有无数副扑克牌）
理所当然地，一手牌是有不同类型，并且有大小之分的。
举个栗子，现在东东的 “一手牌”（记为 α），瑞神的 “一手牌”（记为 β），要么 α > β，要么 α < β，要么 α = β。
那么这两个 “一手牌”，如何进行比较大小比较大小这里又可以搞一个重载呢？首先对于不同类型的一手牌，其值的大小即下面的标号；对于同类型的一手牌，根据组成这手牌的 5 张牌不同，其值不同。下面依次列举了这手牌的形成规则：
大牌：这手牌不符合下面任一个形成规则。如果 α 和 β 都是大牌，那么定义它们的大小为组成这手牌的 5 张牌的大小总和。和上次一样，所有条件都不符合则又有一套规则
对子：5 张牌中有 2 张牌的值相等。如果 α 和 β 都是对子，比较这个 “对子” 的大小，如果 α 和 β 的 “对子” 大小相等，那么比较剩下 3 张牌的总和。
两对：5 张牌中有两个不同的对子。如果 α 和 β 都是两对，先比较双方较大的那个对子，如果相等，再比较双方较小的那个对子，如果还相等，只能比较 5 张牌中的最后那张牌组不成对子的牌。
三个：5 张牌中有 3 张牌的值相等。如果 α 和 β 都是 “三个”，比较这个 “三个” 的大小，如果 α 和 β 的 “三个” 大小相等，那么比较剩下 2 张牌的总和。
三带二：5 张牌中有 3 张牌的值相等，另外 2 张牌值也相等。如果 α 和 β 都是 “三带二”，先比较它们的 “三个” 的大小，如果相等，再比较 “对子” 的大小。
炸弹：5 张牌中有 4 张牌的值相等。如果 α 和 β 都是 “炸弹”，比较 “炸弹” 的大小，如果相等，比较剩下那张牌的大小。
顺子：5 张牌中形成 x, x+1, x+2, x+3, x+4。如果 α 和 β 都是 “顺子”，直接比较两个顺子的最大值。
龙顺：5 张牌分别为 10、J、Q、K、A。
作为一个称职的魔法师，东东得知了全场人手里 5 张牌的情况。他现在要输出一个排行榜。排行榜按照选手们的 “一手牌” 大小进行排序，如果两个选手的牌相等，那么人名字典序小的排在前面。
不料，此时一束宇宙射线扫过，为了躲避宇宙射线，东东慌乱中清空了他脑中的 Cache。请你告诉东东，全场人的排名
输入
输入包含多组数据。每组输入开头一个整数 n (1 <= n <= 1e5)，表明全场共多少人。
随后是 n 行，每行一个字符串 s1 和 s2 （1 <= |s1|,|s2| <= 10）， s1 是对应人的名字，s2 是他手里的牌情况。
输出
对于每组测试数据，输出 n 行，即这次全场人的排名。
样例输入
注意处理10这个特殊输入
3
DongDong AAA109
ZJM 678910
Hrz 678910
样例输出
Hrz
ZJM
DongDong
思路
这道题跟上次那一道判断牌型的题目差不多，只是逻辑更加复杂了。
- 首先根据牌型要求对每个结构体进行分值计算
- 然后重载运算符进行排序
心得
- 用
这种格式来进行题目注释是个不错的阅读方法。 - 使用制定数值的枚举类型代表牌型，优化代码编写。
- 字母序函数我尝试用strcmp，但不可行，测试好几波也没有测出原因来。
代码
#include <bits/stdc++.h>
using namespace std;
int tmp[15];
enum cardtype {
WU = 0,
DA_PAI = 1,
DUI_ZI = 2,
LIANG_DUI = 3,
SAN_GE = 4,
SAN_DAI_ER = 5,
ZHA_DAN = 6,
SHUN_ZI = 7,
LONG_SHUN = 8,
};
struct card {
bool _zidian(const char* a1, const char* a2) const {
int l1 = strlen(a1);
int l2 = strlen(a2);
for (int j = 0; j < min(l1, l2); j++) {
if (a1[j] == a2[j])
continue;
if (a1[j] < a2[j])
return true;
if (a1[j] > a2[j])
return false;
}
if (l1 < l2)
return true;
return false;
}
char name[11];
char s[11];
int type;
int score;
int two[3];
int three[3];
int four[3];
bool operator<(const card p) const {
if (type != p.type)
return type > p.type;
else if (type == p.type) {
if (type == DA_PAI) {
if (score != p.score)
return score > p.score;
} else if (type == DUI_ZI) {
if (two[1] != p.two[1])
return two[1] > p.two[1];
else if (score != p.score)
return score > p.score;
} else if (type == LIANG_DUI) {
if (two[1] != p.two[1])
return two[1] > p.two[1];
else if (two[2] != p.two[2])
return two[2] > p.two[2];
else if (score != p.score)
return score > p.score;
} else if (type == SAN_GE || type == SAN_DAI_ER) {
if (three[1] != p.three[1])
return three[1] > p.three[1];
else if (score != p.score)
return score > p.score;
} else if (type == ZHA_DAN) {
if (four[1] != p.four[1])
return four[1] > p.four[1];
else if (score != p.score)
return score > p.score;
} else if (type == SHUN_ZI) {
if (score != p.score)
return score > p.score;
}
}
return _zidian(this->name, p.name);
}
} cards[100000 + 10];
void cal(int x) {
int i = 0;
memset(tmp, 0, sizeof(tmp));
while (i < strlen(cards[x].s)) {
if (cards[x].s[i] == '1') {
tmp[10]++;
i++;
} else {
if (cards[x].s[i] >= '2' && cards[x].s[i] <= '9')
tmp[cards[x].s[i] - '0']++;
else {
if (cards[x].s[i] == 'A')
tmp[1]++;
if (cards[x].s[i] == 'J')
tmp[11]++;
if (cards[x].s[i] == 'Q')
tmp[12]++;
if (cards[x].s[i] == 'K')
tmp[13]++;
}
}
i++;
}
if (tmp[1] && tmp[10] && tmp[11] && tmp[12] && tmp[13]) {
cards[x].type = LONG_SHUN;
return;
}
for (int i = 1; i <= 13; i++)
if (tmp[i]) {
for (int j = 1; j <= tmp[i]; j++)
cards[x].score += i;
}
//从13向1循环，顺序不能反 ,保证two[1]中存的一定是最大的
for (int i = 13; i >= 1; i--) {
if (tmp[i] == 4) {
cards[x].four[0] = 1;
cards[x].four[1] = i;
cards[x].type = ZHA_DAN;
return;
}
if (tmp[i] == 3) {
cards[x].three[0] = 1;
cards[x].three[1] = i;
}
if (tmp[i] == 2) {
cards[x].two[0]++;
if (cards[x].two[0] == 1)
cards[x].two[1] = i;
else {
cards[x].two[2] = i;
cards[x].type = LIANG_DUI;
return;
}
}
}
for (int i = 1; i <= 9; i++)
if (tmp[i] && tmp[i + 1] && tmp[i + 2] && tmp[i + 3] && tmp[i + 4]) {
cards[x].type = SHUN_ZI;
return;
}
if (cards[x].two[0] == 1 && cards[x].three[0] == 1) {
cards[x].type = 5;
return;
}
if (cards[x].two[0] == 1) {
cards[x].type = DUI_ZI;
return;
}
if (cards[x].three[0] == 1) {
cards[x].type = SAN_GE;
return;
}
cards[x].type = DA_PAI;
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) {
memset(cards[i].two, 0, sizeof(cards[i].two));
memset(cards[i].three, 0, sizeof(cards[i].three));
memset(cards[i].four, 0, sizeof(cards[i].four));
cards[i].type = WU;
cards[i].score = 0;
cin >> cards[i].name >> cards[i].s;
cal(i);
}
sort(cards + 1, cards + n + 1);
for (int i = 1; i <= n; i++)
cout << cards[i].name << endl;
}
return 0;
}
C - 签到题
题目
SDUQD 旁边的滨海公园有 x 条长凳。第 i 个长凳上坐着 a_i 个人。这时候又有 y 个人将来到公园，他们将选择坐在某些公园中的长凳上，那么当这 y 个人坐下后，记k = 所有椅子上的人数的最大值，那么k可能的最大值mx和最小值mn分别是多少。
Input
第一行包含一个整数 x (1 <= x <= 100) 表示公园中长椅的数目
第二行包含一个整数 y (1 <= y <= 1000) 表示有 y 个人来到公园
接下来 x 个整数 a_i (1<=a_i<=100)，表示初始时公园长椅上坐着的人数
Output
输出 mn 和 mx
Input Example
3
7
1
6
1
Output Example
6 13
样例解释
最初三张椅子的人数分别为 1 6 1
接下来来了7个人。
可能出现的情况为{1 6 8},{1,7,7},…,{8,6,1}
相对应的k分别为8,7,…,8
其中，状态{1,13,1}的k = 13，为mx
状态{4,6,5}和状态{5,6,4}的k = 6，为mn
思路
这还是一道数学结论的题目，不需要进行复杂的计算。
最大值：新到的人坐到原最多人坐的椅子上，mx=max(ai)+y 这个比较好想出来
最小值：新到的人尽量地坐到当前人数最少的椅子上，mn=向上取整(sum(ai)+y/x) 这个有点难度
心得
一开始求和没加括号…，烦了语法错误不应该。
代码
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
scanf("%d %d", &x, &y);
int max_people = 0;
int min_people = INT_MIN;
int total = 0;
for (int i = 0; i < x; i++) {
int a;
scanf("%d", &a);
total += a;
if (max_people < a) {
max_people = a;
}
}
//对于最小人数，首先假设所有人全部重新排座
//则最后平均值与原来最大值中的最大值是新的最大值
auto getMAX = [&]() -> int {
int mn = (total + y) / x;
if ((total + y) % x)
mn++;
return max(mn, max_people); //向最大人数取整
};
cout << getMAX() << " " << max_people + y << endl;
}
8890
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
