A - 咕咕东的目录管理器
Input
输入文件包含多组测试数据，第一行输入一个整数表示测试数据的组数 T （T <= 20）；
每组测试数据的第一行输入一个整数表示该组测试数据的命令总数 Q （Q <= 1e5）；
每组测试数据的 2 ~ Q+1 行为具体的操作 （MKDIR、RM 操作总数不超过 5000）；
Output
每组测试数据的输出结果间需要输出一行空行。注意大小写敏感。
Example Input
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
Example Output
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
题意：
实现一个简单的目录管理器，有创建、删除、排序、输出、撤销等操作。
分析：
如果没有课上的思路，估计很难独立完成。
本题需要注意的是使用怎样的数据结构去保存每个节点和数据的范围。
可以使用结构体：
struct Directory
{
string name;
map<string, int>mp;
int father, son;
vector<string> pre, bck;
bool flag;
};
来保存每个节点，分别表示名称、后代的名称和编号、父节点和子树的规模、前序遍历的前几个和后几个、是否被更新过。
然后按照课件的思路，逐步实现几个函数。需要注意的是有个撤销操作，所以前面的创建和删除时不能太彻底，比如删除时，只需要删除边的关系就可以了，再进行撤销时可以恢复边的关系，注意撤销的是上一步的成功操作，而不是上一步的操作。
代码如下：
#include<iostream>
#include<string>
#include<string.h>
#include<map>
#include<vector>
using namespace std;
struct Directory
{
string name;
map<string, int>mp;
int father, son;
vector<string> pre, bck;
bool flag;
};
Directory node[200000];
int now, ind;
struct point
{
string name;
int now;
int next;
};
vector<point> v;
void update(int id, int num)
{
while (id != -1)
{
node[id].flag = 0;
node[id].son += num;
id = node[id].father;
}
}
void MKDIR(string& s)
{
if (node[now].mp.count(s) == 1)
cout << "ERR" << endl;
else
{
node[now].mp.insert(pair<string, int>(s, ind));
update(now, 1);
node[ind].name = s;
node[ind].father = now;
node[ind].son = 1;
node[ind].flag = 0;
node[ind].mp.clear();
node[ind].pre.clear();
node[ind].bck.clear();
point p;
p.name = "MKDIR", p.now = now, p.next = ind;
v.push_back(p);
ind++;
cout << "OK" << endl;
}
}
void RM(string& s)
{
if (node[now].mp.count(s) == 1)
{
int indexOfS = node[now].mp[s];
node[now].mp.erase(s);
update(now, (-1) * node[indexOfS].son);
point p;
p.name = "RM", p.now = now, p.next = indexOfS;
v.push_back(p);
cout << "OK" << endl;
}
else cout << "ERR" << endl;
}
void CD(string& s)
{
if (s == "..")
{
if (node[now].father == -1)
cout << "ERR" << endl;
else
{
point p;
p.name = "CD", p.now = now, p.next = node[now].father;
v.push_back(p);
now = node[now].father;
cout << "OK" << endl;
}
}
else
{
if (node[now].mp.count(s) == 1)
{
point p;
p.name = "CD", p.now = now, p.next = node[now].mp[s];
v.push_back(p);
now = node[now].mp[s];
cout << "OK" << endl;
}
else cout << "ERR" << endl;
}
}
void SZ()
{
cout << node[now].son << endl;
}
void LS()
{
if (node[now].mp.size() == 0)
cout << "EMPTY" << endl;
else if (node[now].mp.size() >= 1 && node[now].mp.size() <= 10)
{
for (map<string, int>::iterator it = node[now].mp.begin(); it != node[now].mp.end(); it++)
cout << it->first << endl;
}
else
{
map<string, int>::iterator it = node[now].mp.begin();
for (int i = 1; i <= 5; i++)
{
cout << it->first << endl;
it++;
}
cout << "..." << endl;
it = node[now].mp.end();
for (int i = 1; i <= 5; i++)
it--;
for (int i = 1; i <= 5; i++)
{
cout << it->first << endl;
it++;
}
}
}
void alltrack(int id, vector<string>& pre)
{
pre.push_back(node[id].name);
for (map<string, int>::iterator it = node[id].mp.begin(); it != node[id].mp.end(); it++)
alltrack(it->second, pre);
}
void pretrack(int id, vector<string>& pre, int& num)
{
pre.push_back(node[id].name);
num--;
if (num == 0) return;
for (map<string, int>::iterator it = node[id].mp.begin(); it != node[id].mp.end(); it++)
{
pretrack(it->second, pre, num);
if (num == 0) break;
}
}
void bcktrack(int id, vector<string>& bck, int& num)
{
map<string, int>::iterator it = node[id].mp.end();
int n = node[id].mp.size();
for (int i = 0; i < n; i++)
{
it--;
bcktrack(it->second, bck, num);
if (num == 0) return;
}
bck.push_back(node[id].name);
num--;
}
void pushdown(int id)
{
node[id].pre.clear();
node[id].bck.clear();
if (node[id].son <= 10)
alltrack(id, node[id].pre);
else
{
int num = 5;
pretrack(id, node[id].pre, num);
num = 5;
bcktrack(id, node[id].bck, num);
}
node[id].flag = 1;
}
void TREE()
{
if (!node[now].flag)
pushdown(now);
if (node[now].son == 1)
cout << "EMPTY" << endl;
else if (node[now].son > 1 && node[now].son <= 10)
{
for (int i = 0; i < node[now].pre.size(); i++)
cout << node[now].pre[i] << endl;
}
else
{
for (int i = 0; i < 5; i++)
cout << node[now].pre[i] << endl;
cout << "..." << endl;
for (int i = 4; i >= 0; i--)
cout << node[now].bck[i] << endl;
}
}
void UNDO()
{
if (v.size() == 0)
cout << "ERR" << endl;
else
{
point p = v[v.size() - 1];
v.pop_back();
cout << "OK" << endl;
if (p.name == "MKDIR")
{
update(p.now, (-1) * node[p.next].son);
node[p.now].mp.erase(node[p.next].name);
}
else if (p.name == "RM")
{
update(p.now, node[p.next].son);
node[p.now].mp[node[p.next].name] = p.next;
}
else
now = p.now;
}
}
int main()
{
int T, Q;
string s1, s2;
cin >> T;
while (T--)
{
cin >> Q;
now = 0, ind = 1;
node[0].name = "root", node[0].father = -1, node[0].son = 1, node[0].flag = 0;
node[0].pre.clear(), node[0].bck.clear(), node[0].mp.clear();
v.clear();
while (Q--)
{
cin >> s1;
if (s1 == "MKDIR")
{
cin >> s2;
MKDIR(s2);
}
else if (s1 == "RM")
{
cin >> s2;
RM(s2);
}
else if (s1 == "CD")
{
cin >> s2;
CD(s2);
}
else if (s1 == "SZ")
SZ();
else if (s1 == "LS")
LS();
else if (s1 == "TREE")
TREE();
else if (s1 == "UNDO")
UNDO();
}
cout << endl;
}
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 张牌不同，其值不同。下面依次列举了这手牌的形成规则：
1.大牌：这手牌不符合下面任一个形成规则。如果 α 和 β 都是大牌，那么定义它们的大小为组成这手牌的 5 张牌的大小总和。
2.对子：5 张牌中有 2 张牌的值相等。如果 α 和 β 都是对子，比较这个 “对子” 的大小，如果 α 和 β 的 “对子” 大小相等，那么比较剩下 3 张牌的总和。
3.两对：5 张牌中有两个不同的对子。如果 α 和 β 都是两对，先比较双方较大的那个对子，如果相等，再比较双方较小的那个对子，如果还相等，只能比较 5 张牌中的最后那张牌组不成对子的牌。
4.三个：5 张牌中有 3 张牌的值相等。如果 α 和 β 都是 “三个”，比较这个 “三个” 的大小，如果 α 和 β 的 “三个” 大小相等，那么比较剩下 2 张牌的总和。
5.三带二：5 张牌中有 3 张牌的值相等，另外 2 张牌值也相等。如果 α 和 β 都是 “三带二”，先比较它们的 “三个” 的大小，如果相等，再比较 “对子” 的大小。
6.炸弹：5 张牌中有 4 张牌的值相等。如果 α 和 β 都是 “炸弹”，比较 “炸弹” 的大小，如果相等，比较剩下那张牌的大小。
7.顺子：5 张牌中形成 x, x+1, x+2, x+3, x+4。如果 α 和 β 都是 “顺子”，直接比较两个顺子的最大值。
8.龙顺：5 张牌分别为 10、J、Q、K、A。
作为一个称职的魔法师，东东得知了全场人手里 5 张牌的情况。他现在要输出一个排行榜。排行榜按照选手们的 “一手牌” 大小进行排序，如果两个选手的牌相等，那么人名字典序小的排在前面。
不料，此时一束宇宙射线扫过，为了躲避宇宙射线，东东慌乱中清空了他脑中的 Cache。请你告诉东东，全场人的排名
Input
输入包含多组数据。每组输入开头一个整数 n (1 <= n <= 1e5)，表明全场共多少人。
随后是 n 行，每行一个字符串 s1 和 s2 （1 <= |s1|,|s2| <= 10）， s1 是对应人的名字，s2 是他手里的牌情况。
Output
对于每组测试数据，输出 n 行，即这次全场人的排名。
Example Input
3
DongDong AAA109
ZJM 678910
Hrz 678910
Example Output
Hrz
ZJM
DongDong
题意：
每个人有一手牌，扑克牌的大小有一定的规则，输出这些人中按照牌的大小排序的结果，如果两个人的牌大小相同，按照名称的字典序输出。
分析：
本题可以看做是一个多关键字排序问题，可以使用结构体：
struct people
{
string name;
int level;
int mark;
}p[100010];
来保存每个人的信息，包括名字，牌的类型，在某个类型中牌的大小。
再利用排序函数：
int cmp(people p1, people p2)
{
if (p1.level == p2.level && p1.mark == p2.mark)
return p1.name < p2.name;
else
{
if (p1.level == p2.level)
return p1.mark > p2.mark;
else
return p1.level > p2.level;
}
}
进行排序即可。
这里最主要的是如何计算出level和mark，依然使用上次模拟题的方法判断出牌的类型，这里需要注意的是多了“龙顺”这一种情况，并且“A2345”也是顺子，当牌属于同一类型是，使用int型数据mark来给出一个加权的数字，代表了这个牌的大小。
代码如下：
#include<iostream>
#include<algorithm>
#include<string>
#include<string.h>
using namespace std;
struct people
{
string name;
int level;
int mark;
}p[100010];
void change(string s, int* Level, int* Mark)
{
int hm[5];
bool dapai = true;
int m = -1;
for (int i = 0; i < s.size(); i++)
{
if (s[i] == '1')
hm[++m] = 10;
else if (s[i] == '0')
continue;
else if (s[i] == 'A')
hm[++m] = 1;
else if (s[i] == 'J')
hm[++m] = 11;
else if (s[i] == 'Q')
hm[++m] = 12;
else if (s[i] == 'K')
hm[++m] = 13;
else if(s[i] >= '2' && s[i] <= '9')
hm[++m] = s[i] - '0';
}
sort(hm, hm + 5);
bool shunzi = true;
for (int i = 1; i < 5; i++)
{
if (hm[i] - hm[i - 1] != 1)
shunzi = false;
}
if (shunzi)
{
*Level = 7;
*Mark = hm[4];
dapai = false;
}
if (hm[0] == 1 && hm[1] == 10 && hm[2] == 11 && hm[3] == 12 && hm[4] == 13)
{
*Level = 8;
*Mark = 0;
dapai = false;
}
int num[5] = { 0 };
num[0]++;
int j = 0;
int temp = hm[0];
for (int i = 1; i < 5; i++)
{
if (hm[i] == temp)
num[j]++;
else
{
temp = hm[i];
j++;
num[j]++;
}
}
sort(num, num + 5);
if (num[4] == 4)
{
*Level = 6;
if (hm[0] == hm[1])
*Mark = hm[0] * 100 + hm[4];
else
*Mark = hm[4] * 100 + hm[0];
dapai = false;
}
else if (num[4] == 3 && num[3] == 2)
{
*Level = 5;
if (hm[1] == hm[2])
*Mark = hm[2] * 100 + hm[3];
else
*Mark = hm[2] * 100 + hm[1];
dapai = false;
}
else if (num[4] == 3 && num[3] == 1)
{
*Level = 4;
if (hm[0] == hm[1] && hm[1] == hm[2])
*Mark = hm[2] * 100 + hm[3] + hm[4];
else if (hm[1] == hm[2] && hm[2] == hm[3])
*Mark = hm[2] * 100 + hm[0] + hm[4];
else if (hm[2] == hm[3] && hm[3] == hm[4])
*Mark = hm[2] * 100 + hm[0] + hm[1];
dapai = false;
}
else if (num[4] == 2 && num[3] == 2)
{
*Level = 3;
if (hm[1] == hm[2] && hm[3] == hm[4])
*Mark = hm[3] * 10000 + hm[1] * 100 + hm[0];
else if (hm[0] == hm[1] && hm[3] == hm[4])
*Mark = hm[3] * 10000 + hm[1] * 100 + hm[2];
else if (hm[0] == hm[1] && hm[2] == hm[3])
*Mark = hm[3] * 10000 + hm[1] * 100 + hm[4];
dapai = false;
}
else if (num[4] == 2 && num[3] == 1)
{
*Level = 2;
if (hm[0] == hm[1])
*Mark = hm[1] * 100 + hm[2] + hm[3] + hm[4];
else if (hm[1] == hm[2])
*Mark = hm[2] * 100 + hm[0] + hm[3] + hm[4];
else if (hm[2] == hm[3])
*Mark = hm[3] * 100 + hm[0] + hm[1] + hm[4];
else if (hm[3] == hm[4])
*Mark = hm[4] * 100 + hm[0] + hm[1] + hm[2];
dapai = false;
}
int sum = 0;
if (dapai)
{
*Level = 1;
for (int i = 0; i < 5; i++)
sum += hm[i];
*Mark = sum;
}
return;
}
int cmp(people p1, people p2)
{
if (p1.level == p2.level && p1.mark == p2.mark)
return p1.name < p2.name;
else
{
if (p1.level == p2.level)
return p1.mark > p2.mark;
else
return p1.level > p2.level;
}
}
int main()
{
int n;
string s1, s2;
while (cin >> n)
{
for (int i = 0; i < n; i++)
{
int Level = 0, Mark = 0;
cin >> s1 >> s2;
p[i].name = s1;
change(s2, &Level, &Mark);
p[i].level = Level;
p[i].mark = Mark;
}
sort(p, p + n, cmp);
for (int i = 0; i < n; i++)
cout << p[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
Example Input
3
7
1
6
1
Example Output
6 13
题意：
有一排椅子，每个椅子上坐着若干个人，又来了一拨人，他们每个人可能坐在任何一个椅子上，计算出这一拨人坐下以后，人数最多的椅子的可能最大值和最小值。
分析：
本题看上去很简单，但特别容易出错，一不小心就爆零了，只能说以后做简单题要特别注意。
代码如下：
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
int a[110];
int main()
{
int x, y, mn, mx;
cin >> x >> y;
int num = y;
for (int i = 0; i < x; i++)
{
cin >> a[i];
num += a[i];
}
sort(a, a + x);
mx = a[x - 1] + y;
mn = a[x - 1];
if (a[x - 1] * x < num)
{
if (num % x == 0)
mn = num / x;
else
mn = num / x + 1;
}
cout << mn << " " << mx;
return 0;
}
