【POJ C++题目】魔兽世界之二：装备

Mount256

于 2020-08-02 12:35:32 发布

阅读量590

点赞数

分类专栏： C/C++ 文章标签： c++ 算法数据结构

本文章为作者原创，未经许可禁止转载。

本文链接：https://blog.csdn.net/baidu_39514357/article/details/107742172

版权

C/C++ 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

文章目录

一、题目描述

描述

魔兽世界的西面是红魔军的司令部，东面是蓝魔军的司令部。两个司令部之间是依次排列的若干城市。

红司令部，City 1，City 2，……，City n，蓝司令部

两军的司令部都会制造武士。武士一共有 dragon 、ninja、iceman、lion、wolf 五种。每种武士都有编号、生命值这两种属性。
有的武士可以拥有武器。武器有三种，sword, bomb,和arrow，编号分别为0,1,2。
双方的武士编号都是从1开始计算。红方制造出来的第 n 个武士，编号就是n。同样，蓝方制造出来的第 n 个武士，编号也是n。

不同的武士有不同的特点。
dragon 可以拥有一件武器。编号为n的dragon降生时即获得编号为 n%3 的武器。dragon还有“士气”这个属性，是个浮点数，其值为它降生后其司令部剩余生命元的数量除以造dragon所需的生命元数量。
ninja可以拥有两件武器。编号为n的ninja降生时即获得编号为 n%3 和 (n+1)%3的武器。
iceman有一件武器。编号为n的iceman降生时即获得编号为 n%3 的武器。
lion 有“忠诚度”这个属性，其值等于它降生后其司令部剩余生命元的数目。
wolf没特点。
请注意，在以后的题目里，武士的士气，生命值，忠诚度在其生存期间都可能发生变化，都有作用，武士手中的武器随着使用攻击力也会发生变化。

武士在刚降生的时候有一个生命值。

在每个整点，双方的司令部中各有一个武士降生。

红方司令部按照 iceman、lion、wolf、ninja、dragon 的顺序循环制造武士。

蓝方司令部按照 lion、dragon、ninja、iceman、wolf 的顺序循环制造武士。

制造武士需要生命元。

制造一个初始生命值为 m 的武士，司令部中的生命元就要减少 m 个。

如果司令部中的生命元不足以制造某个按顺序应该制造的武士，那么司令部就试图制造下一个。如果所有武士都不能制造了，则司令部停止制造武士。
给定一个时间，和双方司令部的初始生命元数目，要求你将从0点0分开始到双方司令部停止制造武士为止的所有事件按顺序输出。
一共有两种事件，其对应的输出样例如下：

武士降生
输出样例： 004 blue lion 5 born with strength 5,2 lion in red headquarter
表示在 4点整，编号为5的蓝魔lion武士降生，它降生时生命值为5,降生后蓝魔司令部里共有2个lion武士。(为简单起见，不考虑单词的复数形式)注意，每制造出一个新的武士，都要输出此时司令部里共有多少个该种武士。
如果造出的是dragon，那么还要输出一行，例：
It has a arrow,and it’s morale is 23.34
表示该dragon降生时得到了arrow,其士气是23.34（为简单起见，本题中arrow前面的冠词用a,不用an，士气精确到小数点后面2位，四舍五入）
如果造出的是ninja，那么还要输出一行，例：
It has a bomb and a arrow
表示该ninja降生时得到了bomb和arrow。
如果造出的是iceman，那么还要输出一行，例：
It has a sword
表示该iceman降生时得到了sword。
如果造出的是lion，那么还要输出一行，例：
It’s loyalty is 24
表示该lion降生时的忠诚度是24。
司令部停止制造武士
输出样例： 010 red headquarter stops making warriors
表示在 10点整，红方司令部停止制造武士

输出事件时：

首先按时间顺序输出；

同一时间发生的事件，先输出红司令部的，再输出蓝司令部的。

输入

第一行是一个整数,代表测试数据组数。

每组测试数据共两行。

第一行，一个整数M。其含义为：每个司令部一开始都有M个生命元( 1 <= M <= 10000)

第二行：五个整数，依次是 dragon 、ninja、iceman、lion、wolf 的初始生命值。它们都大于0小于等于10000

样例：

1
20
3 4 5 6 7

输出

对每组测试数据，要求输出从0时0分开始，到双方司令部都停止制造武士为止的所有事件。
对每组测试数据，首先输出“Case:n" n是测试数据的编号，从1开始
接下来按恰当的顺序和格式输出所有事件。每个事件都以事件发生的时间开头，时间以小时为单位，有三位。
样例：

Case:1
000 red iceman 1 born with strength 5,1 iceman in red headquarter
It has a bomb
000 blue lion 1 born with strength 6,1 lion in blue headquarter
It's loyalty is 14
001 red lion 2 born with strength 6,1 lion in red headquarter
It's loyalty is 9
001 blue dragon 2 born with strength 3,1 dragon in blue headquarter
It has a arrow,and it's morale is 3.67
002 red wolf 3 born with strength 7,1 wolf in red headquarter
002 blue ninja 3 born with strength 4,1 ninja in blue headquarter
It has a sword and a bomb
003 red headquarter stops making warriors
003 blue iceman 4 born with strength 5,1 iceman in blue headquarter
It has a bomb
004 blue headquarter stops making warriors

二、简要思路

在写这个程序之前，我把先前的代码重新改造了一下（请看上一篇本人的博文）。在先前的代码中，我在主函数定义了一个基类指针数组，并以此在之后制造武士的过程中运用多态，通过记录武士出场顺序的数组作为下标来访问该指针数组，这样就不用专门写一个switch分支语句来判断输出的是什么武士。这样做的好处是可以简化代码。

但是在这个程序中，我打算在Command类里用一个myWarrior的基类指针数组来存储每一个成功生成的武士，因此主函数的基类指针数组其实是多此一举的，我定义了一个p数组，这个数组按照武士默认顺序记录了每种武士的生命值，这样，我通过记录武士出场顺序的数组作为下标来访问该数组，这样做显然比先前的效率更高，也更符合逻辑。

好，我们来理一理思路，我们以红司令部作为例子，其实是这个样子的：
在这里插入图片描述
上面的图片展示了默认顺序、记录每种武士的生命值的数组p以及记录红司令部武士们的生成顺序的数组Order。我们用OrderCount来作为循环变量，比如当OrderCount=1时，那么就可以访问redOrder[OrderCount]，即redOrder[1]=3，这个3告诉我们第一个生成的应该是iceman，好，我们再去访问iceman对应的生命值，为5，这样就能进行后续比较、生成操作了。对，就是下面这个过程：
在这里插入图片描述
在Warrior基类派生出五种武士类，它们的构造函数将直接输出生成信息，以及武器信息、士气信息和忠诚度信息，这也意味着我要写五遍这样类似的代码，而且需要将司令部的各种信息作为这些构造函数的形参，例如：

Dragon(int _No, const int _HP, string belong, const double CommandHP, int WarriorKindNumber);
    //这些参数从左到右依次是：武士编号，武士生命值，武士所属司令部（字符串），
	//武士所属司令部剩余生命元 ，武士所属司令部中同种类武士数量

虽然有点麻烦，但是这样写显然是更符合逻辑的。写完这个程序之后我专门到网上查找了其他人的代码，发现基本都是写在了司令部类的成员函数里，这显然不符合逻辑。我写这个题目其实不是为了拿个通过码，可能他们只是想快点AC吧。

我这样写又有一个好处：代码的逻辑性增强了，而且司令部的制造武士函数也不用那么复杂了，直接调用一个构造函数就搞定了结果的输出。

好了废话不多说，上代码。

三、初步代码

温馨提示：本代码不能作为答案直接贴在评测系统上，因为输出结果跟题目要求是不一样的！

#include <iostream>
#include <string>
#include <iomanip>
#include <ctime>
using namespace std;
const int WARRIOR_NUM = 5;
const int WEAPON_NUM = 2;
enum warrior{total=0, dragon, ninja, iceman, lion, wolf};
//1dragon 2ninja 3iceman 4lion 5wolf 
//0sword 1bomb 2arrow

//No.0
class Warrior{
	protected:
		int No;
		int HP;
		short WeaponHP[WEAPON_NUM+1];
		string Name;
	public:
		friend class Command;
		virtual string CreateWeapon(int No);
};

string Warrior::CreateWeapon(int _No)
{
	_No = _No % 3;
	switch(_No)
	{
		case 0: WeaponHP[0]=1; return "sword"; break;
		case 1: WeaponHP[1]=1; return "bomb"; break;
		case 2: WeaponHP[2]=1; return "arrow"; break;
		default: break;
	}
}

//No.1
class Dragon:public Warrior{
	private:
		double Morale;
	public:
		Dragon(int _No, const int _HP, string belong, const double CommandHP, int WarriorKindNumber);
    //这些参数从左到右依次是：武士编号，武士生命值，武士所属司令部（字符串），
	//武士所属司令部剩余生命元 ，武士所属司令部中同种类武士数量 ，下同 
};

Dragon::Dragon(int _No, const int _HP, string belong, const double CommandHP, int WarriorKindNumber)
{
	No=_No; HP=_HP; Name="dragon"; 
	Morale = CommandHP/HP; 
	cout<<belong<<" "<<this->Name<<" "<<this->No<<" born with strength "<<this->HP<<", ";
	cout<<WarriorKindNumber<<" "<<this->Name<<" in "<<belong<<" headquarter, ";
	cout<<"rest HP = "<<(int)CommandHP<<endl;
	cout<<"It has a "<<this->CreateWeapon(No)<<", and it's morale is "<<setiosflags(ios::fixed)<<setprecision(2)<<Morale<<endl;
}

//No.2
class Ninja:public Warrior{
	public:
		Ninja(int _No, const int _HP, string belong, const int CommandHP, int WarriorKindNumber);
};

Ninja::Ninja(int _No, const int _HP, string belong, const int CommandHP, int WarriorKindNumber)
{
	No=_No; HP=_HP; Name="ninja"; 
	cout<<belong<<" "<<this->Name<<" "<<this->No<<" born with strength "<<this->HP<<", ";
	cout<<WarriorKindNumber<<" "<<this->Name<<" in "<<belong<<" headquarter, ";
	cout<<"rest HP = "<<CommandHP<<endl;
	cout<<"It has a "<<this->CreateWeapon(No)<<" and a "<<this->CreateWeapon(No+1)<<endl;
}

//No.3
class Iceman:public Warrior{
	public:
		Iceman(int _No, const int _HP, string belong, const int CommandHP, int WarriorKindNumber);
};

Iceman::Iceman(int _No, const int _HP, string belong, const int CommandHP, int WarriorKindNumber)
{
	No=_No; HP=_HP; Name="iceman"; 
	cout<<belong<<" "<<this->Name<<" "<<this->No<<" born with strength "<<this->HP<<", ";
	cout<<WarriorKindNumber<<" "<<this->Name<<" in "<<belong<<" headquarter, ";
	cout<<"rest HP = "<<CommandHP<<endl;
	cout<<"It has a "<<this->CreateWeapon(No)<<endl;
}

//No.4
class Lion:public Warrior{
	private:
		int Loyalty;
	public:
		Lion(int _No, const int _HP, string belong, const int CommandHP, int WarriorKindNumber);
};

Lion::Lion(int _No, const int _HP, string belong, const int CommandHP, int WarriorKindNumber)
{
	No=_No; HP=_HP; Name="lion"; Loyalty=CommandHP;
	cout<<belong<<" "<<this->Name<<" "<<this->No<<" born with strength "<<this->HP<<", ";
	cout<<WarriorKindNumber<<" "<<this->Name<<" in "<<belong<<" headquarter, ";
	cout<<"rest HP = "<<CommandHP<<endl;
	cout<<"It's loyalty is "<<Loyalty<<endl;
}

//No.5
class Wolf:public Warrior{
	public:
		Wolf(int _No, const int _HP, string belong, const int CommandHP, int WarriorKindNumber);
};

Wolf::Wolf(int _No, const int _HP, string belong, const int CommandHP, int WarriorKindNumber)
{
	No=_No; HP=_HP; Name="wolf"; 
	cout<<belong<<" "<<this->Name<<" "<<this->No<<" born with strength "<<this->HP<<", ";
	cout<<WarriorKindNumber<<" "<<this->Name<<" in "<<belong<<" headquarter, ";
	cout<<"rest HP = "<<CommandHP<<endl;
}

//====================================================
class Command{
	private:
		string Name;
		short OrderCount;//循环遍历武士顺序数组 
		int HP;
		int WarriorNumber[WARRIOR_NUM+1];//记录总数以及每个武士的数量 ,下标为0的元素存储总数 
		Warrior *myWarrior[200]; //指向每一个成功生成的武士 
	public:
		static int time;//游戏系统时间 
		short Order[WARRIOR_NUM+1];//制造武士的顺序记录，即武士顺序数组 
		Command(string _Name, const short _Order[], const int _HP);
		~Command();
		bool CreateWarrior(short p[]);
		void StopCreateWarrior();
};
int Command::time = -1;//静态成员变量必须进行初始化 

Command::Command(string _Name, const short _Order[], const int _HP):Name(_Name), HP(_HP) 
{ 
	OrderCount = 1;
	for(int i=0; i<=WARRIOR_NUM; i++) //这里做的工作是复制+初始化 
	{
		Order[i] = _Order[i];
		WarriorNumber[i] = 0;
	}
}

Command::~Command()
{
	while(WarriorNumber[total]) //内存释放很重要，别忘了 
	{
		delete myWarrior[WarriorNumber[total]];
		WarriorNumber[total]--;
	}
}

bool Command::CreateWarrior(short p[])
{
	if( HP<p[1] && HP<p[2] && HP<p[3] && HP<p[4] && HP<p[5] ) return 0;
	while(HP < p[Order[OrderCount]])
	{
			OrderCount++;
			if(OrderCount==WARRIOR_NUM+1) OrderCount=1;
	}
	short ord = Order[OrderCount];
	WarriorNumber[total]++;
	WarriorNumber[ord]++;
	HP -= p[ord];
	short No = WarriorNumber[total];
	cout<<setw(3)<<setfill('0')<<time<<" "; 
	switch(ord)
	{
		case 1: myWarrior[No]=new Dragon(No, p[1], Name, (double)HP, WarriorNumber[ord]); break;
		case 2: myWarrior[No]=new Ninja(No, p[2], Name, HP, WarriorNumber[ord]); break;
		case 3: myWarrior[No]=new Iceman(No, p[3], Name, HP, WarriorNumber[ord]); break;
		case 4: myWarrior[No]=new Lion(No, p[4], Name, HP, WarriorNumber[ord]); break;
		case 5: myWarrior[No]=new Wolf(No, p[5], Name, HP, WarriorNumber[ord]); break;
		default：break;
	}
	OrderCount++;
	if(OrderCount == WARRIOR_NUM+1) OrderCount=1;
	return 1;
}

void Command::StopCreateWarrior()
{
	cout<<setw(3)<<setfill('0')<<time<<" "<<this->Name<<" headquarter stops making warriors"<<endl;
}

int main()
{
	int n=1;
	short redOrder[WARRIOR_NUM+1]={0, iceman, lion, wolf, ninja, dragon};
	short blueOrder[WARRIOR_NUM+1]={0, lion, dragon, ninja, iceman, wolf};
	short M, dm, nm, im, lm, wm;
	clock_t startTime, endTime;
	//cin>>n;
	while(n--)
	{
		cin>>M;//输入司令部生命元 
		cin>>dm>>nm>>im>>lm>>wm;//输入每种武士的生命值 
		startTime = clock();
		Command red("red", redOrder, M), blue("blue", blueOrder, M);
		short p[WARRIOR_NUM+1] = {0, dm, nm, im, lm, wm}; //用数组存储每种武士的生命值 
		bool redCreate = 1, blueCreate = 1;//记录司令部是否能进行制造武士，1表示可以，0则相反 
		Command::time = -1;
		while(redCreate || blueCreate)//开始制造武士 
		{
			Command::time ++;//系统时间加1
			//制造武士的函数既可以完成制造任务，又可以返回制造情况：返回1表示制造成功，
			//而返回0则说明一个都制造不了， 同时还要使布尔变量red(blue)Create变成0 
			if(redCreate == 1 && red.CreateWarrior(p) == 0){redCreate = 0; red.StopCreateWarrior();} 
			if(blueCreate == 1 && blue.CreateWarrior(p) == 0){blueCreate = 0; blue.StopCreateWarrior();} 
			cout<<endl;
		}
	}
	endTime = clock();
	cout<<"time:"<<(double)(endTime - startTime) <<"ms"<<endl;
	return 0;
}

输入：

60
3 4 5 6 7

输出：

000 red iceman 1 born with strength 5, 1 iceman in red headquarter, rest HP = 55
It has a bomb
000 blue lion 1 born with strength 6, 1 lion in blue headquarter, rest HP = 54
It's loyalty is 54

001 red lion 2 born with strength 6, 1 lion in red headquarter, rest HP = 49
It's loyalty is 49
001 blue dragon 2 born with strength 3, 1 dragon in blue headquarter, rest HP = 51
It has a arrow, and it's morale is 17

002 red wolf 3 born with strength 7, 1 wolf in red headquarter, rest HP = 42
002 blue ninja 3 born with strength 4, 1 ninja in blue headquarter, rest HP = 47
It has a sword and a bomb

003 red ninja 4 born with strength 4, 1 ninja in red headquarter, rest HP = 38
It has a bomb and a arrow
003 blue iceman 4 born with strength 5, 1 iceman in blue headquarter, rest HP = 42
It has a bomb

004 red dragon 5 born with strength 3, 1 dragon in red headquarter, rest HP = 35
It has a arrow, and it's morale is 11.67
004 blue wolf 5 born with strength 7, 1 wolf in blue headquarter, rest HP = 35

005 red iceman 6 born with strength 5, 2 iceman in red headquarter, rest HP = 30
It has a sword
005 blue lion 6 born with strength 6, 2 lion in blue headquarter, rest HP = 29
It's loyalty is 29

006 red lion 7 born with strength 6, 2 lion in red headquarter, rest HP = 24
It's loyalty is 24
006 blue dragon 7 born with strength 3, 2 dragon in blue headquarter, rest HP = 26
It has a bomb, and it's morale is 8.67

007 red wolf 8 born with strength 7, 2 wolf in red headquarter, rest HP = 17
007 blue ninja 8 born with strength 4, 2 ninja in blue headquarter, rest HP = 22
It has a arrow and a sword

008 red ninja 9 born with strength 4, 2 ninja in red headquarter, rest HP = 13
It has a sword and a bomb
008 blue iceman 9 born with strength 5, 2 iceman in blue headquarter, rest HP = 17
It has a sword

009 red dragon 10 born with strength 3, 2 dragon in red headquarter, rest HP = 10
It has a bomb, and it's morale is 3.33
009 blue wolf 10 born with strength 7, 2 wolf in blue headquarter, rest HP = 10

010 red iceman 11 born with strength 5, 3 iceman in red headquarter, rest HP = 5
It has a arrow
010 blue lion 11 born with strength 6, 3 lion in blue headquarter, rest HP = 4
It's loyalty is 4

011 red ninja 12 born with strength 4, 3 ninja in red headquarter, rest HP = 1
It has a sword and a bomb
011 blue dragon 12 born with strength 3, 3 dragon in blue headquarter, rest HP = 1
It has a sword, and it's morale is 0.33

012 red headquarter stops making warriors
012 blue headquarter stops making warriors

time:724.00ms

运行时间比较长，其实是cout造成的。OK，本题目完结撒花。

Mount256

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
【POJ C++题目】魔兽世界之二：装备

文章目录一、题目描述描述输入输出二、简要思路三、初步代码一、题目描述描述魔兽世界的西面是红魔军的司令部，东面是蓝魔军的司令部。两个司令部之间是依次排列的若干城市。红司令部，City 1，City 2，……，City n，蓝司令部两军的司令部都会制造武士。武士一共有 dragon 、ninja、iceman、lion、wolf 五种。每种武士都有编号、生命值这两种属性。有的武士可以拥有武器。武器有三种，sword, bomb,和arrow，编号分别为0,1,2。双方的武士编号都是从1开始计算。红
复制链接

扫一扫