SDU week9作业 A（目录管理器）B（打牌）C（公园的长凳）

最新推荐文章于 2020-05-06 21:18:36 发布

^O^ ? ^O^

最新推荐文章于 2020-05-06 21:18:36 发布

阅读量296

点赞数

分类专栏：学习

本文链接：https://blog.csdn.net/weixin_45736432/article/details/105655911

版权

学习专栏收录该内容

30 篇文章 0 订阅

订阅专栏

A:目录管理器

题意：

咕咕东的雪梨电脑的操作系统在上个月受到宇宙射线的影响，时不时发生故障，他受不了了，想要写一个高效易用零bug的操作系统 —— 这工程量太大了，所以他定了一个小目标，从实现一个目录管理器开始。前些日子，东东的电脑终于因为过度收到宇宙射线的影响而宕机，无法写代码。他的好友TT正忙着在B站看猫片，另一位好友瑞神正忙着打守望先锋。现在只有你能帮助东东！

初始时，咕咕东的硬盘是空的，命令行的当前目录为根目录 root。

目录管理器可以理解为要维护一棵有根树结构，每个目录的儿子必须保持字典序。
在这里插入图片描述

现在咕咕东可以在命令行下执行以下表格中描述的命令：
在这里插入图片描述

输入：

输入文件包含多组测试数据，第一行输入一个整数表示测试数据的组数 T （T <= 20）；
每组测试数据的第一行输入一个整数表示该组测试数据的命令总数 Q （Q <= 1e5）；
每组测试数据的 2 ~ Q+1 行为具体的操作（MKDIR、RM 操作总数不超过 5000）；
面对数据范围你要思考的是他们代表的 “命令” 执行的最大可接受复杂度，只有这样你才能知道你需要设计的是怎样复杂度的系统。

输出：

每组测试数据的输出结果间需要输出一行空行。注意大小写敏感。

样例：

样例输入：
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

分析：

因为这道题是按照助教写的照搬过来的，这里的分析就写一下自己所理解的这道题。
其中操作mkdir,rm,cd ，属于具体的操作
sz,ls,tree 是查询操作，对目录结构和之后的操作都不影响
undo 是针对 mkdir,rm,cd 的撤销操作。

其中需要存储的结构是两部分，目录和命令
目录中有很多子目录并且要求根据子目录的名字取到它的子目录，因此结构是：map<string,Directory*> children,并且，每个目录要存储它的父节点，和子树的大小。

之后的任务就是具体写出相应操作的函数。
由于存在一个undo 函数，需要保存每条指令的执行结果，防止之后要进行删除回退增加操作。进入目录也需要判断子目录是不是存在，或者存不存在上级目录。
之后就是各种操作和查询函数的实现。创建和删除目录前需要判断创建或删除的目录是否存在。

tree :在写tree 的时候后代节点大于10 就需要前序遍历和后序遍历，对时间复杂度有要求，而在题目中这样的查询又很多，因此这里采用一种懒更新方法。每一次做完谦虚后序遍历的时候，保存当前节点的十个后代，并且保存更新情况，当没有更新的时候，下次再问到这里就不需要重新计算。

代码：

#include<stdio.h>
#include<string>
#include<map>
#include<vector>
#include<algorithm> 
#include<iostream>
using namespace std;
char tmps[20];
struct Directory
{
	string name;
	map<string,Directory*> children;
	Directory* parent;
	int subtreesize;
	bool updated;
	vector<string>* tenDescendants;
	Directory(string name,Directory* parent){
		this->name=name;
		this->parent=parent;
		this->subtreesize=1; 
		this->tenDescendants = new vector<string>;
	}
public:
	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);
	}
	Directory* mkdir(string name)
	{
		if(children.find(name)!=children.end())
			return nullptr;
		Directory* ch=new Directory(name,this);
		children[name]=ch;
		maintain(+1);
		return ch;
	}
	Directory* rm(string name)
	{
		auto it=children.find(name);
		if(it==children.end())
			return nullptr;
		maintain(-1*it->second->subtreesize);
		children.erase(it);
		return it->second;
	}
	Directory* cd(string name)
	{
		if(".."==name)
			return this->parent;
		return getchild(name);
	}
	Directory* getchild(string name){
		auto it=children.find(name);
		if(it==children.end())
			return nullptr;
		return it->second;
	}
	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());
		}
	}
};
struct Command
{
	int type;
	string arg;
	Directory* tmpDir;
	const string CMDNAMES[7]={"MKDIR","RM","CD","SZ","LS","TREE","UNDO"};
	Command(string s)
	{
		for(int i=0;i<7;i++)
		{
			if(CMDNAMES[i]==s){
				type=i;
				if(i<3)	scanf("%s",tmps),arg=tmps;
				return ;
			}
		}
	}
};

void solve()
{
	int n;
	scanf("%d",&n);
	Directory* now=new Directory("root",nullptr);
	vector<Command*> cmdList;
	while(n--)
	{
		scanf("%s",tmps);
		Command* cmd = new Command(tmps);
		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:{
				//undo
				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"); 
			}
		}	
	}
	cout<<endl;
}
int main() 
{
	int T;
	scanf("%d",&T);
	while(T--) solve();
	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

分析：

打牌的题看上去依旧是非常麻烦，但是总归还是一个排序题，要解决的就是怎么排序的问题。牌的次序依旧是牌的类型->牌的类型中的关系->名字的字典序。
借照上题封装的思想，需要将人和牌以及中间的转换比较方法封装起来。
第一步修改AJQK；
第二步将每个人的牌排序，以便后序操作
第三步确定牌的类型，和比较的内容（看全部的比较内容，无非就是特殊的牌的大小和剩余的牌的和的大小，最多一种牌型里需要比较三次，就设置a,b,sum,三种，以便后续比较）
第四步，重写比较函数，按照之前规定的顺序进行排序。

代码：

#include<stdio.h>
#include<string> 
#include<algorithm>
#include<iostream>
using namespace std;
struct person{
	
	string name;  //名字
	int type;  //牌的类型
	int p[6];  //具体的牌 
	string p1; 
	int a,b,sum;    //type a b sum m 
	void p2p()
	{
		int k=0;
		for(int i=0;i<p1.size();i++){
			if(p1[i]=='A'){
				p[k]=1;k++;
			}
			else if(p1[i]=='J'){
				p[k]=11;k++;
			}
			else if(p1[i]=='Q'){
				p[k]=12;k++;
			}
			else if(p1[i]=='K'){
				p[k]=13;k++;
			}
			else if(p1[i]=='1'){
				p[k]=10;k++;i++;
			}
			else {
				p[k]=p1[i]-'0'; k++;
			}
		} 
	}
	void Sort(){
		sort(p,p+5); 
	}
	void Type(){
		if(p[0]==1&&p[1]==10&&p[2]==11&&p[3]==12&&p[4]==13){
			this->type=8;
			return;
		}
		else if(p[1]==p[0]+1&&p[2]==p[1]+1&&p[3]==p[2]+1&&p[4]==p[3]+1){
			this->type=7;
			this->a=p[4]; 
			return;
		}
		else if(p[0]==p[1]&&p[1]==p[2]&&p[2]==p[3]){
			this->type=6;
			this->a=p[0];
			this->b=p[4]; return;
		}
		else if(p[4]==p[3]&&p[1]==p[2]&&p[2]==p[3]){
			this->type=6;
			this->a=p[4];
			this->b=p[0]; return;
		}
		else if(p[0]==p[1]&&p[1]==p[2]&&p[3]==p[4]){   //前三 后二 
			this->type=5;
			this->a=p[0];
			this->b=p[4];    return;
		}
		else if(p[0]==p[1]&&p[2]==p[3]&&p[3]==p[4]){   //前二 后三 
			this->type=5;
			this->a=p[4];
			this->b=p[0];	return;
		}
		else if(p[0]==p[1]&&p[1]==p[2]){   //前三  
			this->type=4;
			this->a=p[0];
			this->b=p[3]+p[4]; return;
		}
		else if(p[2]==p[1]&&p[2]==p[3]){   //中三 
			this->type=4;
			this->a=p[1];
			this->b=p[0]+p[4];   return ;
		}
		else if(p[2]==p[3]&&p[3]==p[4]){   //后三 
			this->type=4;
			this->a=p[3];
			this->b=p[0]+p[1];  return ;
		}
		else if(p[0]==p[1]&&p[2]==p[3]){ //12 34
			this->type=3;
			this->a=max(p[0],p[2]);
			this->b=min(p[0],p[2]);
			this->sum=p[4];    return ;
		} 
		else if(p[0]==p[1]&&p[3]==p[4]){ //12 45
			this->type=3;
			this->a=max(p[1],p[3]);
			this->b=min(p[1],p[3]);
			this->sum=p[2];  return;
		}
		else if(p[1]==p[2]&&p[3]==p[4]){ //23 45
			this->type=3;
			this->a=max(p[1],p[3]);
			this->b=min(p[1],p[3]);
			this->sum=p[0]; return;
		}
		else if(p[0]==p[1]){    //01
			this->type=2;
			this->a=p[0]; 
			this->b=p[2]+p[3]+p[4]; return;
		} 
		else if(p[2]==p[1]){   //12
			this->type=2;
			this->a=p[1];
			this->b=p[0]+p[3]+p[4]; return;
		}
		else if(p[2]==p[3]){  //23
			this->type=2;
			this->a=p[2];
			this->b=p[0]+p[1]+p[4];   return;
		}
		else if(p[3]==p[4]){     //34
			this->type=2;
			this->a=p[3];
			this->b=p[0]+p[1]+p[2];   return;
		}
		else {
			this->type=1;
			this->a=p[0]+p[1]+p[2]+p[3]+p[4];  return;
		}
	}
	bool operator < (const person &e)const {
		if(type!=e.type) 	return type<e.type;
		else if(a!=e.a)		return a<e.a; 
		else if(b!=e.b)		return b<e.b; 
		else if(sum!=e.sum)		return sum<e.sum; 
		else if(name!=e.name)		return name>e.name; 
		return true;
	}
}pp[100010];
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		cin>>pp[i].name;
		cin>>pp[i].p1;
	}	 //数据输入完成 
	for(int i=0;i<n;i++){
		pp[i].p2p();
		pp[i].Sort();
		pp[i].Type();
	} 
	sort(pp,pp+n);
	for(int i=n-1;i>=0;i--)	cout<<pp[i].name<<endl ;
	return 0;
}

公园的长凳

题意：

SDUQD 旁边的滨海公园有 x 条长凳。第 i 个长凳上坐着 a_i 个人。这时候又有 y 个人将来到公园，他们将选择坐在某些公园中的长凳上，那么当这 y 个人坐下后，记k = 所有椅子上的人数的最大值，那么k可能的最大值mx和最小值mn分别是多少。

输入：

第一行包含一个整数 x (1 <= x <= 100) 表示公园中长椅的数目
第二行包含一个整数 y (1 <= y <= 1000) 表示有 y 个人来到公园
接下来 x 个整数 a_i (1<=a_i<=100)，表示初始时公园长椅上坐着的人数

输出：

输出 mn 和 mx

样例：

样例输入:
3
7
1
6
1
样例输出：
6 13

分析：

读题很重要，非常重要…
这道题的意思是要求出最大值中的最小值和最大值。
最大值就是原来凳子最多的人数加上新来的人数，这样这个凳子的人就是最大的。
最大值中的最小值，就是人不能都做到一个凳子上，尽量分散开来。第一轮将新来的人向原来的最大值靠齐，如果没有剩余的人，就是原来凳子的最大人数是最小值。
如果还有人没有坐，此时所有凳子的人是相同的，这样按照如果是k不能被n 整除结果就是a[n-1]+k/n+1；要是能整除就是a[n-1]+k/n；

代码：

#include<stdio.h>
#include<algorithm>
using namespace std;
//最大值中的最小值和最大值 
int a[150]; 
int main()
{
	int n,k,mn;        // 3 7  2 7  3 7
	scanf("%d %d",&n,&k);
	int t=k;
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);   
	}
	sort(a,a+n);
	for(int i=0;i<n;i++){
		k=k-(a[n-1]-a[i]);
		if(k<=0){
			mn=a[n-1];
			break;
		}
	}
	if(k>0){
		if(k%n!=0)
			mn=a[n-1]+k/n+1;
		else
			mn=a[n-1]+k/n;
	}
	printf("%d %d\n",mn,a[n-1]+t);
	return 0;
 }

^O^ ? ^O^

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SDU week9作业 A（目录管理器）B（打牌）C（公园的长凳）

week9 作业A:目录管理器题意：输入：输出：样例：分析：总结：代码：东东学打牌题意：输入：输出：样例：分析：代码：公园的长凳题意：输入：输出：样例：分析：代码：A:目录管理器题意：咕咕东的雪梨电脑的操作系统在上个月受到宇宙射线的影响，时不时发生故障，他受不了了，想要写一个高效易用零bug的操作系统 —— 这工程量太大了，所以他定了一个小目标，从实现一个目录管理器开始。前些日子，东东的电脑...
复制链接

扫一扫