Program week9 work

最新推荐文章于 2022-02-06 22:53:50 发布

Maroon°

最新推荐文章于 2022-02-06 22:53:50 发布

阅读量91

点赞数

分类专栏： work

本文链接：https://blog.csdn.net/qq_45050487/article/details/105658284

版权

work 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

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

思路

对于像这种涉及操作比较多的题，首先确定一个解题框架是很有必要的。
这里采用面向对象的方法，使用结构体来存储每一个目录，并将实现所有操作的方法封装起来。这里要注意一个目录可能有多个子目录，并且需要保证按字典序进行排序，所以这里使用map，每一个目录名映射到一个目录指针，map自动按第一维排序，并且map的红黑树结构将时间复杂度优化为为log（n）。
七个操作中，部分操作可能会改变目录的某些内容，比如可能会改变子目录的数目，这里我们利用函数maintain来由下往上维护大小；对于undo操作，需要额外维护一个数组，删除与加入时分别要加入相应的cmd
对于操作tree，如果每次执行tree操作都将整个目录遍历一遍则会超时。这里对tree进行缓存，并我们通过一个bool型的变量update来标记该目录在一次tree操作后是否更改过。如果没有被更改过，则直接输出已经保存好的结果。如果被更新过，则对目录进行遍历，如果该文件下的目录个数不大于10个，则直接遍历输出；如果大于10个，分别遍历得到前5个目录和后5个目录，并各自输出。

Answer

具体思路见注释

#include<iostream>
#include<stdio.h>
#include<string>
#include<vector>
#include<map>
#include<string.h>
using namespace std;
char tmp[20];
struct dir;
struct command {
	const string CMD[7] = { "MKDIR","RM","CD","SZ","LS","TREE","UNDO" };
	int type;
	string argu;//参数
	dir* target_dir;

	command(string& t) {
		for (int i = 0; i < 7; i++)
			if (t == CMD[i])type = i;
		if (type < 3) {
			scanf("%s", tmp);
			argu = tmp;
		}
	}
};
struct dir {
	string name;
	map<string, dir*>children;
	dir* parent;
	int size;
	bool update;
	vector<string> tenDescends;//存储遍历过的孩子
	dir(string Name, dir* Parent) {
		size = 1;
		name = Name;
		parent = Parent;
		update = true;
	}
	public:
	dir* getchild(string& x) {
		map<string, dir*>::iterator it = children.find(x);
		if (it == children.end())return NULL;
		else return it->second;
	}
	dir* cd(string& x)
	{
		if (x == "..")
			return parent;
		else return getchild(x);
	}
	dir* mkdir(string& x) {
		if (children.find(x) != children.end())return NULL;
		dir* te = new dir(x, this);
		children[x] = te;
		maintain(1);
		return te;
	}
	dir* rm(string& x)//返回已删除的目录
	{
		map<string, dir*>::iterator it = children.find(x);
		if (it == children.end())return NULL;
		maintain(-1 * it->second->size);
		children.erase(it);
		return it->second;
	}
	dir* addchild(dir* x) {//返回增加的目录
		if (children.find(x->name) != children.end())return NULL;
		else children[x->name] = x;
		maintain(1 * x->size);
		return x;
	}
	void maintain(int s) {
		update = true;
		size += s;
		if (parent != NULL)parent->maintain(s);
	}
	void sz() {
		cout << size << endl;
	};
	void ls() {
		int size = children.size();
		if (size == 0)cout << "EMPTY" << endl;
		else {
			if (size <= 10) {
				map<string, dir*>::iterator it = children.begin();
				while (it != children.end())
				{
					cout << it->first << endl;
					it++;
				}
			}
			else {
				map<string, dir*>::iterator it = children.begin();
				for (int i = 0; i < 5; i++, it++)
					cout << it->first << endl;
				cout << "..." << endl;
				it = children.end();
				for (int i = 0; i < 5; i++)it--;
				for (int i = 0; i < 5; i++, it++)
					cout << it->first << endl;
			}
		}
	}
	void tree() {
		if (size == 1)cout << "EMPTY" << endl;
		else {
			if (size <= 10) {
				if (update) {
					tenDescends.clear();
					treeall(&tenDescends);
					update = false;
				}
				for (int i = 0; i < size; i++)
					cout << tenDescends[i] << endl;
			}
			else {
				if (update)
				{
					tenDescends.clear();
					treeFirst(5, &tenDescends);
					treeLast(5, &tenDescends);
					update = false;
				}
				for (int i = 0; i < 5; i++)
					cout << tenDescends[i] << endl;
				cout << "..." << endl;
				for (int i = 9; i >= 5; i--)
					cout << tenDescends[i] << endl;
			}
		}
	}
	private:
	void treeall(vector<string>* x) {
		x->push_back(name);
		for (map<string, dir*>::iterator it = children.begin(); it != children.end(); it++)
			it->second->treeall(x);
	}
	void treeFirst(int n, vector<string>* x) {//遍历前五个节点
		x->push_back(name);
		if (--n == 0)return;

		int Size = children.size();
		map<string, dir*>::iterator it = children.begin();

		while (Size--)
		{
			int sizei = it->second->size;//每个孩子的目录的大小
			if (sizei >= n) {//如果够了
				it->second->treeFirst(n, x);//遍历完就返回
				return;
			}
			else {
				it->second->treeFirst(sizei, x);
				n -= sizei;
			}
			it++;//去到下一个子树
		}
	}
	void treeLast(int n, vector<string>* x) {//后五个
		int size = children.size();
		map<string, dir*>::iterator it = children.end();//从最后一个开始
		while (size--) {
			it--;//来到最后一个
			int sizei = it->second->size;
			if (sizei >= n) {
				it->second->treeLast(n, x);
				return;
			}
			else {
				it->second->treeLast(sizei, x);
				n -= sizei;
			}
		}
		x->push_back(name);//最后一个先加入
	}
};
void solve(){
	long long n;
	cin>>n;
	dir* now = new dir("root", NULL);
	vector<command*>cmdlist;
	for (int i = 0; i < n; i++){
		cin>>tmp;
		string str = tmp;
		command* cmd = new command(str);
		switch (cmd->type){
		case 0:{
			cmd->target_dir = now->mkdir(cmd->argu);
			if (cmd->target_dir == NULL)cout << "ERR" << endl;
			else{
				cout << "OK" << endl;
				cmdlist.push_back(cmd);
			}
			break;
		}
		case 1:{
			cmd->target_dir = now->rm(cmd->argu);
			if (cmd->target_dir == NULL)cout << "ERR" << endl;
			else{
				cout << "OK" << endl;
				cmdlist.push_back(cmd);
			}
			break; 
		}
		case 2: {
			dir* te = now->cd(cmd->argu);
			if (te == NULL)cout << "ERR" << endl;
			else {
				cout << "OK" << endl;
				cmd->target_dir = now;
				now = te;
				cmdlist.push_back(cmd);
			}
			break; 
		}
		case 3:now->sz(); break;
		case 4:now->ls(); break;
		case 5:now->tree(); break;
		case 6: {
			bool flag = false;
			if (!cmdlist.empty()){
				cmd = cmdlist.back(); cmdlist.pop_back();
				switch (cmd->type){
					case 0:  //undo mkdir
						if (now->rm(cmd->target_dir->name) != NULL)flag = true; break;
					case 1:  //undo rm
						if (now->addchild(cmd->target_dir) != NULL)flag = true; break;
					case 2: //undo cd
						now = cmd->target_dir; flag = true; break;
				}
			}
			if (flag)cout<<"OK"<<endl; 
			else cout<<"ERR"<<endl;
		}
		}
	}
}
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

思路

与之前打牌类似，不过这次逻辑要更清晰也更简单些（但是偏偏在这题上wa吐了，真的是吐了）；根据规定的大小规则，为每种牌（结构体）定义四种rank，来规定其大小，并在不同的层级之上进行比较。

Answer

这是原版代码，死都不知道哪不对，感觉算法很妙，只需要不到一百行，但就是wa，实在检查不出来哪的问题

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn = 1e6 + 100;
int n;
struct node {
	string s;//名字
	int rank1 = 0, rank2 = 0, rank3 = 0, rank4 = 0;//用来标记不同层级的排名
	int one[5] = { 0 }, two[2] = { 0 }, three = 0, four = 0;//标记某大小的牌的总数，two最多只需要两个，three和four只需要一个
	bool operator < (const node p)const {
		if (rank1 != p.rank1)return rank1 < p.rank1;
		else if (rank2 != p.rank2)return rank2 < p.rank2;
		else if (rank3 != p.rank3)return rank3 < p.rank3;
		else if (rank4 != p.rank4)return rank4 < p.rank4;
		else if (s.compare(p.s) == 1)return 1;//字典序更大者更小
		else return 0;
	}
}a[maxn];
void init(int i) {
	a[i].rank1 = 0, a[i].rank2 = 0, a[i].rank3 = 0, a[i].rank4 = 0;
	memset(a[i].one, 0, sizeof(a[i].one));
	memset(a[i].two, 0, sizeof(a[i].two));
	a[i].three = 0, a[i].four = 0;
}
int main() {
	while (cin >> n) {
		for (int i = 1; i <= n; i++) {
			init(i);
			cin >> a[i].s;
			int c[14] = { 0 };//标记13种大小的牌的数量
			for (int j = 1; j <= 5; j++) {
				char x;
				cin >> x;
				if (x == 'A')c[1]++;
				if (x >= '2' && x <= '9')c[x - 48]++;
				if (x == '1')c[10]++, getchar();//若为1则吞掉后面的0，即10
				if (x == 'J')c[11]++;
				if (x == 'Q')c[12]++;
				if (x == 'K')c[13]++;
			}
			int x = 0, y = 0;
			for (int j = 1; j <= 13; j++) {//遍历所有13个大小的牌，记录一张，两张。。。的张数及位置
				if (c[j] == 1)a[i].one[x++] = j;
				if (c[j] == 2)a[i].two[y++] = j;
				if (c[j] == 3)a[i].three = j;
				if (c[j] == 4)a[i].four = j;
				if (c[j] == 5)a[i].four = j,a[i].one[0]=j;
			}
			if (x == 5) {//不同的牌有五张
				//sort(a[i].one, a[i].one + 5);
				if (a[i].one[0] == 1 && a[i].one[1] == 10) {
					a[i].rank1 = 8;
					a[i].rank2 = 0;
					a[i].rank3 = 0;
					a[i].rank4 = 0;
				}
				if (a[i].one[4] - a[i].one[0] == 4) {
					a[i].rank1 = 7;
					a[i].rank2 = a[i].one[4];
					a[i].rank3 = 0;
					a[i].rank4 = 0;
				}
			}
			else if (a[i].four > 0) {//有炸
				a[i].rank1 = 6;
				a[i].rank2 = a[i].four;
				a[i].rank3 = a[i].one[0];
				a[i].rank4 = 0;
			}
			else if (a[i].three > 0) {//有三张
				if (a[i].two[0] > 0) {
					a[i].rank1 = 5;
					a[i].rank2 = a[i].three;
					a[i].rank3 = a[i].two[0];
					a[i].rank4 = 0;
				}
				else {
					a[i].rank1 = 4;
					a[i].rank2 = a[i].three;
					a[i].rank3 = a[i].one[0] + a[i].one[1];
					a[i].rank4 = 0;
				}
			}
			else if (a[i].two[1] > 0) {//有两个两张
				a[i].rank1 = 3;
				a[i].rank2 = a[i].two[1];
				a[i].rank3 = a[i].two[0];
				a[i].rank4 = a[i].one[0];
			}
			else if (a[i].two[0] > 0) {//只有一个两张
				a[i].rank1 = 2;
				a[i].rank2 = a[i].two[0];
				a[i].rank3 = a[i].one[0] + a[i].one[1] + a[i].one[2];
				a[i].rank4 = 0;
			}
			else {//大牌
				a[i].rank1 = 1;
				a[i].rank2 = a[i].one[0] + a[i].one[1] + a[i].one[2] + a[i].one[3] + a[i].one[4];
				a[i].rank3 = 0;
				a[i].rank4 = 0;
			}
		}
		sort(a + 1, a + n + 1);//升序排名，所以倒序输出 
		for (int i = n; i >= 1; i--)cout << a[i].s << endl;
	}
	return 0;
}

重写代码：

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
const int maxn=1e6+100;
string ss;
struct node{
	string s;
	int c[5],rank1,rank2,rank3,rank4;
	bool operator<(const node&p){
		if(rank1!=p.rank1)return rank1>p.rank1;
		if(rank2!=p.rank2)return rank2>p.rank2;
		if(rank3!=p.rank3)return rank3>p.rank3;
		if(rank4!=p.rank4)return rank4>p.rank4;
		return s<p.s;
	}
}a[maxn];

int main() {
	int n;
	while(cin>>n){
		for(int i=1;i<=n;i++){
			cin>>a[i].s>>ss;
			for(int j=0,k=0;j<5;j++,k++){
				if(ss[k]=='A')a[i].c[j]=1;
				if(ss[k]>='2'&&ss[k]<='9')a[i].c[j]=ss[k]-48; 
				if(ss[k]=='1')a[i].c[j]=10,k++;
				if(ss[k]=='J')a[i].c[j]=11;
				if(ss[k]=='Q')a[i].c[j]=12;
				if(ss[k]=='K')a[i].c[j]=13;			
			}
			sort(a[i].c,a[i].c+5);
			if(a[i].c[0]==1&&a[i].c[1]==10&&a[i].c[2]==11&&a[i].c[3]==12&&a[i].c[4]==13){
				a[i].rank1=8;a[i].rank2=0;
				a[i].rank3=0;a[i].rank4=0;
			}
			else if(a[i].c[0]+1==a[i].c[1]&&a[i].c[1]+1==a[i].c[2]&&a[i].c[2]+1==a[i].c[3]&&a[i].c[3]+1==a[i].c[4]){
				a[i].rank1=7;a[i].rank2=a[i].c[4];
				a[i].rank3=0;a[i].rank4=0;
			}
			else if(a[i].c[0]==a[i].c[3]){
				a[i].rank1=6;a[i].rank2=a[i].c[1];
				a[i].rank3=a[i].c[4];a[i].rank4=0;
			}
			else if(a[i].c[1]==a[i].c[4]){
				a[i].rank1=6;a[i].rank2=a[i].c[1];
				a[i].rank3=a[i].c[0];a[i].rank4=0;
			}
			else if(a[i].c[0]==a[i].c[2]&&a[i].c[3]==a[i].c[4]){
				a[i].rank1=5;a[i].rank2=a[i].c[2];
				a[i].rank3=a[i].c[3];a[i].rank4=0;
			}
			else if(a[i].c[0]==a[i].c[1]&&a[i].c[2]==a[i].c[4]){
				a[i].rank1=5;a[i].rank2=a[i].c[2];
				a[i].rank3=a[i].c[0];a[i].rank4=0;
			}
			else if(a[i].c[0]==a[i].c[2]){
				a[i].rank1=4;a[i].rank2=a[i].c[2];
				a[i].rank3=a[i].c[3]+a[i].c[4];
				a[i].rank4=0;
			}
			else if(a[i].c[1]==a[i].c[3]){
				a[i].rank1=4;a[i].rank2=a[i].c[2];
				a[i].rank3=a[i].c[0]+a[i].c[4];
				a[i].rank4=0;
			}
			else if(a[i].c[2]==a[i].c[4]){
				a[i].rank1=4;a[i].rank2=a[i].c[2];
				a[i].rank3=a[i].c[0]+a[i].c[1];
				a[i].rank4=0;
			}
			else if(a[i].c[0]==a[i].c[1]&&a[i].c[2]==a[i].c[3]){
				a[i].rank1=3;a[i].rank2=a[i].c[3];
				a[i].rank3=a[i].c[0];
				a[i].rank4=a[i].c[4];
			}
			else if(a[i].c[0]==a[i].c[1]&&a[i].c[3]==a[i].c[4]){
				a[i].rank1=3;a[i].rank2=a[i].c[3];
				a[i].rank3=a[i].c[0];
				a[i].rank4=a[i].c[2];
			}
			else if(a[i].c[1]==a[i].c[2]&&a[i].c[3]==a[i].c[4]){
				a[i].rank1=3;a[i].rank2=a[i].c[3];
				a[i].rank3=a[i].c[1];
				a[i].rank4=a[i].c[0];
			}
			else if(a[i].c[0]==a[i].c[1]){
				a[i].rank1=2,a[i].rank2=a[i].c[0];
				a[i].rank3=a[i].c[2]+a[i].c[3]+a[i].c[4];
				a[i].rank4=0;
			}
			else if(a[i].c[1]==a[i].c[2]){
				a[i].rank1=2;
				a[i].rank2=a[i].c[1];
				a[i].rank3=a[i].c[0]+a[i].c[3]+a[i].c[4];
				a[i].rank4=0;
			}
			else if(a[i].c[2]==a[i].c[3]){
				a[i].rank1=2;
				a[i].rank2=a[i].c[2];
				a[i].rank3=a[i].c[0]+a[i].c[1]+a[i].c[4];
				a[i].rank4=0;
			}
			else if(a[i].c[3]==a[i].c[4]){
				a[i].rank1=2;
				a[i].rank2=a[i].c[3];
				a[i].rank3=a[i].c[0]+a[i].c[1]+a[i].c[2];
				a[i].rank4=0;
			}
			else{
				a[i].rank1=1;
				a[i].rank2=a[i].c[0]+a[i].c[1]+a[i].c[2]+a[i].c[3]+a[i].c[4];
				a[i].rank3=0;
				a[i].rank4=0;
			}
		} 
		sort(a+1,a+n+1);
		for(int i=1;i<=n;i++)
			cout<<a[i].s<<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

思路

整一个最大堆一个最小堆来回弹压即可

Answer

具体思路见注释

#include<iostream>
#include<string.h>
#include<queue>
#include<functional>
using namespace std;
const int maxn =1e6+100;
int x,y,t,Qtop,qtop,qqtop;
priority_queue<int> Q;
priority_queue<int,vector<int>,greater<int> > q;
priority_queue<int> qq;
int main(){
	cin>>x>>y;
	while(x--){
		cin>>t;
		Q.push(t);
		q.push(t);
	}
	Qtop=Q.top();
	Q.pop();
	Qtop+=y;
	Q.push(Qtop);
	while(y--){
		qtop=q.top();
		q.pop();
		qtop++;
		q.push(qtop);
	}
	while(!q.empty()){
		qtop=q.top();
		q.pop();
		qq.push(qtop);
	}
	qqtop=qq.top();
	cout<<qqtop<<" "<<Qtop;
	return 0;
}

Maroon°

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Program week9 work

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

扫一扫