1 20 3 4 5 6 7
Case:1 000 red iceman 1 born with strength 5,1 iceman in red headquarter 000 blue lion 1 born with strength 6,1 lion in blue headquarter 001 red lion 2 born with strength 6,1 lion in red headquarter 001 blue dragon 2 born with strength 3,1 dragon in blue headquarter 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 003 red headquarter stops making warriors 003 blue iceman 4 born with strength 5,1 iceman in blue headquarter 004 blue headquarter stops making warriors
这道题踩了无数的坑，错误的原因有如下：
1. 自己写的算法太乐色，之前调用了太多的次的构造函数和复制构造函数，然后time limit exceeded了，现在用了指针数组来指向士兵对象，这样就不用再调用构造和复制构造函数了。然后每个case中共有的东西（换句话说就是不用输入的数据）可以作为公共数值在循环外先赋值。
2. hp和strength是相等的，这个题目里没写……还以为是固定的
3. “如果司令部中的生命元不足以制造某个按顺序应该制造的武士，那么司令部就试图制造下一个。如果所有武士都不能制造了，则司令部停止制造武士。” 这个逻辑有很多细节要注意，我自己也实现的非常啰嗦，代码可读性非常差。
4. 这道题是没问题的，如果是出现了wrong answer， 一定是你自己的代码出了问题， 不要有自己的蜜汁自信
使用了派生类，是因为考虑到后面更为复杂的两题，所以为了增加一些代码的可扩充性。等有空了再继续改进代码……
#include <iostream>
#include <cstring>
#include <iomanip>
using namespace std;
const int Num_of_Type = 5;
//战士区
class warrior
{
protected:
char warrior_name[10];
int strength;
public:
int type_id;
int hp;
void GetHp(int hp1)
{
hp = hp1;
strength = hp1; //strength和hp相同，大坑
}
friend class headquarter;
};
class dragon:public warrior
{
private:
public:
dragon()
{
strcpy(warrior_name, "dragon");
strength = 0;
hp = 0;
type_id = 1;
}
};
class ninja:public warrior
{
private:
public:
ninja()
{
strcpy(warrior_name, "ninja");
strength = 0;
this->hp = hp;
type_id = 2;
}
};
class iceman:public warrior
{
private:
public:
iceman()
{
strcpy(warrior_name, "iceman");
strength = 0;
hp = 0;
type_id = 3;
}
};
class wolf:public warrior
{
public:
wolf()
{
strcpy(warrior_name, "wolf");
strength = 0;
hp = 0;
type_id = 4;
}
};
class lion:public warrior
{
private:
public:
lion()
{
strcpy(warrior_name, "lion");
strength = 0;
hp = 0;
type_id = 5;
}
};
//基地区
class headquarter
{
private:
int resource; //基地生命值
char name[10];
int num_of_warrior;
int round;
int waste; //记录
int num_of_each_warrior[Num_of_Type];
public:
warrior* order[Num_of_Type];
bool declared;
//构造函数
headquarter(const char a1[])
{
strcpy(name, a1);
resource = 0;
num_of_warrior = 0;
waste = 0;
declared = false;
for(int i = 0; i < Num_of_Type; i++)
{
num_of_each_warrior[i]= 0;
}
}
//获得资源值函数
void GetResourceAndReset(int m)
{
resource = m;
declared = false;
num_of_warrior = 0;
waste = 0;
for(int i = 0; i < Num_of_Type; i++)
{
num_of_each_warrior[i] = 0;
}
}
//造兵函数
void Produce(const int time)
{
round = (time+waste) % Num_of_Type;
for(int j = round; j < round + Num_of_Type; j++)
{
int real_round = j;
if(real_round >= Num_of_Type)
{
real_round -= Num_of_Type;
}
//找到了可以制造的士兵则结束循环
if(resource-order[real_round]->hp>=0){
waste += (j - round); //记录下循环了几次才找到要找的士兵，下次进入produce函数时需要加上这个数值
num_of_each_warrior[real_round]++;
num_of_warrior++;
resource -= order[real_round]->hp;
cout<< setw(3) << setfill('0') << time
<< " " << name <<" "<<order[real_round]->warrior_name<<" "
<< num_of_warrior <<" " << "born with strength "<<order[real_round]->strength
<<","<<num_of_each_warrior[real_round] <<" "<<order[real_round]->warrior_name <<" "<< "in" <<" "<<name
<<" headquarter"<<endl;
break;
}
}
}
bool Keepmaking(const int min_requirement, const int time)
{
if(resource < min_requirement){
declared = true;
cout<< setw(3) << setfill('0') << time <<" "<<name << " headquarter stops making warriors" << endl;
return false;
}
else
return true;
}
};
int main()
{
//数据录入
int test_set;
cin >> test_set;
int resource[test_set];
int hp[test_set][Num_of_Type];
for(int i = 0; i < test_set; i++)
{
cin >> resource[i];
for(int j = 0; j < Num_of_Type; j++)
{
cin >> hp[i][j];
}
}
int time = 0;
//初始化战士对象
dragon dragon1;
iceman iceman1;
ninja ninja1;
wolf wolf1;
lion lion1;
//初始化基地
headquarter red("red");
headquarter blue("blue");
//红色基地指针数组
red.order[0]=&iceman1;
red.order[1]=&lion1;
red.order[2]=&wolf1;
red.order[3]=&ninja1;
red.order[4]=&dragon1;
blue.order[0]=&lion1;
blue.order[1]=&dragon1;
blue.order[2]=&ninja1;
blue.order[3]=&iceman1;
blue.order[4]=&wolf1;
//case循环
for(int i = 0; i < test_set; i++)
{
cout << "Case:" << i+1 << endl;
//找到输入的hp的最小值，用来判断资源是否足够制造任何一个士兵
int min_requirement = 1000;
for(int j = 0; j < Num_of_Type; j++)
{
if(hp[i][j]<min_requirement){
min_requirement = hp[i][j];
}
}
//为基地的资源赋值
red.GetResourceAndReset(resource[i]);
blue.GetResourceAndReset(resource[i]);
//为战士的生命值赋值
dragon1.GetHp(hp[i][0]);
ninja1.GetHp(hp[i][1]);
iceman1.GetHp(hp[i][2]);
lion1.GetHp(hp[i][3]);
wolf1.GetHp(hp[i][4]);
//主循环
for(time = 0;;time++)
{
if(red.declared == false) //用光资源后声明了吗？
{
if(red.Keepmaking(min_requirement, time)==true) //资源用光了吗
red.Produce(time);
}
if(blue.declared == false)
{
if(blue.Keepmaking(min_requirement, time)==true)
blue.Produce(time);
}
if(red.declared==true && blue.declared==true) //两个基地的资源用光后都声明了，则结束当前case
{
break;
}
}
}
return 0;
}