程序设计思维与实践Week9 作业 (1/2/智能班)

哇哦12

于 2020-06-11 22:09:59 发布

阅读量162

点赞数

本文链接：https://blog.csdn.net/weixin_43414455/article/details/106691688

版权

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

解题思路

运用了面向对象的思想，每个命令都是一个Command，每个目录是一个Directory，在执行命令时，由于有undo操作，所以要把一些变量保存在Command的tmpDir中，然后把执行成功的命令存到cmdList中，以便于undo时恢复。
另外如果每次tree操作都要查询一遍会超时，所以使用了缓存，用update记录是否更新过，对于当前目录如果距离上次tree操作没有跟新过的话，直接输出上次查询的结果即可，若果更新了则重新查询一遍，设置为为未更新

#include<iostream>
#include<string>
#include<vector>
#include<map>
using namespace std;
char st[20];


struct Directory
{
	string name;
	map<string,Directory*> children;
	Directory *parent;
	int size;
	
	vector<string>* tenDes;
	bool updated;
	
	
	Directory(string name,Directory *parent)
	{
		this->name=name;
		this->parent=parent;
		size=1;
		tenDes=new vector<string>();
	}
	bool addChild(Directory *ch)
	{
		map<string,Directory*>::iterator it = children.find(ch->name);
		if(it!=children.end())
			return 0;
		children[ch->name]=ch;
		maintain(ch->size);
		//cout<<ch->size<<"      ascasvad"<<endl;
		return true;
	}
	Directory *getChild(string name)
	{
		map<string,Directory*>::iterator it = children.find(name);
		if(it==children.end())
			return NULL;
		else
			return it->second;
	}
	Directory *mkdir(string name)
	{
		if(children.find(name)!=children.end())
			return NULL;
		Directory * ch=new Directory(name,this);
		children[name]=ch;
		maintain(1);
		return ch;
		
	}
	
	Directory * rm(string name)
	{
		map<string,Directory*>::iterator it = children.find(name);
		if(it==children.end())
			return NULL;
		map<string,Directory*>::iterator t1=it;
		maintain(-1*it->second->size);
		children.erase(it);
		return t1->second;
		
	}
	
	Directory * cd(string name)
	{
		if(name=="..")
			return this->parent;
		else
			return getChild(name);
	}
	
	void maintain(int delta)
	{
		updated=true;
		size+=delta;
		if(parent!=NULL)
			parent->maintain(delta);
	}
	
	
	
	void sz(){	printf("%d\n",this->size); }
	
	void ls()
	{
		int sz=children.size();
		if(sz==0)
			printf("EMPTY\n");
		else if(sz<=10)
		{
			for(map<string,Directory*>::iterator it=children.begin();it!=children.end();it++)
				printf("%s\n",(*it).first.c_str());
			
		}
		else
		{
			map<string,Directory*>::iterator 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(size==1)
			printf("EMPTY\n");
		else if(size<=10)
		{
			if(updated)
			{
				tenDes->clear();
				treeAll(tenDes);
				this->updated=false;
			}
		//	cout<<"       "<<size<<endl;
			for(int i=0;i<size;i++)
				printf("%s\n",tenDes->at(i).c_str());
			
		}
		else
		{
			if(this->updated)
			{
				tenDes->clear();
				treeFirst(5,tenDes);
				treeLast(5,tenDes);
				this->updated=false;
			}
			for(int i=0;i<5;i++)
				printf("%s\n",tenDes->at(i).c_str());
			printf("...\n");
			for(int i=9;i>=5;i--)
				printf("%s\n",tenDes->at(i).c_str());
		}
	}
	
	
	void treeAll(vector<string>*v)
	{
		v->push_back(name);
		for(map<string,Directory*>::iterator it=children.begin();it!=children.end();it++)
			it->second->treeAll(v);
		
	}
	void treeFirst(int num,vector<string>*v)
	{
		v->push_back(this->name);
		if(--num==0)
			return;
		int n=children.size();
		map<string,Directory*>::iterator it=children.begin();
		while(n--)
		{
			int si=it->second->size;
			if(si>=num)
			{
				it->second->treeFirst(num,v);
				return;
			}
			else
			{
				it->second->treeFirst(si,v);
				num-=si;	
			}
			it++;	
		}
		
	}
	void treeLast(int num,vector<string>*v)
	{
		int n=children.size();
		map<string,Directory*>::iterator it=children.end();
		while(n--)
		{
			it--;
			int si=it->second->size;
			if(si>=num)
			{
				it->second->treeLast(num,v);
				return;
			}
			else
			{
				it->second->treeLast(si,v);
				num-=si;
			}
		}
		v->push_back(name);
	}
	
};




struct Command
{
	const string names[7]={"MKDIR","RM","CD","SZ","LS","TREE","UNDO"};
	int type;
	string arg;
	Directory* tmpdir;
	
	Command(string s)
	{
		for(int i=0;i<7;i++)
		{
			if(s==names[i])
			{
				type=i;
				if(i<3)
				{
					scanf("%s",st);
					arg=st;
				}
				break;
			}
		}
	}
	
};






void solve()
{
	int n;
	Directory *now=new Directory("root",NULL);
	vector<Command*> cmdList; 
	scanf("%d",&n);
	while(n--)
	{
		scanf("%s",st);
		Command* cmd=new Command(st);
		
		switch(cmd->type)
		{
			case 0:
				cmd->tmpdir = now->mkdir(cmd->arg);
				if(cmd->tmpdir==NULL)
					printf("ERR\n");
				else
				{
					printf("OK\n");
					cmdList.push_back(cmd);
				}
				break;
				
			case 1:
				cmd->tmpdir = now->rm(cmd->arg);
				if(cmd->tmpdir==NULL)
					printf("ERR\n");
				else
				{
					printf("OK\n");
					cmdList.push_back(cmd);
				}
				break;
				
			case 2:
			{
				Directory* dd=now->cd(cmd->arg);
				if(dd==NULL)printf("ERR\n");
				else
				{
					printf("OK\n");
					cmd->tmpdir=now;
					now=dd;
					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)!=NULL;break;
						
					
						case 1:success = now->addChild(cmd->tmpdir);break;
/*	**/					case 2: now=cmd->tmpdir; success=true;break;
					}
				}
				if(success)
					printf("OK\n");
				else
					printf("ERR\n");
				break;
			}
			
		}
		
	}
}



int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		solve();
	}
 }

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 行，即这次全场人的排名。

样例输入

3
DongDong AAA109
ZJM 678910
Hrz 678910

样例输出

Hrz
ZJM
DongDong

解题思路

将八种牌型由小到大用1到8来表示。

将A，J,Q,K依次转换成数字1，11，12，13。

每个人的牌用一个结构体来表示：

name:名字，s :牌，rank:记录牌型，tot:记录牌大小总和，

two[3]:two[0]用来记录对子的个数，最多有两个对子，则分别用two[1]和two[2]来表示对子的大小；

three[2]:three[0]用来记录是否由三张牌值相等，three[1]用来记录相等的牌值；

four[2]:four[0]用来记录是否有四张牌相等，four[1]用来记录相等的牌值

首先通过遍历每个人的牌对结构体进行填写，然后再来依次进行比较

#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
using namespace std;
int tmp[15];
struct person

{

	string  name;
	string s;
	int rank;
	int tot;
	int two[3];
	int three[2];
	int four[2];
	bool shun;
	bool operator < (const person p)const
	{
		if (rank != p.rank)
			return rank > p.rank;
                else if (rank == p.rank)
		{
			if (rank == 1)
			{
				if (tot != p.tot)
					return tot > p.tot;
			}
			else if (rank == 2)
			{
				if (two[1] != p.two[1])
					return two[1] > p.two[1];
				else if (tot != p.tot)
					return tot > p.tot;
			}
			else if (rank == 3)
			{
				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 (tot != p.tot)
					return tot > p.tot;
			}
			else if (rank == 4 || rank == 5)
                        {
				if (three[1] != p.three[1])
					return three[1] > p.three[1];
				else if (tot != p.tot)
					return tot > p.tot;
			}
			else if (rank == 6)
			{
				if (four[1] != p.four[1])
					return four[1] > p.four[1];
				else if (tot != p.tot)
					return tot > p.tot;
			}

			else if (rank == 7)
			{
				if (tot != p.tot)
					return tot > p.tot;
			}

		}
		int a = name.length(), b = p.name.length();
                for (int i = 0; i < min(a, b); i++)
		{
			if (name[i] == p.name[i]) 
				continue;
			else if (name[i] < p.name[i]) 
				return true;
			return false;
		}
		if (a < b) 
			return true;
		return false;
	}

}p[100010];
void f(int x)
{
	int i = 0;
	memset(tmp, 0, sizeof(tmp));
	while (i < p[x].s.length())
	{
		if (p[x].s[i] == '1')
		{
			tmp[10]++;
			i++;
		}
		else
		{
			if (p[x].s[i] >= '2' && p[x].s[i] <= '9')
				tmp[p[x].s[i] - '0']++;
			else
			{
				if (p[x].s[i] == 'A')
					tmp[1]++;
				if (p[x].s[i] == 'J')
					tmp[11]++;
				if (p[x].s[i] == 'Q')
					tmp[12]++;
				if (p[x].s[i] == 'K')
					tmp[13]++;
			}
		}
		i++;
            }
	if (tmp[1] && tmp[10] && tmp[11] && tmp[12] && tmp[13])
	{
		p[x].rank = 8;
		return;
	}
	for (int i = 1; i <= 13; i++)
		if (tmp[i])
		{
			for (int j = 1; j <= tmp[i]; j++)
				p[x].tot += i;
		}
	for (int i = 13; i >= 1; i--)
	{
		if (tmp[i] == 4)
		{
			p[x].four[0] = 1;
			p[x].four[1] = i;
			p[x].rank = 6;
			return;
		}
                if (tmp[i] == 3)
		{
			p[x].three[0] = 1;
			p[x].three[1] = i;
		}
		if (tmp[i] == 2)
		{
			p[x].two[0]++;
			if (p[x].two[0] == 1)
				p[x].two[1] = i;
			else
			{
				p[x].two[2] = i;
				p[x].rank = 3;
				return;
			}
		}
	}
	for (int i = 1; i <= 9; i++)
		if (tmp[i] && tmp[i + 1] && tmp[i + 2] && tmp[i + 3] && tmp[i + 4])
		{
			p[x].shun = 1;
			p[x].rank = 7;
			return;
		}
                if (p[x].two[0] == 1 && p[x].three[0] == 1)
	{
		p[x].rank = 5;
		return;
	}
	if (p[x].two[0] == 1)
	{
		p[x].rank = 2;
		return;
	}
	if (p[x].three[0] == 1)
	{
		p[x].rank = 4;
		return;
	}
	p[x].rank = 1;
}
void init(int x)
{
	memset(p[x].two, 0, sizeof(p[x].two));
	memset(p[x].three, 0, sizeof(p[x].three));
	memset(p[x].four, 0, sizeof(p[x].four));
	p[x].shun = 0; p[x].rank = 0; p[x].tot = 0;
}

int main()
{
	int n;
	while (cin>>n)
	{
		for (int i = 0; i < n; i++)
		{
			init(i);
			cin >> p[i].name >> p[i].s;
			f(i);
		}
		sort(p , p + n);
		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

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

解题思路

用数组a[i]记录每个椅子的人数，先用sort排序，则mx=a[x]+y即所有人坐到原本人数最多的椅子上

求解mn,随后计算出一个值：若当前所有凳子上人数相等，至少要添几个人。将这个值更新为sum，分两种情况讨论：
①若到来的人数y大于sum：将y多于sum的人数平均分配到每条长凳上，结果就是mn；
②若到来的人数y小于sum：人数最多的长凳就是mn

#include<iostream>
#include<algorithm>
using namespace std;
int a[101];
int main()
{
	int x, y;
	cin >> x >> y;
	for (int i = 1; i <= x; i++)
		cin >> a[i];
	sort(a + 1, a + 1 + x);
	int mn = 0, mx = a[x] + y;
	int ans = 0;
	for (int i = 1; i < x; i++)
		ans += a[x] - a[i];
	if (y <= ans)
		mn = a[x];
	else
	{
		int tmp = y - ans;
		if (tmp % x == 0)
                    #include<iostream>
#include<algorithm>
using namespace std;
int a[101];
int main()
{
	int x, y;
	cin >> x >> y;
	for (int i = 1; i <= x; i++)
		cin >> a[i];
	sort(a + 1, a + 1 + x);
	int mn = 0, mx = a[x] + y;
	int ans = 0;
	for (int i = 1; i < x; i++)
		ans += a[x] - a[i];
	if (y <= ans)
		mn = a[x];
	else
	{
		int tmp = y - ans;
		if (tmp % x == 0)
                    #include<iostream>
#include<algorithm>
using namespace std;
int a[101];
int main()
{
	int x, y;
	cin >> x >> y;
	for (int i = 1; i <= x; i++)
		cin >> a[i];
	sort(a + 1, a + 1 + x);
	int mn = 0, mx = a[x] + y;
	int ans = 0;
	for (int i = 1; i < x; i++)
		ans += a[x] - a[i];
	if (y <= ans)
		mn = a[x];
	else
	{
		int tmp = y - ans;
		if (tmp % x == 0)
                   mn = tmp / x + a[x];
		else
			mn = tmp / x + 1 + a[x];
	}
	cout << mn << " " << mx ;
}

哇哦12

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
程序设计思维与实践Week9 作业 (1/2/智能班)

A - 咕咕东的目录管理器题面咕咕东的雪梨电脑的操作系统在上个月受到宇宙射线的影响，时不时发生故障，他受不了了，想要写一个高效易用零bug的操作系统 —— 这工程量太大了，所以他定了一个小目标，从实现一个目录管理器开始。前些日子，东东的电脑终于因为过度收到宇宙射线的影响而宕机，无法写代码。他的好友TT正忙着在B站看猫片，另一位好友瑞神正忙着打守望先锋。现在只有你能帮助东东！初始时，咕咕东的硬盘是空的，命令行的当前目录为根目录 root。目录管理器可以理解为要维护一棵有根树结构，每个目录的儿子
复制链接

扫一扫