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）；
面对数据范围你要思考的是他们代表的 “命令” 执行的最大可接受复杂度，只有这样你才能知道你需要设计的是怎样复杂度的系统。
输出
每组测试数据的输出结果间需要输出一行空行。注意大小写敏感。
思路：
本题主要难点我认为有以下几点：1、确定存储形式。2、撤回操作。3、TREE操作。
首先是目录的存储形式，这里采用的不是一般的多叉树结构，而是利用map容器构造了一个文字对应相应指针的结构来存储目录。能够看到，新结构要比传统多叉树灵活的多，更能担任这一题中的存储结构。然后是撤回操作，撤回操作需要在程序开始编写以前就想好这一操作如何实现，否则很有很可能出现某些功能实现以后发现无法撤回而需要回炉重做的尴尬现象。这里我们采取一个链表来存储执行过的插入、移动、删除等可回溯指令，撤回时只需要根据上一操作的对应类型进行对应处理即可。TREE操作则是涉及到一个时间的问题，若后代节点大于10个，则需要进行前序后序的遍历，根据数据范围，这样的复杂度我们显然是无法接受的。因此这里我们应该采用懒更新，即缓存。这样一来时间的问题就得以解决了。
代码：
#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <map>
using namespace std;
struct Directory
{
string name;
map<string ,Directory*> children;
Directory* parent;
int subtreeSize;
vector<string>* tenDescendants;
bool updated;
Directory(string name,Directory* parent){
this->name=name;
this->parent=parent;
this->subtreeSize=1;
updated=false;
tenDescendants=new vector<string>;
}
public:
Directory* getChild(string &sname){
auto it =children.find(sname);
if(it==children.end())
return nullptr;
return it->second;
}
Directory* mkdir(string &sname){
if(children.find(sname) != children.end())
return nullptr;
Directory* ch=new Directory(sname,this);
children[sname]=ch;
maintain(1);
return ch;
}
Directory* rm(string &sname){
auto it=children.find(sname);
if(it==children.end())
return nullptr;
maintain(-1*(it->second->subtreeSize));
children.erase(it);
return it->second;
}
Directory* cd(string &sname){
if(".."==sname)
return this->parent;
return getChild(sname);
}
bool addChild(Directory* ch)
{
if(children.find(ch->name)!=children.end())
return false;
children[ch->name]=ch;
maintain(ch->subtreeSize);
return true;
}
void maintain(int delta)
{
updated=true;
subtreeSize+=delta;
if(parent!=nullptr)
parent->maintain(delta);
}
void sz()
{
printf("%d\n",this->subtreeSize);
}
void ls()
{
int sz=children.size();
if(sz==0) printf("EMPTY\n");
else if(sz<=10){
for (auto &entry : children)
printf("%s\n",entry.first.c_str());
}
else {
auto it=children.begin();
for (int i=0; i<5; i++,it++) printf("%s\n",it->first.c_str());
printf("...\n");
it=children.end();
for (int i=0; i<5; i++) it--;
for (int i=0; i<5; i++,it++) printf("%s\n",it->first.c_str());
}
}
void tree(){
if(subtreeSize==1) printf("EMPTY\n");
else if(subtreeSize<=10){
if(this->updated){
tenDescendants->clear();
treeAll(tenDescendants);
this->updated=false;
}
for (int i=0; i<subtreeSize; i++) printf("%s\n",tenDescendants->at(i).c_str());
}
else {
if(this->updated){
tenDescendants->clear();
treeFirstSome(5,tenDescendants);
treeLastSome(5,tenDescendants);
this->updated=false;
}
for (int i=0; i<5; i++) printf("%s\n",tenDescendants->at(i).c_str());
printf("...\n");
for (int i=9; i>=5; i--) printf("%s\n",tenDescendants->at(i).c_str());
}
}
private:
void treeAll(vector<string>* bar) {
bar->push_back(name);
for (auto &entry: children)
entry.second->treeAll(bar);
}
void treeFirstSome(int num,vector<string>* bar) {
bar->push_back(name);
if(--num==0) return;
int n=children.size();
auto it=children.begin();
while(n--){
int sts=it->second->subtreeSize;
if(sts>=num){
it->second->treeFirstSome(num,bar);
return;
}
else {
it->second->treeFirstSome(sts,bar);
num-=sts;
}
it++;
}
}
void treeLastSome(int num,vector<string>* bar) {
int n=children.size();
auto it=children.end();
while(n--){
it--;
int sts=it->second->subtreeSize;
if(sts>=num){
it->second->treeLastSome(num,bar);
return;
}
else {
it->second->treeLastSome(sts,bar);
num-=sts;
}
}
bar->push_back(name);
}
};
struct Command
{
const string CMDNAMES[7]={"MKDIR","RM","CD","SZ","LS","TREE","UNDO"};
int type;
string arg;
Directory* tmpDir;
Command(string &s)
{
tmpDir=nullptr;
for (int i=0; i<7; i++)
if(CMDNAMES[i]==s)
{
char tmp[40]={0};
type=i;
if(i<3)
{
scanf("%s",tmp);
arg=tmp;
}
return;
}
}
};
void solve()
{
int n=0;scanf("%d",&n);
Directory* now=new Directory("root",nullptr);
vector<Command*> cmdList;
while(n--){
char tmp[40]={0};
scanf("%s",tmp);
string s=tmp;
Command* cmd=new Command(s);
switch(cmd->type){
case 0: case 1:{
cmd->tmpDir=cmd->type==0 ? now->mkdir(cmd->arg) : now->rm(cmd->arg);
if(cmd->tmpDir==nullptr) printf("ERR\n");
else {
printf("OK\n");
cmdList.push_back(cmd);
}
break;
}
case 2:{
Directory* ch=now->cd(cmd->arg);
if(ch==nullptr) printf("ERR\n");
else {
printf("OK\n");
cmd->tmpDir=now;
now=ch;
cmdList.push_back(cmd);
}
break;
}
case 3: now->sz(); break;
case 4: now->ls(); break;
case 5: now->tree(); break;
case 6:{
bool success=false;
while(!success && !cmdList.empty()){
cmd=cmdList.back(); cmdList.pop_back();
switch(cmd->type){
case 0: success=now->rm(cmd->arg)!=nullptr; break;
case 1: success=now->addChild(cmd->tmpDir); break;
case 2: now=cmd->tmpDir; success=true; break;
}
}
printf(success ? "OK\n" : "ERR\n");
}
}
}
}
int main()
{
int T; scanf("%d",&T);
for (int i=0; i<T; i++) {
solve();
if(i!=T) printf("\n");
}
return 0;
}
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 行，即这次全场人的排名。
思路：
该题我感觉主要在考验代码能力，因为题目本身思路不算难，无非就是将牌输入，判断其情况。但是判断方法好坏及对错就是要看代码的功底了。我这里是对每一手牌都做了转换以后再进行比较，转换成自定义的容易比较的类型。
代码：
#include <stdio.h>
#include <iostream>
#include <string>
#include <string.h>
#include <algorithm>
using namespace std;
string name[100000+20];
char card[100000+20][10];
struct same
{
int sz;
char num;
same()
{
sz=0;
num=0;
}
};
struct value
{
int index;
int num;
int sum1;
int sum2;
int sum3;
value()
{
index=0;
num=0;
sum1=0;
sum2=0;
sum3=0;
}
bool operator <(const value &v)
{
if(v.num!=num)
return num<v.num;
else
if(sum1!=v.sum1)
return sum1<v.sum1;
else
if(sum2!=v.sum2)
return sum2<v.sum2;
else
if(sum3!=v.sum3)
return sum3<v.sum3;
else
return name[index]>name[v.index];
}
};
value v[100000+20];
void init()
{
for(int i=0;i<100000+20;i++)
{
name[i].clear();
v[i].index=i;
}
memset(card,0,sizeof(card));
}
void solve(int n)
{
for(int i=1;i<=n;i++)
{
sort(card[i],card[i]+5);
same s[7];
int k=0;
int needle=0;
for(int j=0;j<4;j++)
{
if(card[i][j]!=card[i][j+1])
{
s[needle].sz=j-k+1;
s[needle].num=card[i][j];
k=j+1;
needle++;
}
}
s[needle].num=card[i][4];
s[needle].sz=4-k+1;
needle++;
switch(needle)
{
case 2:
{
if(s[0].sz==1||s[0].sz==4)
{
v[i].num=6;
if(s[0].sz==1)
{
v[i].sum2=s[0].num;
v[i].sum1=s[1].num;
}
else
{
v[i].sum1=s[0].num;
v[i].sum2=s[1].num;
}
}
else
{
v[i].num=5;
if(s[0].sz==2)
{
v[i].sum2=s[0].num;
v[i].sum1=s[1].num;
}
else
{
v[i].sum1=s[0].num;
v[i].sum2=s[1].num;
}
}
break;
}
case 3:
{
if(s[0].sz==2||s[1].sz==2)
{
int judge=0;
v[i].num=3;
for(int c=0;c<3;c++)
if(s[c].sz==2&&judge==0)
{
v[i].sum1=s[c].num;
judge=1;
}
else
if(s[c].sz==2)
v[i].sum2=s[c].num;
else
v[i].sum3=s[c].num;
if(v[i].sum1<v[i].sum2)
{
int tmp;
tmp=v[i].sum1;v[i].sum1=v[i].sum2;v[i].sum2=tmp;
}
}
else
{
v[i].num=4;
for(int c=0;c<3;c++)
{
if(s[c].sz==3)
v[i].sum1=s[c].num;
else
if(s[c].num>57)
v[i].sum2+=s[c].num-55;
else
v[i].sum2+=s[c].num-48;
}
}
break;
}
case 4:
{
v[i].num=2;
for(int c=0;c<4;c++)
{
if(s[c].sz==2)
v[i].sum1=s[c].num;
else
if(s[c].num>57)
v[i].sum2+=s[c].num-55;
else
v[i].sum2+=s[c].num-48;
}
break;
}
case 5:
{
string t=card[i];
if(t=="1ABCD")
v[i].num=8;
else
{
int tmp[10];
for(int c=0;c<5;c++)
{
if(s[c].num>57)
tmp[c]=s[c].num-55;
else
tmp[c]=s[c].num-48;
}
if(tmp[4]-tmp[0]==4)
{
v[i].num=7;
v[i].sum1=tmp[4];
}
else
{
v[i].num=1;
v[i].sum1=tmp[0]+tmp[1]+tmp[2]+tmp[3]+tmp[4];
}
}
break;
}
};
}
}
int main()
{
int n;
while(cin>>n)
{
init();
for(int i=1;i<=n;i++)
{
cin>>name[i];
char tmp[12]={0};
cin>>tmp;
int k=0;
for(int j=0;tmp[j]!=0;j++)
{
if(tmp[j]=='1'||tmp[j]=='A'||tmp[j]=='J'||tmp[j]=='Q'||tmp[j]=='K')
{
if(tmp[j]=='1')
{
card[i][k]='A';
j++;
}
if(tmp[j]=='A')
card[i][k]='1';
if(tmp[j]=='J')
card[i][k]='B';
if(tmp[j]=='Q')
card[i][k]='C';
if(tmp[j]=='K')
card[i][k]='D';
}
else
{
card[i][k]=tmp[j];
}
k++;
}
}
solve(n);
sort(v+1,v+n+1);
for(int i=n;i>=1;i--)
{
cout<<name[v[i].index]<<"\n";
}
}
}
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
思路：
该题就如题目所言签到题。最大的情况为新来的人都到坐着最多人的椅子上坐，最小的情况为新来的人尽可能的平均地坐在所有椅子上。
代码：
#include <iostream>
using namespace std;
int bench[200];
int main()
{
int x,y;
cin>>x>>y;
int maxb=0;
for(int i=1;i<=x;i++)
{
cin>>bench[i];
if(bench[i]>maxb)
maxb=bench[i];
}
int sum=0;
for(int i=1;i<=x;i++)
{
sum=sum+maxb-bench[i];
}
if(y<=sum)
printf("%d ",maxb);
else
{
if(x==1)
printf("%d ",maxb+y);
else
printf("%d ",maxb+(y-sum-1)/x+1);
}
printf("%d",maxb+y);
}
1148
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
