程序设计思维与实践 Week9 作业 (3/4/数据班)

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上，TREE要求我们要用合适的技巧将时间复杂度控制在一定范围内而UNDO要求我们要实现对之前操作的一个复原，TREE可以采用缓存这样的形式：若当前的节点的子节点未更新则其TREE也不会更新。UNDO通过创建结构体来储存对应的操作以及操作的节点来实现。

#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
 struct Directory{
 	string name;
 	map<string,Directory*> kids;
 	Directory* par;
 	int siz;
 	bool updated;
 	vector<string> *tens;
 	Directory(string name,Directory *par){
 		tens=new vector<string>();
 		this->name=name;
 		this->par=par;
 		this->siz=1;
 		this->updated=false;
	 }
public:
	 void mkdir(string name);
	 void rm(string name);
	 Directory* cd(string name);
	 void maintain(int delta);
	 Directory* getkid(string name);
	 void addkid(Directory* kid);
	 void sz();
	 void ls();
	 void tree();
	 void treeAll(vector<string>* bar){
	 	bar->push_back(name);
	 	for(auto &en:kids) en.second->treeAll(bar);
	 }
	 void treefirstsome(int num,vector<string>* bar){
	 	bar->push_back(name);
	 	if(--num==0) return;
	 	int n=kids.size();
	 	auto it=kids.begin();
	 	while(n--){
	 		int sts=it->second->siz;
	 		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=kids.size();
	 	auto it=kids.end();
	 	while(n--){
	 		 it--;
	 		int sts=it->second->siz;
	 		if(sts>=num){
	 			it->second->treelastsome(num,bar);
	 			return;
			 }
			 else{
			 	it->second->treelastsome(sts,bar);
			 	num-=sts;
			 }
		 }
		 bar->push_back(name);
	 }
 };
 struct command{
 	Directory* d;
 	string type;
 	command(Directory *d,string t){
 		this->d=d;
 		this->type=t;
	 }
 };
 int T,Q,vv=0;
 string nowcom,file;
 vector<command*> *comlist;
void Directory::maintain(int delta){
	updated=true;
	siz+=delta;
	if(par!=NULL) par->maintain(delta);
}
Directory* Directory::getkid(string name){
	auto it=kids.find(name);
	if(it==kids.end()){
		return NULL;
	}
	return it->second;
}
void Directory::addkid(Directory* kid){
	if(kids.find(kid->name)!=kids.end()){
		cout<<"ERR"<<endl;
		return;
	}
	kids[kid->name]=kid;
	maintain(kid->siz);
	cout<<"OK"<<endl;
}
void Directory::mkdir(string name){
 	if(kids.find(name)!=kids.end()){
 		cout<<"ERR"<<endl;
 		return;
	 }
	 Directory *kid=new Directory(name,this);
	 kids[name]=kid;
	 maintain(1);
	 comlist->push_back(new command(kid,"MKDIR"));
	 cout<<"OK"<<endl;
 }
 void Directory::rm(string name){
 	auto it=kids.find(name);
 	if(it==kids.end()){
 		cout<<"ERR"<<endl;
 		return;
	 }
	 maintain(-1*it->second->siz);
	 kids.erase(it);
	 if(vv==0){
	 	comlist->push_back(new command(it->second,"RM"));
	 }
	 vv=0;
	 cout<<"OK"<<endl;
 }
 Directory* Directory::cd(string name){
 	if(name==".."){
 		if(this->par==NULL){
 			cout<<"ERR"<<endl;
 			return NULL;
		 }
 		comlist->push_back(new command(this,"CD"));
 		cout<<"OK"<<endl;
 		return this->par;
	 } 
	 else{
	 	Directory* d=getkid(name);
	 	if(d==NULL){
	 		cout<<"ERR"<<endl;
 			return NULL;
		 }
	 	comlist->push_back(new command(this,"CD"));
	 	cout<<"OK"<<endl;
	 	return d;
	 }
	 
 }
 void Directory::sz(){
 	cout<<this->siz<<endl;
 }
 void Directory::ls(){
 	int num=kids.size();
 	if(num==0) cout<<"EMPTY"<<endl;
 	else if(num<=10) for(auto &v:kids) cout<<v.first.c_str()<<endl;
 	else{
 		auto it=kids.begin();
 		for(int k=0;k<5;k++,it++) cout<<it->first.c_str()<<endl;
		 cout<<"…"<<endl;
		 it=kids.end();
		 for(int k=0;k<5;k++) it--;
		 for(int k=0;k<5;k++) cout<<it->first.c_str()<<endl;
	 }
 }
 void Directory::tree(){
 	if(siz==1) cout<<"EMPTY"<<endl;
 	else if(siz<=10){
 		if(this->updated){
 			 tens->clear();
 			 treeAll(tens);
 			 updated=false;
		 }
		 for(int k=0;k<siz;k++) cout<<tens->at(k).c_str()<<endl;
	 }
	 else{
	 	if(updated){ 
	 		 tens->clear();
	 		 treefirstsome(5,tens);
	 		 treelastsome(5,tens);
	 		 updated=false;
		 }
		for(int k=0;k<5;k++) cout<<tens->at(k).c_str()<<endl;
		cout<<"…"<<endl;
		for(int k=9;k>=5;k--)  cout<<tens->at(k).c_str()<<endl;
	 }
 }
main(){
	cin>>T;
	for(int Z=1;Z<=T;Z++){
		cin>>Q;
		comlist=new vector<command*>();
		Directory* now=new Directory("root",NULL);
		for(int l=1;l<=Q;l++){
			cin>>nowcom;
			if(nowcom=="MKDIR"){
				cin>>file;
				now->mkdir(file);		
			}
			else if(nowcom=="RM"){
				cin>>file;
				vv=0;
				now->rm(file);	
			}
			else if(nowcom=="CD"){
				cin>>file;
				Directory* g=now->cd(file);	
				if(g==NULL) continue;
				now=g;
			}
			else if(nowcom=="SZ"){
				now->sz();	
			}
			else if(nowcom=="LS"){
				now->ls();
			}
			else if(nowcom=="TREE"){
				now->tree();	
			}
			else if(nowcom=="UNDO"){
				if(comlist->empty()){
					cout<<"ERR"<<endl;
				}
				else{
				command *k=comlist->back();
				comlist->pop_back();
				Directory *cmd=k->d;
				string t=k->type;
				if(t=="MKDIR"){
					vv=1;
					now->rm(cmd->name);
				}
				else if(t=="RM"){
					now->addkid(cmd);
				}
				else{
					
					now=cmd;
					cout<<"OK"<<endl;
				}	
				}
			}
		}
		cout<<endl; 
	}
	
	return 0;
} 

东东学打牌

题面
最近，东东沉迷于打牌。所以他找到 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 行，即这次全场人的排名。
样例输入
3
DongDong AAA109
ZJM 678910
Hrz 678910
样例输出
Hrz
ZJM
DongDong

思路：一道比较长的题。。。说一下大概思路：首先对于输入的人和他的牌我们要先将其分组，分组后放入vector leixing[]类型的容器中,每组代表持有某种类型牌的人，如leixing[2]中储存的是持有对子的牌的人的信息，分组完成后需要在组内再进行排序。之后从leixing[1]开始，依次输出每个容器中的每个元素即可。

#include <iostream>
#include <map>
#include <algorithm>
#include <string>
#include <vector>
using namespace std;
const int inf = 1e6;
string w[14] = { "x","A","2","3","4","5","6","7","8","9","1","J","Q","K" };
struct stu {
	string name;
	char a1, a2;
	int su;
	string pai;
}s[inf];
map<char, int> v;
vector<stu> g[15];
int n;
string s1, s2;
void chushi() {
	for (int i = 1; i <= n; i++) {
		s[i].su=0;
	}
	for(int i=1;i<=8;i++) g[i].clear();
}
bool zidianxu(string a, string b) {
	unsigned m = min(a.size(), b.size());
	for (unsigned i = 0; i < m; i++) {
		if (a[i] < b[i]) return true;
		else if (a[i] > b[i]) return false;
	}
	if (a.size() <= b.size()) return true;
	else return false;
}
void val() {
	v['A'] = 1;
	v['1'] = 10;
	v['0'] = 10;
	for (int i = 50; i <= 57; i++) {
		v[i] = i - 48;
	}
	v['J'] = 11;
	v['Q'] = 12;
	v['K'] = 13;
}
void putout() {
	for (int i = 8; i >= 1; i--) {
		if (!g[i].empty()) {
			for (auto it = g[i].begin(); it != g[i].end(); it++)
				cout << it->name << endl;
		}
	}
}
bool cmp(char a, char b) {
	if (v[a] < v[b]) return true;
	else return false;
}
bool cmp1(stu a, stu b) {
	if (a.su > b.su) return true;
	else if (a.su < b.su) return false;
	else {
		if (zidianxu(a.name, b.name)) return true;
		else return false;
	}
}
bool cmp2(stu a, stu b) {
	if (v[a.a1] > v[b.a1]) return true;
	else if (v[a.a1] < v[b.a1]) return false;
	else {
		if (a.su > b.su) return true;
		else if (a.su < b.su) return false;
		else {
			if (zidianxu(a.name, b.name)) return true;
			else return false;
		}
	}
}
bool cmp3(stu a, stu b) {
	if (v[a.a1] > v[b.a1]) return true;
	else if (v[a.a1] < v[b.a1]) return false;
	else {
		if (v[a.a2] > v[b.a2]) return true;
		else if (v[a.a2] < v[b.a2]) return false;
		else {
			if (a.su > b.su) return true;
			else if (a.su < b.su) return false;
			else {
				if (zidianxu(a.name, b.name)) return true;
				else return false;
			}
		}
	}
}
bool cmp4(stu a, stu b) {
	if (v[a.a1] > v[b.a1]) return true;
	else if (v[a.a1] < v[b.a1]) return false;
	else {
		if (a.su > b.su) return true;
		else if (a.su < b.su) return false;
		else {
			if (zidianxu(a.name, b.name)) return true;
			else return false;
		}
	}
}
bool cmp5(stu a, stu b) {
	if (v[a.a1] > v[b.a1]) return true;
	else if (v[a.a1] < v[b.a1]) return false;
	else {
		if (v[a.a2] > v[b.a2]) return true;
		else if (v[a.a2] < v[b.a2]) return false;
		else {
			if (zidianxu(a.name, b.name)) return true;
			else return false;
		}
	}
}
bool cmp6(stu a, stu b) {
	if (v[a.a1] > v[b.a1]) return true;
	else if (v[a.a1] < v[b.a1]) return false;
	else {
		if (a.su > b.su) return true;
		else if (a.su < b.su) return false;
		else {
			if (zidianxu(a.name, b.name)) return true;
			else return false;
		}
	}
}
bool cmp7(stu a, stu b) {
	if (v[a.a1] > v[b.a1]) return true;
	else if (v[a.a1] < v[b.a1]) return false;
	else {
		if (zidianxu(a.name, b.name)) return true;
		else return false;
	}
}
bool cmp8(stu a, stu b) {
	if (zidianxu(a.name, b.name)) return true;
	else return false;
}
int leixing(int x) {
	string dui[2], san, zha;
	int z = 1, t = 0;
	string h = s[x].pai;
	int a[15];
	for (int i = 0; i <= 14; i++) a[i] = 0;
	for (unsigned i = 0; i < h.size(); i++) {
		if (h[i] == '0') continue;
		a[v[h[i]]]++;
		s[x].su += v[h[i]];
	}
	vector<int> px;
	for (int i = 1; i <= 13; i++) {
		if (a[i] == 0) continue;
		if (a[i] == 2) {
			dui[t] = w[i];
			s[x].su = s[x].su - 2 * i;
			t++;
		}
		else if (a[i] == 3) {
			san = w[i];
			s[x].su = s[x].su - 3 * i;
		}
		else if (a[i] == 4) {
			zha = w[i];
			s[x].su = s[x].su - 4 * i;
		}
		else px.push_back(i);
	}
	if (t == 1 && !san.empty()) { s[x].a1 = san[0]; s[x].a2 = dui[0][0]; return 5; }
	else if (!san.empty()) {
		s[x].a1 = san[0]; return 4;
	}
	else if (t == 1) {
		s[x].a1 = dui[0][0]; return 2;
	}
	else if (t == 2) { s[x].a1 = dui[1][0]; s[x].a2 = dui[0][0]; return 3; }
	if (!zha.empty()) {
		s[x].a1 = zha[0]; return 6;
	}
	if(px[0]==1&&px[1]==10&&px[2]==11&&px[3]==12&&px[4]==13) return 8;
	for (unsigned i = 0; i < px.size() - 1; i++) {
		if (px[i + 1] - px[i] != 1) return 1;
	}
		s[x].a1 = w[px[0]][0];
		return 7;
}
void fenzu() {
	for (int i = 1; i <= n; i++) {
		g[leixing(i)].push_back(s[i]);
	}
}
void paixu() {
	for (int i = 1; i <= 8; i++) {
		if (g[i].size() <= 1) continue;
		if (i == 1 ) {
			sort(g[1].begin(), g[1].end(), cmp1);
		}
		else if (i == 2 ) {
			sort(g[2].begin(), g[2].end(), cmp2);
		}
		else if (i == 3 ) {
			sort(g[3].begin(), g[3].end(), cmp3);
		}
		else if (i == 4 ) {
			sort(g[4].begin(), g[4].end(), cmp4);
		}
		else if (i == 5) {
			sort(g[5].begin(), g[5].end(), cmp5);
		}
		else if (i == 6 ) {
			sort(g[6].begin(), g[6].end(), cmp6);
		}
		else if (i == 7 ) {
			sort(g[7].begin(), g[7].end(), cmp7);
		}
		else if (i == 8) {
			sort(g[8].begin(), g[8].end(), cmp8);
		}
	}
}
int main() {
	val();
	while (cin >> n) {
		chushi();
		for (int i = 1; i <= n; i++) {
			cin >> s1 >> s2;
			sort(s2.begin(), s2.end(), cmp);
			s[i].name = s1;
			s[i].pai = s2;
		}
		fenzu();
		paixu();
		putout();
	}
	return 0;
}

签到题

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

思路：最大值很简单，设人没来之前人最多的长椅上有Max人，最大值就是来的人都坐到了来之前人数最多的椅子上，即Max+y。对于最小值，我们需要计算来之后的总人数Sum，对于总人数，每条长椅平均可以坐Avg=Sum/x个人，剩余n=Sum%x个人没座位，如果Avg小于Max，则最小值mn=Max，当Max大于Avg时，如果n=0，则mn=Avg，如果n>0，则mn=Avg+n。

#include <iostream>
#include <algorithm>
using namespace std;
const int inf=1e4;
int x,y,a[inf],k,Max=-2000,Min,Sum=0,n,Avg;

int main(){
	cin>>x>>y;
	for(int i=1;i<=x;i++){
		cin>>a[i];
		Sum+=a[i];
		Max=max(Max,a[i]);
	}
	Sum+=y;
	n=Sum%x;
	Avg=Sum/x;
	if(Avg<Max) Min=Max;
	else{
		if(n==0){
			Min=Avg;
		}
		else Min=Avg+1;
	}
	Max=Max+y;
	cout<<Min<<" "<<Max;
	return 0;
}