程序设计思维与实践 Week9 作业

最新推荐文章于 2024-04-29 10:54:56 发布

叭哒杏_vivila

最新推荐文章于 2024-04-29 10:54:56 发布

阅读量142

点赞数

分类专栏：程序设计

本文链接：https://blog.csdn.net/qq_44157558/article/details/105584720

版权

程序设计专栏收录该内容

28 篇文章 1 订阅

订阅专栏

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

思路

在这里插入图片描述
用这个来存储目录。
每次记录它的上级目录，保存当前的目录，并且存储其子目录。

缓存它的十个后代是便于已经询问过的目录在没有发生更改时，不必再次遍历，可以直接输出结果，节省时间。

每次执行MKDIR、RM、CD，若OK记录该命令，以便UNDO。

MKDIR创建目录时，可以直接搜索其子目录中是否存在该目录，不存在则添加，存在，则按要求输出。

RM删除某个目录时，先搜索判断该目录是否存在，存在则删除，不存在则按要求输出。

CD进入某个目录时，直接从当前目录的孩子目录中找到要进的目录，进入即可。需要注意CD …的情况，是返回上一级目录。

SZ直接返回treesize即可。

LS判断一下treesize的大小，等于0，则为空；小于10，直接遍历输出；大于10，用迭代器输出前五个和后五个。

TREE这个是最难的，先判断treesize大小，等于0，则为空；小于10，直接遍历整个目录输出；大于10，通过递归输出前五个和后五个。并保存。

UNDO判断上一个OK的操作是什么，进行反操作，即撤销即可。

出现的问题

在运行的时候，发现提示上述图片里面的tempten和parent没有进行初始化，在添加了初始化的代码后顺利通过。

代码

#include<iostream>
#include<algorithm>
#include<string.h>
#include<map>
#include<vector>
#include<cstring>
#include<string>
using namespace std;

/*A*/
string tempstr;

struct Directory
{
	string name;//当前目录的名字
	map<string, Directory*> children;//儿子
	Directory* parent;//记录上级目录
	int treesize;//子树大小

	vector<string>* tempten;//缓存10个后代
	bool updated;//懒惰处理，有没有发生更新

	Directory()
	{
		tempten = new vector<string>;
		this->updated = true;
		parent = new Directory();
	}

	Directory(string name, Directory* parent)
	{
		this->name = name;
		this->parent = parent;
		this->treesize = 1;
		tempten = new vector<string>;
	}

	bool addChild(Directory* ch)
	{
		if (children.find(ch->name) != children.end())
		{
			return false;
		}
		children[ch->name] = ch;
		maintain(+ch->treesize);
		return true;
	}

	Directory* getChild(string name)
	{
		auto it = children.find(name);
		if (it == children.end())
		{
			return NULL;
		}
		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)
	{
		auto it = children.find(name);
		if (it == children.end())
		{
			return NULL;
		}
		maintain(-1 * it->second->treesize);
		children.erase(it);
		return it->second;
	}

	Directory* cd(string name)
	{
		if (".." == name)
		{
			return this->parent;
		}
		return getChild(name);
	}

	void maintain(int delta)//维护子树大小
	{
		updated = true;

		treesize += delta;
		if (parent != NULL)
		{
			parent->maintain(delta);
		}


	}

	void sz()
	{
		cout << this->treesize << endl;
	}

	void ls()
	{
		int sz = children.size();
		if (sz == 0)
		{
			cout << "EMPTY" << endl;
		}
		else if (sz <= 10)
		{
			for (auto& entry : children)
			{
				cout << entry.first << endl;
			}
		}
		else
		{
			auto 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()
	{
		//cout << "44444444" << endl;

		if (treesize == 1)
		{
			cout << "EMPTY" << endl;
		}
		else if (treesize <= 10)
		{
			//cout << "2222222222" << endl;
			if (this->updated)
			{	
				tempten->clear();
				//cout << "-----------------" << endl;
				treeAll(tempten);
				//cout << "mmmmmmmmmmmmmmmmmmmmmmmmmmm" << endl;
				this->updated = false;
			}
			for (int i = 0; i < treesize; i++)
			{
				//cout << "*******************************" << endl;
				cout << tempten->at(i) << endl;
			}
		}
		else
		{
			//cout << "33333333" << endl;
			if (this->updated)
			{
				tempten->clear();
				treeFirst(5, tempten);//前五个
				treeLast(5, tempten);//后五个
				this->updated = false;
			}
			for (int i = 0; i < 5; i++)
			{
				cout << tempten->at(i).c_str() << endl;
			}
			cout << "..." << endl;
			for (int i = 9; i >= 5; i--)
			{
				cout << tempten->at(i).c_str() << endl;
			}
		}
	}

public:
	void treeAll(vector<string>* v)
	{
		v->push_back(name);
		for (auto& entry : children)
		{
			entry.second->treeAll(v);
		}

	}

	void treeFirst(int num, vector<string>* v)
	{
		//cout << "11111111111" << endl;
		v->push_back(name);
		if (--num == 0)
		{
			return;
		}
		int n = children.size();
		auto it = children.begin();
		while (n--)
		{
			int sts = it->second->treesize;
			if (sts >= num)
			{
				it->second->treeFirst(num, v);
				return;
			}
			else
			{
				it->second->treeFirst(sts, v);
				num -= sts;
			}

			it++;
		}
	}

	void treeLast(int num, vector<string>* v)
	{
		int n = children.size();
		auto it = children.end();
		while (n--)
		{
			it--;
			int sts = it->second->treesize;
			if (sts >= num)
			{
				it->second->treeLast(num, v);
				return;
			}
			else
			{
				it->second->treeLast(sts, v);
				num -= sts;
			}
		}

		v->push_back(name);
		
	}
};


struct command
{
	const string COMMAND_NAMES[7] = { "MKDIR","RM","CD","SZ","LS","TREE","UNDO" };

	int type;//命令的类型
	string arg;//命令的参数
	Directory* tempDir;//临时目录

	command(string str)
	{
		this->type = -1;

		for (int i = 0; i < 7; i++)
		{
			if (COMMAND_NAMES[i] == str)
			{
				this->type = i;
				if (i < 3)
				{
					cin >> tempstr;
					this->arg = tempstr;
				}
				return;
			}
		}

		//tempDir = new Directory();
	}
};




void solve()
{
	int n;
	cin >> n;
	//当前目录
	Directory* now = new Directory("root", NULL);
	vector<command*> cmdList;
	while (n--)
	{
		cin >> tempstr;
		command* cmd = new command(tempstr);
		switch (cmd->type)
		{
		case 0:
		{
			cmd->tempDir = now->mkdir(cmd->arg);//MKDIR
			if (cmd->tempDir == NULL)
			{
				cout << "ERR" << endl;
			}
			else
			{
				cout << "OK" << endl;
				cmdList.push_back(cmd); 
			}
			break;
		}
		case 1:
		{
			cmd->tempDir = now->rm(cmd->arg);//MKDIR
			if (cmd->tempDir == NULL)
			{
				cout << "ERR" << endl;
			}
			else
			{
				cout << "OK" << endl;
				cmdList.push_back(cmd);
			}
			break;
		}
		case 2:
		{
			Directory* ch = now->cd(cmd->arg);//CD
			if (ch == NULL)
			{
				cout << "ERR" << endl;
			}
			else
			{
				cout << "OK" << endl;
				cmd->tempDir = now;
				now = ch;
				cmdList.push_back(cmd);
			}
			break;
		}
		case 3:
			now->sz();//SZ
			break;
		case 4:
			now->ls();//LS
			break;
		case 5:
			now->tree();//TREE
			break;
		case 6:
		{
			bool success = false;//UNDO
			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->tempDir); break;
				case 2: now = cmd->tempDir; success = true; break;
				default:
					break;
				}
			}
			cout << (success ? "OK" : "ERR") << endl;
			break;
		}
			
		default:
			break;
		}
	}
}



int main()
{

	int T;
	cin >> T;
	while (T--)
	{
		solve();
	}
	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 张牌不同，其值不同。下面依次列举了这手牌的形成规则：

大牌：这手牌不符合下面任一个形成规则。如果 α 和 β 都是大牌，那么定义它们的大小为组成这手牌的 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

思路

定义一个结构体，来记录每个玩家的信息。

struct player
{
	string name;//人名
	string cards;//五张牌
	int type;//牌的类型
	int first;//1.0、2.对子的值、3.大对子的值、4."三个"的值、5."三个"的值、6.炸弹的值、7.0、8.0
	int second;//1.0、2.0、3.小对子的值、4.0、5.对子的值、6.0、7.0、8.0
	int value;//1.大牌的值、2.剩三张牌的总和、3.最后一张牌、4.剩2张牌的和、5.0、6.最后一张牌、7.最大值、8.0

	player()
	{
		this->type = 0;
		this->first = 0;
		this->second = 0;
		this->value = 0;
	}

	player(string name, string cards)
	{
		this->name = name;
		this->cards = cards;
		this->type = 0;
		this->first = 0;
		this->second = 0;
		this->value = 0;
	}
};

处理每个玩家手里的牌。
将其牌面都转化为整数。

考虑牌面大小为10的情况。由于没有牌面为1 的牌，因此一旦字符串中出现1，就是出现了10.
统计玩家手中的五张牌的种类asize以及每种的牌面大小及其出现的次数。

统计完成后，按照其出现的次数进行降序排序，按照牌面大小升序排序。

对题中的8中情况进行分析。

asize=5时：

是龙顺：即出现的次数均为1，并且牌面为1，10，11，12，13
是顺子：即出现的次数均为1，并且牌面+1=后一张牌。(注意：此时已经进行了排序)
是大牌：其他情况

asize=4时：
是对子，且只有一个对子。
asize=3时：

三个：一个出现次数为3，其他两个出现次数为1。
两对：有两个出现次数为2，另一个出现次数为1。此时注意一下，第二个次数为2的数是大对子，因为次数相同时，是按照牌面大小升序排序的。(第一次WA在了这个地方)

asize=2时：

炸弹：一个出现次数为4，另一个是1.
三带二：一个出现次数是3，另一个是2.

asize=1时：
是大牌

处理完之后，进行排序，输出名字即可。

代码

#include<iostream>
#include<algorithm>
#include<string.h>
#include<map>
#include<vector>
#include<cstring>
#include<string>
using namespace std;

struct player
{
	string name;//人名
	string cards;//五张牌
	int type;//牌的类型
	int first;//1.0、2.对子的值、3.大对子的值、4."三个"的值、5."三个"的值、6.炸弹的值、7.0、8.0
	int second;//1.0、2.0、3.小对子的值、4.0、5.对子的值、6.0、7.0、8.0
	int value;//1.大牌的值、2.剩三张牌的总和、3.最后一张牌、4.剩2张牌的和、5.0、6.最后一张牌、7.最大值、8.0

	player()
	{
		this->type = 0;
		this->first = 0;
		this->second = 0;
		this->value = 0;
	}

	player(string name, string cards)
	{
		this->name = name;
		this->cards = cards;
		this->type = 0;
		this->first = 0;
		this->second = 0;
		this->value = 0;
	}
};

int N;
player p[100010];

bool cmp(player& a, player& b)
{
	if (a.type != b.type)return a.type > b.type;
	else if (a.first != b.first)return a.first > b.first;
	else if (a.second != b.second)return a.second > b.second;
	else if (a.value != b.value)return a.value > b.value;
	else return a.name < b.name;
}

bool cmp2(pair<int, int>& a, pair<int, int>& b)
{
	if (a.second != b.second)return a.second > b.second;
	else return a.first < b.first;
}


int map1(char a)//牌面大小赋值
{
	if (a == '2')return 2;
	if (a == '3')return 3;
	if (a == '4')return 4;
	if (a == '5')return 5;
	if (a == '6')return 6;
	if (a == '7')return 7;
	if (a == '8')return 8;
	if (a == '9')return 9;
	if (a == 'J')return 11;
	if (a == 'Q')return 12;
	if (a == 'K')return 13;
	if (a == 'A')return 1;

}

void solve(player& a)
{
	vector<pair<int, int>> vec;
	int asize = a.cards.size();

	//分解a的cards
	for (int i = 0; i < asize; i++)
	{
		int flag = 0;
		int f;
		if (a.cards[i] == '1')
		{
			f = 10;
			i++;
		}
		else
		{
			f = map1(a.cards[i]);
		}

		for (int j = 0; j < (int)vec.size(); j++)
		{
			if (vec[j].first == f)
			{
				vec[j].second++;
				flag = 1;
				break;
			}
		}
		if (!flag)
		{
			vec.push_back(pair<int, int>(f, 1));
		}
	}

	asize = vec.size();
	sort(vec.begin(), vec.end(), cmp2);

	if (asize == 5)//有五种
	{
		//8.龙顺
		if (vec[0].first == 1 && vec[1].first == 10 && vec[2].first == 11 && vec[3].first == 12 && vec[4].first == 13)
	    {
			a.type = 8;
	    }
		else if (vec[0].first + 1 == vec[1].first && vec[1].first + 1 == vec[2].first && vec[2].first + 1 == vec[3].first && vec[3].first + 1 == vec[4].first)
		{//7.顺子
			a.type = 7;
			a.value = vec[4].first;
		}
		else
		{//1.大牌
			a.type = 1;
			a.value = vec[0].first + vec[1].first + vec[2].first + vec[3].first + vec[4].first;
		}

	}
	else if (asize == 4)//2.对子
	{
		a.type = 2;
		a.first = vec[0].first;
		a.value = vec[1].first + vec[2].first + vec[3].first;
	}
	else if (asize == 3)
	{
		//4.三个
		if (vec[0].second == 3 && vec[1].second == 1 && vec[2].second == 1)
		{
			a.type = 4;
			a.first = vec[0].first;
			a.value = vec[1].first + vec[2].first;
		}
		else if (vec[0].second == 2 && vec[1].second == 2 && vec[2].second == 1)
		{//3.两对
			a.type = 3;
			a.first = vec[1].first;//大对子
			a.second = vec[0].first;//小对子
			a.value = vec[2].first;
		}
	}
	else if (asize == 2)
	{
		//6.炸弹
		if (vec[0].second == 4 && vec[1].second == 1)
		{
			a.type = 6;
			a.first = vec[0].first;
			a.value = vec[1].first;
		}
		else if (vec[0].second == 3 && vec[1].second == 2)
		{//5.三带二
			a.type = 5;
			a.first = vec[0].first;
			a.second = vec[1].first;
		}
	}
	else
	{
		a.type = 1;
		a.value = 5 * vec[0].first;
	}
	


}

int main()
{
	cin >> N;
	int i = 0;
	for (; i < N; i++)
	{
		cin >> p[i].name;
		cin >> p[i].cards;
		solve(p[i]);
	}

	sort(p, p + i, cmp);
	for (int j = 0; j < i; j++)
	{
		cout << p[j].name << endl;
	}
}

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

思路

分析可以知道mx一定是初始椅子上最多的人数+后来来到公园的人数。
mn则稍微复杂一点。

考虑，mn是在将后来来到公园的y个人进行椅子上的分配后，每次选取人数最多的情况，在这么多情况中中的最少的人数。

什么时候才是最多的人中最少的人呢？

先得到初始时x个椅子上最多的人数maxa，算出每个椅子上的人数与maxa的差值，一定是个非正数。将这些差值相加，是其他椅子与人数最多的椅子相差的人数。

将y分配给这些椅子。如果椅子还没分配完，y已经没了，那么mn就是maxa。
如果y还有剩余，分配结束后，每个椅子上的人数都是maxa。
考虑将y个人平均分配在x个椅子上。

如果y%x==0，那么说明y个人刚好可以平均的分配在x个椅子上，每椅子上人数相同，那么mn=maxa+y/x。
如果y%x!=0，那么说明每次给x个椅子分配1个人，重复执行之后，最后一组的人数不足以分配x个椅子，那么mn=maxa+1+y/x。

代码

#include<iostream>
#include<algorithm>
using namespace std;

int main()
{
	int a[110];
	int x, y;
	cin >> x;
	cin >> y;
	int mn = 0;
	int mx = 0;
	int maxa = 0;
	for (int i = 0; i < x; i++)
	{
		cin >> a[i];
		if (a[i] > maxa)
		{
			maxa = a[i];
		}
	}
    mx = maxa + y;//得到mx

	int difference = 0;//记录a[i]与maxa的差的和，是个负数。
	for (int i = 0; i < x; i++)
	{
		difference += a[i] - maxa;
	}
	
	y += difference;

	if (y <= 0)
	{
		mn = maxa;
	}
	else
	{
		int value = 0;
		if (y % x == 0)
		{
			value = y / x;
		}
		else
		{
			value = y / x + 1;
		}

		mn = maxa + value;
	}

	cout << mn << " " << mx;
}

叭哒杏_vivila

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
程序设计思维与实践 Week9 作业

目录A- 咕咕东的目录管理器题面输入输出时空限制样例输入样例输出思路代码B - 东东学打牌题面输入输出样例输入样例输出思路代码C - 签到题InputOutputInput ExampleOutput Example样例解释思路代码A- 咕咕东的目录管理器题面咕咕东的雪梨电脑的操作系统在上个月受到宇宙射线的影响，时不时发生故障，他受不了了，想要写一个高效易用零bug的操作系统 —— 这工程量...
复制链接

扫一扫