一、序言
笨人pku大一新生，在完成程设魔兽大作业时设计思路和debug过得痛不欲生，遂在此记录一篇博客，附上冗长的代码，整理回顾思路，望有路过的大神能指点，也为和我一样毫无方向不知如何下手的小白提供一种最笨的方法。
二、简介
魔兽世界共有四个题目，分别为：备战、装备、开战、终极版。备战和装备比较容易，并且代码逻辑和后两个差异较大，在此忽略不做讨论。开战中战斗的一些细节要复杂与终极版，但是总体的事件数量不如终极版复杂，二者逻辑大体相似，有一些函数和类中需要改动。
三、正文
魔兽世界之一：备战
描述
魔兽世界的西面是红魔军的司令部，东面是蓝魔军的司令部。两个司令部之间是依次排列的若干城市。
红司令部，City 1，City 2，……，City n，蓝司令部
两军的司令部都会制造武士。武士一共有 dragon 、ninja、iceman、lion、wolf 五种。每种武士都有编号、生命值、攻击力这三种属性。
双方的武士编号都是从1开始计算。红方制造出来的第n个武士，编号就是n。同样，蓝方制造出来的第n个武士，编号也是n。
武士在刚降生的时候有一个生命值。
在每个整点，双方的司令部中各有一个武士降生。
红方司令部按照iceman、lion、wolf、ninja、dragon的顺序循环制造武士。
蓝方司令部按照lion、dragon、ninja、iceman、wolf的顺序循环制造武士。
制造武士需要生命元。
制造一个初始生命值为m的武士，司令部中的生命元就要减少m个。
如果司令部中的生命元不足以制造某个按顺序应该制造的武士，那么司令部就试图制造下一个。如果所有武士都不能制造了，则司令部停止制造武士。
给定一个时间，和双方司令部的初始生命元数目，要求你将从0点0分开始到双方司令部停止制造武士为止的所有事件按顺序输出。
一共有两种事件，其对应的输出样例如下：
1) 武士降生
输出样例： 004 blue lion 5 born with strength 5,2 lion in red headquarter
表示在4点整，编号为5的蓝魔lion武士降生，它降生时生命值为5，降生后蓝魔司令部里共有2个lion武士。（为简单起见，不考虑单词的复数形式）注意，每制造出一个新的武士，都要输出此时司令部里共有多少个该种武士。
2) 司令部停止制造武士
输出样例： 010 red headquarter stops making warriors
表示在10点整，红方司令部停止制造武士
输出事件时：
首先按时间顺序输出；
同一时间发生的事件，先输出红司令部的，再输出蓝司令部的。
输入
第一行是一个整数，代表测试数据组数。
每组测试数据共两行。
第一行：一个整数M。其含义为， 每个司令部一开始都有M个生命元( 1 <= M <= 10000)。
第二行：五个整数，依次是 dragon 、ninja、iceman、lion、wolf 的初始生命值。它们都大于0小于等于10000。
输出
对每组测试数据，要求输出从0时0分开始，到双方司令部都停止制造武士为止的所有事件。
对每组测试数据，首先输出"Case:n" n是测试数据的编号，从1开始 。
接下来按恰当的顺序和格式输出所有事件。每个事件都以事件发生的时间开头，时间以小时为单位，有三位。
样例输入
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
代码
#include<bits/stdc++.h>
using namespace std;
int cases,d_hp,n_hp,i_hp,l_hp,w_hp,M;
int time_clock=0;
void get_data(){
cin>>M;
cin>>d_hp>>n_hp>>i_hp>>l_hp>>w_hp;
}
class headquarter{
public:
//string red_turn[5]={"iceman","lion","wolf","ninja","dragon"};
//string blue_turn[5]={"lion","dragon","ninja","iceman","wolf"};
int redhp[5]={},bluehp[5]={};
int cnt=0;
int color;//0为红军，1为蓝军
int dragon_num=0;
int ninja_num=0;
int iceman_num=0;
int lion_num=0;
int wolf_num=0;
int total_hp=0;
int dragon_hp,ninja_hp,iceman_hp,lion_hp,wolf_hp;
headquarter(){};
headquarter(int n,int d_hp,int n_hp,int i_hp,int l_hp,int w_hp):total_hp(n),dragon_hp(d_hp),ninja_hp(n_hp),iceman_hp(i_hp),lion_hp(l_hp),wolf_hp(w_hp){
//int redhp[5]={iceman_hp,lion_hp,wolf_hp,ninja_hp,dragon_hp},bluehp[5]={lion_hp,dragon_hp,ninja_hp,iceman_hp,wolf_hp};
};
void inc(string kind){
cnt++;
if (kind=="dragon") dragon_num++,total_hp-=dragon_hp;
else if (kind=="ninja") ninja_num++,total_hp-=ninja_hp;
else if (kind=="iceman") iceman_num++,total_hp-=iceman_hp;
else if (kind=="lion") lion_num++,total_hp-=lion_hp;
else if (kind=="wolf") wolf_num++,total_hp-=wolf_hp;
}
void print_born(int t,string kind){
if (t<10) cout<<"00"<<t<<' ';
else if (t<100) cout<<0<<t<<' ';
else cout<<t<<' ';
if (color) cout<<"blue ";
else cout<<"red ";
cout<<kind<<' '<<cnt<<" born with strength ";
if (kind=="dragon")
cout<<dragon_hp<<','<<dragon_num<<' '<<kind<<' ';
if (kind=="ninja")
cout<<ninja_hp<<','<<ninja_num<<' '<<kind<<' ';
if (kind=="iceman")
cout<<iceman_hp<<','<<iceman_num<<' '<<kind<<' ';
if (kind=="lion")
cout<<lion_hp<<','<<lion_num<<' '<<kind<<' ';
if (kind=="wolf")
cout<<wolf_hp<<','<<wolf_num<<' '<<kind<<' ';
if (color){
cout<<"in blue headquarter"<<endl;
}
else cout<<"in red headquarter"<<endl;
//cout<<total_hp<<endl;
}
void print_end(int t){
if (t<10) cout<<"00"<<t<<' ';
else if (t<100) cout<<0<<t<<' ';
else cout<<t<<' ';
if (color) cout<<"blue ";
else cout<<"red ";
cout<<"headquarter stops making warriors"<<endl;
}
};
class _generate{
public:
string red_kind,blue_kind;
_generate(){}
void set_red_kind(int n){
switch(n){
case 0:red_kind="iceman";break;
case 1:red_kind="lion";break;
case 2:red_kind="wolf";break;
case 3:red_kind="ninja";break;
case 4:red_kind="dragon";break;
}
return ;
}
void set_blue_kind(int n){
switch(n){
case 3:blue_kind="iceman";break;
case 0:blue_kind="lion";break;
case 4:blue_kind="wolf";break;
case 2:blue_kind="ninja";break;
case 1:blue_kind="dragon";break;
}
return ;
}
void start(){
headquarter r_headquarter=headquarter(M,d_hp,n_hp,i_hp,l_hp,w_hp);
headquarter b_headquarter=headquarter(M,d_hp,n_hp,i_hp,l_hp,w_hp);
r_headquarter.color=0,b_headquarter.color=1;
int red_now=0,blue_now=0;
bool flag_red=true,flag_blue=true;
r_headquarter.redhp[0]=i_hp,r_headquarter.redhp[1]=l_hp,r_headquarter.redhp[2]=w_hp,r_headquarter.redhp[3]=n_hp,r_headquarter.redhp[4]=d_hp;
b_headquarter.bluehp[0]=l_hp,b_headquarter.bluehp[1]=d_hp,b_headquarter.bluehp[2]=n_hp,b_headquarter.bluehp[3]=i_hp,b_headquarter.bluehp[4]=w_hp;
//cout<<r_headquarter.redhp[0]<<' '<<r_headquarter.redhp[1]<<" "<<r_headquarter.redhp[2]<<' '<<r_headquarter.redhp[3]<<' '<<r_headquarter.redhp[4]<<endl;
while (flag_blue||flag_red){
//todo
int redcnt=0,bluecnt=0;
if (flag_red==false) goto loop1;
while (1) {
if (r_headquarter.total_hp-r_headquarter.redhp[red_now%5]>=0) break;
if (redcnt==5) break;
redcnt++;
red_now++;
}
//cout<<r_headquarter.total_hp-r_headquarter.redhp[red_now%5]<<endl;
if (r_headquarter.total_hp-r_headquarter.redhp[red_now%5]<0){
//cout<<1<<endl;
flag_red=false;
r_headquarter.print_end(time_clock);
}
else {
set_red_kind(red_now%5);
r_headquarter.inc(red_kind);
r_headquarter.print_born(time_clock,red_kind);
red_now++;
}
loop1:
if (flag_blue==false) goto loop2;
while (b_headquarter.total_hp-b_headquarter.bluehp[blue_now%5]<0&&bluecnt<5) bluecnt++,blue_now++;
if (b_headquarter.total_hp-b_headquarter.bluehp[blue_now%5]<0){
flag_blue=false;
b_headquarter.print_end(time_clock);
}
else {
set_blue_kind(blue_now%5);
b_headquarter.inc(blue_kind);
b_headquarter.print_born(time_clock,blue_kind);
blue_now++;
}
loop2:
time_clock++;
}
}
};
int main(){
cin>>cases;
int sum=1;
while (cases--){
cout<<"Case:"<<sum<<endl;
time_clock=0;
get_data();
_generate g;
g.start();
sum++;
}
return 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分开始到双方司令部停止制造武士为止的所有事件按顺序输出。
一共有两种事件，其对应的输出样例如下：
1) 武士降生
输出样例： 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。
2) 司令部停止制造武士
输出样例： 010 red headquarter stops making warriors
表示在 10点整，红方司令部停止制造武士
输出事件时：
首先按时间顺序输出；
同一时间发生的事件，先输出红司令部的，再输出蓝司令部的。
输入
第一行是一个整数,代表测试数据组数。
每组测试数据共两行。
第一行，一个整数M。其含义为： 每个司令部一开始都有M个生命元( 1 <= M <= 10000)
第二行：五个整数，依次是 dragon 、ninja、iceman、lion、wolf 的初始生命值。它们都大于0小于等于10000
输出
对每组测试数据，要求输出从0时0分开始，到双方司令部都停止制造武士为止的所有事件。
对每组测试数据，首先输出“Case:n" n是测试数据的编号，从1开始
接下来按恰当的顺序和格式输出所有事件。每个事件都以事件发生的时间开头，时间以小时为单位，有三位。
样例输入
1 20 3 4 5 6 7
样例输出
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
代码
只需要在一的基础上稍作增减即可
#include<bits/stdc++.h>
using namespace std;
int cases,d_hp,n_hp,i_hp,l_hp,w_hp,M;
int time_clock=0;
void get_data(){
cin>>M;
cin>>d_hp>>n_hp>>i_hp>>l_hp>>w_hp;
}
class headquarter{
public:
//string red_turn[5]={"iceman","lion","wolf","ninja","dragon"};
//string blue_turn[5]={"lion","dragon","ninja","iceman","wolf"};
int redhp[5]={},bluehp[5]={};
int cnt=0;
int color;//0为红军，1为蓝军
int dragon_num=0;
int ninja_num=0;
int iceman_num=0;
int lion_num=0;
int wolf_num=0;
int total_hp=0;
int dragon_hp,ninja_hp,iceman_hp,lion_hp,wolf_hp;
headquarter(){};
headquarter(int n,int d_hp,int n_hp,int i_hp,int l_hp,int w_hp):total_hp(n),dragon_hp(d_hp),ninja_hp(n_hp),iceman_hp(i_hp),lion_hp(l_hp),wolf_hp(w_hp){
//int redhp[5]={iceman_hp,lion_hp,wolf_hp,ninja_hp,dragon_hp},bluehp[5]={lion_hp,dragon_hp,ninja_hp,iceman_hp,wolf_hp};
};
void inc(string kind){
cnt++;
if (kind=="dragon") dragon_num++,total_hp-=dragon_hp;
else if (kind=="ninja") ninja_num++,total_hp-=ninja_hp;
else if (kind=="iceman") iceman_num++,total_hp-=iceman_hp;
else if (kind=="lion") lion_num++,total_hp-=lion_hp;
else if (kind=="wolf") wolf_num++,total_hp-=wolf_hp;
}
void print_born(int t,string kind){
if (t<10) cout<<"00"<<t<<' ';
else if (t<100) cout<<0<<t<<' ';
else cout<<t<<' ';
if (color) cout<<"blue ";
else cout<<"red ";
cout<<kind<<' '<<cnt<<" born with strength ";
if (kind=="dragon")
cout<<dragon_hp<<','<<dragon_num<<' '<<kind<<' ';
if (kind=="ninja")
cout<<ninja_hp<<','<<ninja_num<<' '<<kind<<' ';
if (kind=="iceman")
cout<<iceman_hp<<','<<iceman_num<<' '<<kind<<' ';
if (kind=="lion")
cout<<lion_hp<<','<<lion_num<<' '<<kind<<' ';
if (kind=="wolf")
cout<<wolf_hp<<','<<wolf_num<<' '<<kind<<' ';
if (color){
cout<<"in blue headquarter"<<endl;
}
else cout<<"in red headquarter"<<endl;
//cout<<total_hp<<endl;
}
void print_information(string kind){
int weapon_kind=cnt%3;
string weapon;
if (weapon_kind==0){
weapon="sword";
}
else if (weapon_kind==1){
weapon="bomb";
}
else {
weapon="arrow";
}
if (kind=="dragon"){
double morale=(double)total_hp/d_hp;
cout<<"It has a "<<weapon<<",and it's morale is "<<setprecision(2)<<fixed<<morale<<endl;
}
else if (kind=="ninja"){
int weapon_add_kind=(cnt+1)%3;
string weapon_add;
if (weapon_add_kind==0) weapon_add="sword";
else if (weapon_add_kind==1) weapon_add="bomb";
else weapon_add="arrow";
cout<<"It has a "<<weapon<<" and a "<<weapon_add<<endl;
}
else if (kind=="iceman"){
cout<<"It has a "<<weapon<<endl;
}
else if (kind=="lion"){
int loyalty=total_hp;
cout<<"It's loyalty is "<<loyalty<<endl;
}
return ;
}
void print_end(int t){
if (t<10) cout<<"00"<<t<<' ';
else if (t<100) cout<<0<<t<<' ';
else cout<<t<<' ';
if (color) cout<<"blue ";
else cout<<"red ";
cout<<"headquarter stops making warriors"<<endl;
}
};
class _generate{
public:
string red_kind,blue_kind;
_generate(){}
void set_red_kind(int n){
switch(n){
case 0:red_kind="iceman";break;
case 1:red_kind="lion";break;
case 2:red_kind="wolf";break;
case 3:red_kind="ninja";break;
case 4:red_kind="dragon";break;
}
return ;
}
void set_blue_kind(int n){
switch(n){
case 3:blue_kind="iceman";break;
case 0:blue_kind="lion";break;
case 4:blue_kind="wolf";break;
case 2:blue_kind="ninja";break;
case 1:blue_kind="dragon";break;
}
return ;
}
void start(){
headquarter r_headquarter=headquarter(M,d_hp,n_hp,i_hp,l_hp,w_hp);
headquarter b_headquarter=headquarter(M,d_hp,n_hp,i_hp,l_hp,w_hp);
r_headquarter.color=0,b_headquarter.color=1;
int red_now=0,blue_now=0;
bool flag_red=true,flag_blue=true;
r_headquarter.redhp[0]=i_hp,r_headquarter.redhp[1]=l_hp,r_headquarter.redhp[2]=w_hp,r_headquarter.redhp[3]=n_hp,r_headquarter.redhp[4]=d_hp;
b_headquarter.bluehp[0]=l_hp,b_headquarter.bluehp[1]=d_hp,b_headquarter.bluehp[2]=n_hp,b_headquarter.bluehp[3]=i_hp,b_headquarter.bluehp[4]=w_hp;
//cout<<r_headquarter.redhp[0]<<' '<<r_headquarter.redhp[1]<<" "<<r_headquarter.redhp[2]<<' '<<r_headquarter.redhp[3]<<' '<<r_headquarter.redhp[4]<<endl;
while (flag_blue||flag_red){
//todo
int redcnt=0,bluecnt=0;
if (flag_red==false) goto loop1;
while (1) {
if (r_headquarter.total_hp-r_headquarter.redhp[red_now%5]>=0) break;
if (redcnt==5) break;
redcnt++;
red_now++;
}
//cout<<r_headquarter.total_hp-r_headquarter.redhp[red_now%5]<<endl;
if (r_headquarter.total_hp-r_headquarter.redhp[red_now%5]<0){
//cout<<1<<endl;
flag_red=false;
r_headquarter.print_end(time_clock);
}
else {
set_red_kind(red_now%5);
r_headquarter.inc(red_kind);
r_headquarter.print_born(time_clock,red_kind);
r_headquarter.print_information(red_kind);
red_now++;
}
loop1:
if (flag_blue==false) goto loop2;
while (b_headquarter.total_hp-b_headquarter.bluehp[blue_now%5]<0&&bluecnt<5) bluecnt++,blue_now++;
if (b_headquarter.total_hp-b_headquarter.bluehp[blue_now%5]<0){
flag_blue=false;
b_headquarter.print_end(time_clock);
}
else {
set_blue_kind(blue_now%5);
b_headquarter.inc(blue_kind);
b_headquarter.print_born(time_clock,blue_kind);
b_headquarter.print_information(blue_kind);
blue_now++;
}
loop2:
time_clock++;
}
}
};
int main(){
cin>>cases;
int sum=1;
while (cases--){
cout<<"Case:"<<sum<<endl;
time_clock=0;
get_data();
_generate g;
g.start();
sum++;
}
return 0;
}魔兽世界之三：开战
描述
魔兽世界的西面是红魔军的司令部，东面是蓝魔军的司令部。两个司令部之间是依次排列的若干城市，城市从西向东依次编号为1,2,3 .... N ( N <= 20)。红魔军的司令部算作编号为0的城市，蓝魔军的司令部算作编号为N+1的城市。司令部有生命元，用于制造武士。
两军的司令部都会制造武士。武士一共有dragon 、ninja、iceman、lion、wolf 五种。每种武士都有编号、生命值、攻击力这三种属性。
双方的武士编号都是从1开始计算。红方制造出来的第n 个武士，编号就是n。同样，蓝方制造出来的第n 个武士，编号也是n。
武士在刚降生的时候有一个初始的生命值，生命值在战斗中会发生变化，如果生命值减少到0（生命值变为负数时应当做变为0处理），则武士死亡（消失）。
武士可以拥有武器。武器有三种，sword, bomb,和arrow，编号分别为0,1,2。
sword的攻击力是使用者当前攻击力的20%(去尾取整)。
bomb的攻击力是使用者当前攻击力的40%(去尾取整)，但是也会导致使用者受到攻击，对使用者的攻击力是对敌人取整后的攻击力的1/2(去尾取整)。Bomb一旦使用就没了。
arrow的攻击力是使用者当前攻击力的30%(去尾取整)。一个arrow用两次就没了。
武士降生后就朝对方司令部走，在经过的城市如果遇到敌人（同一时刻每个城市最多只可能有1个蓝武士和一个红武士），就会发生战斗。战斗的规则是：
-
在奇数编号城市，红武士先发起攻击
-
在偶数编号城市，蓝武士先发起攻击
-
战斗开始前，双方先对自己的武器排好使用顺序，然后再一件一件地按顺序使用。编号小的武器，排在前面。若有多支arrow，用过的排在前面。排好序后，攻击者按此排序依次对敌人一件一件地使用武器。如果一种武器有多件，那就都要用上。每使用一件武器，被攻击者生命值要减去武器攻击力。如果任何一方生命值减为0或小于0即为死去。有一方死去，则战斗结束。
-
双方轮流使用武器，甲用过一件，就轮到乙用。某一方把自己所有的武器都用过一轮后，就从头开始再用一轮。如果某一方没有武器了，那就挨打直到死去或敌人武器用完。武器排序只在战斗前进行，战斗中不会重新排序。
-
如果双方武器都用完且都还活着，则战斗以平局结束。如果双方都死了，也算平局。
-
有可能由于武士自身攻击力太低，而导致武器攻击力为0。攻击力为0的武器也要使用。如果战斗中双方的生命值和武器的状态都不再发生变化，则战斗结束，算平局。
-
战斗的胜方获得对方手里的武器。武士手里武器总数不超过10件。缴获武器时，按照武器种类编号从小到大缴获。如果有多件arrow，优先缴获没用过的。
-
如果战斗开始前双方都没有武器，则战斗视为平局。如果先攻击方没有武器，则由后攻击方攻击。
不同的武士有不同的特点。
编号为n的dragon降生时即获得编号为n%3 的武器。dragon在战斗结束后，如果还没有战死，就会欢呼。
编号为n的ninjia降生时即获得编号为n%3 和(n+1)%3的武器。ninja 使用bomb不会让自己受伤。
编号为n的iceman降生时即获得编号为n%3 的武器。iceman每前进一步，生命值减少10%(减少的量要去尾取整)。
编号为n的lion降生时即获得编号为n%3 的武器。lion 有“忠诚度”这个属性，其初始值等于它降生之后其司令部剩余生命元的数目。每前进一步忠诚度就降低K。忠诚度降至0或0以下，则该lion逃离战场,永远消失。但是已经到达敌人司令部的lion不会逃跑。lion在己方司令部可能逃跑。
wolf降生时没有武器，但是在战斗开始前会抢到敌人编号最小的那种武器。如果敌人有多件这样的武器，则全部抢来。Wolf手里武器也不能超过10件。如果敌人arrow太多没法都抢来，那就先抢没用过的。如果敌人也是wolf，则不抢武器。
以下是不同时间会发生的不同事件：
在每个整点，即每个小时的第0分， 双方的司令部中各有一个武士降生。
红方司令部按照iceman、lion、wolf、ninja、dragon 的顺序制造武士。
蓝方司令部按照lion、dragon、ninja、iceman、wolf 的顺序制造武士。
制造武士需要生命元。
制造一个初始生命值为m 的武士，司令部中的生命元就要减少m 个。
如果司令部中的生命元不足以制造某本该造的武士，那就从此停止制造武士。
在每个小时的第5分，该逃跑的lion就在这一时刻逃跑了。
在每个小时的第10分：所有的武士朝敌人司令部方向前进一步。即从己方司令部走到相邻城市，或从一个城市走到下一个城市。或从和敌军司令部相邻的城市到达敌军司令部。
在每个小时的第35分：在有wolf及其敌人的城市，wolf要抢夺对方的武器。
在每个小时的第40分：在有两个武士的城市，会发生战斗。
在每个小时的第50分，司令部报告它拥有的生命元数量。
在每个小时的第55分，每个武士报告其拥有的武器情况。
武士到达对方司令部后就算完成任务了，从此就呆在那里无所事事。
任何一方的司令部里若是出现了敌人，则认为该司令部已被敌人占领。
任何一方的司令部被敌人占领，则战争结束。战争结束之后就不会发生任何事情了。
给定一个时间，要求你将从0点0分开始到此时间为止的所有事件按顺序输出。事件及其对应的输出样例如下：
1) 武士降生
输出样例：000:00 blue dragon 1 born
表示在0点0分，编号为1的蓝魔dragon武士降生
如果造出的是lion，那么还要多输出一行，例:
000:00 blue lion 1 born
Its loyalty is 24
表示该lion降生时的忠诚度是24
2) lion逃跑
输出样例：000:05 blue lion 1 ran away
表示在0点5分，编号为1的蓝魔lion武士逃走
3) 武士前进到某一城市
输出样例：
000:10 red iceman 1 marched to city 1 with 20 elements and force 30
表示在0点10分，红魔1号武士iceman前进到1号城市，此时他生命值为20,攻击力为30
对于iceman,输出的生命值应该是变化后的数值
4) wolf抢敌人的武器
000:35 blue wolf 2 took 3 bomb from red dragon 2 in city 4
表示在0点35分，4号城市中，红魔1号武士wolf 抢走蓝魔2号武士dragon 3个bomb。为简单起见，武器不写复数形式
5) 报告战斗情况
战斗只有3种可能的输出结果：
000:40 red iceman 1 killed blue lion 12 in city 2 remaining 20 elements
表示在0点40分，1号城市中，红魔1号武士iceman 杀死蓝魔12号武士lion后，剩下生命值20
000:40 both red iceman 1 and blue lion 12 died in city 2
注意，把红武士写前面
000:40 both red iceman 1 and blue lion 12 were alive in city 2
注意，把红武士写前面
6) 武士欢呼
输出样例：003:40 blue dragon 2 yelled in city 4
7) 武士抵达敌军司令部
输出样例：001:10 red iceman 1 reached blue headquarter with 20 elements and force 30
（此时他生命值为20,攻击力为30）对于iceman,输出的生命值和攻击力应该是变化后的数值
8) 司令部被占领
输出样例：003:10 blue headquarter was taken
9)司令部报告生命元数量
000:50 100 elements in red headquarter
000:50 120 elements in blue headquarter
表示在0点50分，红方司令部有100个生命元，蓝方有120个
10)武士报告情况
000:55 blue wolf 2 has 2 sword 3 bomb 0 arrow and 7 elements
为简单起见，武器都不写复数形式。elements一律写复数，哪怕只有1个
交代武器情况时，次序依次是：sword,bomb, arrow。
输出事件时：
首先按时间顺序输出；
同一时间发生的事件，按发生地点从西向东依次输出. 武士前进的事件, 算是发生在目的地。
在一次战斗中有可能发生上面的 5 至 6 号事件。这些事件都算同时发生，其时间就是战斗开始时间。一次战斗中的这些事件，序号小的应该先输出。
两个武士同时抵达同一城市，则先输出红武士的前进事件，后输出蓝武士的。
对于同一城市，同一时间发生的事情，先输出红方的，后输出蓝方的。
显然，8号事件发生之前的一瞬间一定发生了7号事件。输出时，这两件事算同一时间发生，但是应先输出7号事件
虽然任何一方的司令部被占领之后，就不会有任何事情发生了。但和司令部被占领同时发生的事件，全都要输出。
输入
第一行是t,代表测试数据组数
每组样例共三行。
第一行，4个整数 M,N,K, T。其含义为：
每个司令部一开始都有M个生命元( 1 <= M <= 100000)
两个司令部之间一共有N个城市( 1 <= N <= 20 )
lion每前进一步，忠诚度就降低K。(0<=K<=100)
要求输出从0时0分开始，到时间T为止(包括T) 的所有事件。T以分钟为单位，0 <= T <= 6000
第二行：五个整数，依次是 dragon 、ninja、iceman、lion、wolf 的初始生命值。它们都大于0小于等于200
第三行：五个整数，依次是 dragon 、ninja、iceman、lion、wolf 的攻击力。它们都大于0小于等于200
输出
对每组数据，先输出一行：
Case n:
如对第一组数据就输出 Case 1:
然后按恰当的顺序和格式输出到时间T为止发生的所有事件。每个事件都以事件发生的时间开头，时间格式是“时: 分”，“时”有三位，“分”有两位。
样例输入
1
20 1 10 400
20 20 30 10 20
5 5 5 5 5
样例输出
Case 1:
000:00 blue lion 1 born
Its loyalty is 10
000:10 blue lion 1 marched to city 1 with 10 elements and force 5
000:50 20 elements in red headquarter
000:50 10 elements in blue headquarter
000:55 blue lion 1 has 0 sword 1 bomb 0 arrow and 10 elements
001:05 blue lion 1 ran away
001:50 20 elements in red headquarter
001:50 10 elements in blue headquarter
002:50 20 elements in red headquarter
002:50 10 elements in blue headquarter
003:50 20 elements in red headquarter
003:50 10 elements in blue headquarter
004:50 20 elements in red headquarter
004:50 10 elements in blue headquarter
005:50 20 elements in red headquarter
005:50 10 elements in blue headquarter
提示
请注意浮点数精度误差问题。OJ上的编译器编译出来的可执行程序，在这方面和你电脑上执行的程序很可能会不一致。5 * 0.3 的结果，有的机器上可能是 15.00000001，去尾取整得到15,有的机器上可能是14.9999999，去尾取整后就变成14。因此,本题不要写 5 * 0.3，要写 5 * 3 / 10。
分析
初看题目似乎感觉无从下手，认真读了几遍题目之后，我发现整个题目的关键在于维护一个武士移动和司令部制造武士的时间线，然后处理好武士移动后的位置变化以及战斗发生时循环攻击，武器更新。
于是我设计了一些类：headquarter类，这个类用于处理司令部的行为；weapon类，这个类用来记录一件武器的详细信息并可以更新武器状态；warrior类，这个类来记录一个武士的信息，处理武士的一种行为，以此作为基类，派生出各种武士；a_round类，这个类来维护一局游戏的时间线，可以输出各种事件的发生。
我踩的坑点：
武士移动事件的输出顺序是按照移动后的城市的自西向东排列的，与其他事件的输出略有区别。
武士武器更新时，如果要用erase函数删除一件武器，那么要注意循环应该往前移动一位，不然无法处理完所有的武器（会跳过），检查武士生死时也要注意这个问题。
各种segmentation fault 几乎没有别的，都是数组越界，或者是访问了空指针，或者是指针没有置为空指针造成的。
wolf抢武器和每一次攻击要求的武器排序规则不一样，要写不同的排序函数。
city类中的武士都要设置为指针而不是对象，这样才能在战斗中实时修改武士序列的信息，并且能正常地调用虚函数。
代码
#include<bits/stdc++.h>
using namespace std;
int cases,M,N,K,T;
int d_hp,n_hp,i_hp,l_hp,w_hp;
int d_attack,n_attack,i_attack,l_attack,w_attack;
bool gameover=false;
int timeclock=0;
//用来处理每一次的输入并初始化数据
void get_data(){
cin>>M;//司令部初始生命元
cin>>N;//城市的数目
cin>>K;//lion每前进一步，忠诚度就降低K
cin>>T;//一直持续到时间T T的单位是分钟
cin>>d_hp>>n_hp>>i_hp>>l_hp>>w_hp;
cin>>d_attack>>n_attack>>i_attack>>l_attack>>w_attack;
return ;
}
//司令部
class headquarter{
public:
int color;//0代表红军 1代表蓝军
int total_hp;//司令部的生命元
int num;//当前制造的武士的编号,武士总数
string red_kind,blue_kind;//当前编号应该制造的武士
bool can_make=true;//是否可以继续制造武士
headquarter(){}
//红色司令部制造红武士
void set_red_kind(){
switch (num%5)
{
case 1:red_kind="iceman";break;
case 2:red_kind="lion";break;
case 3:red_kind="wolf";break;
case 4:red_kind="ninja";break;
case 0:red_kind="dragon";break;
}
return ;
}
//蓝色司令部制造蓝武士
void set_blue_kind(){
switch(num%5)
{
case 1:blue_kind="lion";break;
case 2:blue_kind="dragon";break;
case 3:blue_kind="ninja";break;
case 4:blue_kind="iceman";break;
case 0:blue_kind="wolf";break;
}
return ;
}
//司令部报告生命元
void report_element(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":50 "<<total_hp<<" elements in ";
if (color) cout<<"blue ";
else cout<<"red ";
cout<<"headquarter"<<endl;
return ;
}
//司令部被占领了
void report_occupy(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":10 ";
if (color) cout<<"blue ";
else cout<<"red ";
cout<<"headquarter was taken"<<endl;
return ;
}
};
//武器
class weapon{
public:
int attack=0;
int side_effect=0;//对使用者的攻击力
int usetime=0;//可以用几次
int kind_ID=0;//武器编号
string name;
weapon(string _name){
name=_name;
if (name=="sword") {
usetime=INT32_MAX;//sword可以使用无限次
kind_ID=0;
}
else if (name=="bomb"){
usetime=1;
kind_ID=1;
}
else {
usetime=2;
kind_ID=2;
}
}
//更新武器的数值
void update(int attack_of_warrior){
switch(kind_ID)
{
case 0:attack=attack_of_warrior*2/10; break;
case 1:attack=attack_of_warrior*4/10; side_effect=attack/2;break;
case 2:attack=attack_of_warrior*3/10; break;
}
return ;
}
};
//两个比较函数
bool cmp_for_grab(weapon &a,weapon &b){
if (a.kind_ID!=b.kind_ID) return a.kind_ID<b. kind_ID;
return a.usetime>b.usetime;
}
bool cmp_for_fight(weapon &a,weapon &b){
if (a.kind_ID!=b.kind_ID) return a.kind_ID<b.kind_ID;
return a.usetime<b.usetime;
}
//武士
class warrior{
public:
string kind;//代表红方或者蓝方
string name;//代表武士的名字
int position;
int loyalty;
int hp;//生命值
int attack;//攻击力
int num;//武士编号
bool live=true;
bool can_move=true;//防止在移动的时候一轮走到底
int sword=0,bomb=0,arrow=0;//拥有武器的数量
vector<weapon>weapons;//每个武士的武器库
warrior(){};
//武士出生
void born(int hour,int loyalty=0){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":00 "<<kind<<" "<<name<<" "<<num<<" born"<<endl;
if (name=="lion") {
cout<<"Its loyalty is "<<loyalty<<endl;
}
return ;
}
virtual void flee(int hour) {};
virtual void yell(int hour,int city_num) {};
virtual void grab(warrior *a,int hour,int city_num) {};
//移动至下一座城市
void arrive(int hour,int city_num){
position=city_num;
if (name=="iceman"){
hp=hp-hp*1/10;
}
live=check_die();
if (live==false) {
return ;//防止iceman走到以后就去世
}
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":10 "<<kind<<" "<<name<<" "<<num<<" marched to city "<<city_num<<" with "<<hp<<" elements and force "<<attack<<endl;
return ;
}
//检查武士存活情况
bool check_die(){
if (hp<=0) return false;
else return true;
}
//在每一个回合开始前，根据要求把武器库里面的武器进行排序
void check_weapons_before_fight(){
if (!weapons.empty()){
sort(weapons.begin(),weapons.end(),cmp_for_fight);
for(int i=0;i<weapons.size();i++){
weapons[i].update(attack);
}
}
return ;
}
//在每一个回合后，更新武器库
void check_weapons_after_fight(){
for (int i=0;i<weapons.size();i++){
if (weapons[i].usetime==0){
switch(weapons[i].kind_ID){
case 0: sword--;break;
case 1: bomb--;break;
case 2: arrow--;break;
}
weapons.erase(weapons.begin()+i);
i--;//关键，这里不自减，会使循环直接跳过后一个元素
}
}
// vector<weapon>newvec;
// for (auto wp:weapons) if (wp.usetime) newvec.push_back(wp);
// newvec.swap(weapons);
// newvec.clear();
// return ;
}
//战胜对手后，缴获武器
void capture(warrior *a){
if (a->weapons.empty()) return ;
sort(a->weapons.begin(),a->weapons.end(),cmp_for_grab);
int num_of_weapons=weapons.size();
while(num_of_weapons<=10){
if (a->weapons.empty()) break;//防止取不出来武器
weapon tmp=a->weapons.front();
if (tmp.usetime==0) continue;
a->weapons.erase(a->weapons.begin());
weapons.push_back(tmp);
switch(tmp.kind_ID){
case 0:sword++;break;
case 1:bomb++;break;
case 2:arrow++;break;
}
num_of_weapons++;
}
return ;
}
//事件10辅助函数
void report_current(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":55 "<<kind<<" "<<name<<" "<<num<<" has "<<sword<<" sword "<<bomb<<" bomb "<<arrow<<" arrow and "<<hp<<" elements"<<endl;
return ;
}
};
bool cmp_for_city(warrior *p, warrior *q){
int pposition=0,qposition=0;
if (p->kind=="red") pposition=p->position+1;
else if (p->kind=="blue") pposition=p->position-1;
if (q->kind=="red") qposition=q->position+1;
else if (q->kind=="blue") qposition=q->position-1;
return pposition<qposition;
}//把城市按照从西到东排列(march)
bool cmp_for_city_(warrior*p,warrior*q){
return p->position<q->position;
}//把城市按照从西到东排列(普通)
class dragon : public warrior{
public:
dragon(int d_hp,int d_attack,int _num,string _kind,int _position,string _name="dragon"){
hp=d_hp;
attack=d_attack;
num=_num;
kind=_kind;
name=_name;
position=_position;
}
//dragon欢呼
void yell(int hour,int city_num){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":40 "<<kind<<" dragon "<<num<<" yelled in city "<<city_num<<endl;
return ;
}
void get_weapon(int num){
int ID=num%3;
switch(ID)
{
case 0:weapons.push_back(weapon("sword"));sword++;break;
case 1:weapons.push_back(weapon("bomb"));bomb++;break;
case 2:weapons.push_back(weapon("arrow"));arrow++;break;
}
return;
}
};
class ninja : public warrior{
public:
ninja(int n_hp,int n_attack,int _num,string _kind,int _position,string _name="ninja"){
hp=n_hp;
attack=n_attack;
num=_num;
kind=_kind;
name=_name;
position=_position;
}
void get_weapon(int num){
int ID=num%3;
switch(ID)
{
case 0:weapons.push_back(weapon("sword"));sword++;break;
case 1:weapons.push_back(weapon("bomb"));bomb++;break;
case 2:weapons.push_back(weapon("arrow"));arrow++;break;
}
ID=(num+1)%3;
switch(ID)
{
case 0:weapons.push_back(weapon("sword"));sword++;break;
case 1:weapons.push_back(weapon("bomb"));bomb++;break;
case 2:weapons.push_back(weapon("arrow"));arrow++;break;
}
return ;
}
};
class iceman : public warrior{
public:
iceman(int i_hp,int i_attack,int _num,string _kind,int _position,string _name="iceman"){
hp=i_hp;
attack=i_attack;
num=_num;
kind=_kind;
name=_name;
position=_position;
}
void get_weapon(int num){
int ID=num%3;
switch(ID)
{
case 0:weapons.push_back(weapon("sword"));sword++;break;
case 1:weapons.push_back(weapon("bomb"));bomb++;break;
case 2:weapons.push_back(weapon("arrow"));arrow++;break;
}
return ;
}
};
class lion : public warrior{
public:
lion(int l_hp,int l_attack,int _num,string _kind,int _position,int _loyalty,string _name="lion"){
hp=l_hp;
attack=l_attack;
num=_num;
kind=_kind;
name=_name;
loyalty=_loyalty;
position=_position;
}
void get_weapon(int num){
int ID=num%3;
switch(ID)
{
case 0:weapons.push_back(weapon("sword"));sword++;break;
case 1:weapons.push_back(weapon("bomb"));bomb++;break;
case 2:weapons.push_back(weapon("arrow"));arrow++;break;
}
return ;
}
//lion逃跑
void flee(int hour){
//如果忠诚度满足要求那么就什么都不做
if (loyalty<=0) {
live=false;
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":05 "<<kind<<" lion "<<num<<" ran away"<<endl;
}
return ;
}
};
class wolf : public warrior{
public:
int num_of_weapons=0;
wolf(int w_hp,int w_attack,int _num,string _kind,int _position,string _name="wolf"){
hp=w_hp;
attack=w_attack;
num=_num;
kind=_kind;
name=_name;
position=_position;
}
//wolf抢武器
void grab(warrior *a,int hour,int city_num){
if (a->weapons.empty()) return ;
int s_get=0,b_get=0,a_get=0;
int output=0;
string name;
sort(a->weapons.begin(),a->weapons.end(),cmp_for_grab);
int min_ID=a->weapons.front().kind_ID;
while(num_of_weapons<=10){
if (a->weapons.empty()) break;//防止取不出来武器
weapon tmp=a->weapons.front();
if (tmp.kind_ID!=min_ID) break;
a->weapons.erase(a->weapons.begin());
weapons.push_back(tmp);
switch(tmp.kind_ID){
//注意：抢走武器后，对方的武器数量需要减1!!
case 0:sword++;s_get++;a->sword--;break;
case 1:bomb++;b_get++;a->bomb--;break;
case 2:arrow++;a_get++;a->arrow--;break;
}
num_of_weapons++;
}
if (s_get!=0) {
name="sword";
output=s_get;
}
else if(b_get!=0){
name="bomb";
output=b_get;
}
else if (a_get!=0){
name="arrow";
output=a_get;
}
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":35 "<<kind<<" wolf "<<num<<" took "<<output<<" "<<name<<" from "<<a->kind<<" "<<a->name<<" "<<a->num<<" in city "<<city_num<<endl;
return ;
}
};
//城市中进行的战争，每一个时刻城市中的武士
class city{
public:
//不初始化为nullptr会发生segmentation fault
warrior* red=nullptr;
warrior* blue=nullptr;
warrior* winner=nullptr;
warrior* loser=nullptr;
int ID_city=0;
bool win_or_lose=false;
bool all_die=false;
city(){}
//分出胜负
void print_case1(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":40 "<<winner->kind<<" "<<winner->name<<" "<<winner->num<<" killed "<<loser->kind<<" "<<loser->name<<" "<<loser->num<<" in city "<<ID_city
<<" remaining "<<winner->hp<<" elements"<<endl;
return ;
}
//平局且全死了
void print_case2(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":40 both "<<red->kind<<" "<<red->name<<" "<<red->num<<" and "<<blue->kind<<" "<<blue->name<<" "<<blue->num<<" died in city "<<ID_city<<endl;
return ;
}
//平局且都活着
void print_case3(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":40 both "<<red->kind<<" "<<red->name<<" "<<red->num<<" and "<<blue->kind<<" "<<blue->name<<" "<<blue->num<<" were alive in city "<<ID_city<<endl;
return ;
}
};
//控制一组样例的进行
class a_round{
public:
//两方制造的武士序列
vector<warrior*>red_warrior;
vector<warrior*>blue_warrior;
//两方司令部
headquarter red;
headquarter blue;
//司令部之间的城市
city *cities=new city[25];
//初始化必要条件
a_round(){
red.color=0,blue.color=1;
red.total_hp=blue.total_hp=M;
red.num=blue.num=0;
for (int i=1;i<=N;i++){
cities[i].ID_city=i;
}
}
void update_can_move(){
for (int i=0;i<red_warrior.size();i++){
red_warrior[i]->can_move=true;
}
for (int j=0;j<blue_warrior.size();j++){
blue_warrior[j]->can_move=true;
}
return ;
}
//事件1
void warrior_born(){
if (!red.can_make) {
goto loop1;
}
red.num++;
red.set_red_kind();
if (red.red_kind=="dragon"){
if (red.total_hp<d_hp) {
red.can_make=false;
}
else {
dragon* d=new dragon(d_hp,d_attack,red.num,"red",0);
d->get_weapon(d->num);
d->born(timeclock);
red_warrior.push_back(d);
red.total_hp-=d_hp;
cities[0].red=d;
}
}
else if (red.red_kind=="ninja"){
if (red.total_hp<n_hp) {
red.can_make=false;
}
else {
ninja* n=new ninja(n_hp,n_attack,red.num,"red",0);
n->get_weapon(n->num);
n->born(timeclock);
red_warrior.push_back(n);
red.total_hp-=n_hp;
cities[0].red=n;
}
}
else if (red.red_kind=="iceman"){
if (red.total_hp<i_hp) {
red.can_make=false;
}
else {
iceman* i=new iceman(i_hp,i_attack,red.num,"red",0);
i->get_weapon(i->num);
i->born(timeclock);
red_warrior.push_back(i);
red.total_hp-=i_hp;
cities[0].red=i;
}
}
else if (red.red_kind=="lion"){
if (red.total_hp<l_hp) {
red.can_make=false;
}
else {
lion* l=new lion(l_hp,l_attack,red.num,"red",0,red.total_hp-l_hp);
l->get_weapon(l->num);
l->born(timeclock,l->loyalty);
red_warrior.push_back(l);
red.total_hp-=l_hp;
cities[0].red=l;
}
}
else {
if (red.total_hp<w_hp) {
red.can_make=false;
}
else {
wolf* w=new wolf(w_hp,w_attack,red.num,"red",0);
w->born(timeclock);
red_warrior.push_back(w);
red.total_hp-=w_hp;
cities[0].red=w;
}
}
loop1:;
if (!blue.can_make) {
goto loop2;
}
blue.num++;
blue.set_blue_kind();
if (blue.blue_kind=="dragon") {
if (blue.total_hp<d_hp){
blue.can_make=false;
}
else {
dragon* d=new dragon(d_hp,d_attack,blue.num,"blue",N+1);
d->get_weapon(d->num);
d->born(timeclock);
blue_warrior.push_back(d);
blue.total_hp-=d_hp;
cities[N+1].blue=d;
}
}
else if (blue.blue_kind=="ninja") {
if (blue.total_hp<n_hp){
blue.can_make=false;
}
else {
ninja* n=new ninja(n_hp,n_attack,blue.num,"blue",N+1);
n->get_weapon(n->num);
n->born(timeclock);
blue_warrior.push_back(n);
blue.total_hp-=n_hp;
cities[N+1].blue=n;
}
}
else if (blue.blue_kind=="iceman") {
if (blue.total_hp<i_hp){
blue.can_make=false;
}
else {
iceman* i=new iceman(i_hp,i_attack,blue.num,"blue",N+1);
i->get_weapon(i->num);
i->born(timeclock);
blue_warrior.push_back(i);
blue.total_hp-=i_hp;
cities[N+1].blue=i;
}
}
else if (blue.blue_kind=="lion") {
if (blue.total_hp<l_hp) {
blue.can_make=false;
}
else {
lion* l=new lion(l_hp,l_attack,blue.num,"blue",N+1,blue.total_hp-l_hp);
l->get_weapon(l->num);
l->born(timeclock,l->loyalty);
blue_warrior.push_back(l);
blue.total_hp-=l_hp;
cities[N+1].blue=l;
}
}
else {
if (blue.total_hp<w_hp){
blue.can_make=false;
}
else {
wolf* w=new wolf(w_hp,w_attack,blue.num,"blue",N+1);
w->born(timeclock);
blue_warrior.push_back(w);
blue.total_hp-=w_hp;
cities[N+1].blue=w;
}
}
loop2:;
return ;
}
//事件2
void lion_flee(){
for (int i=0;i<red_warrior.size();i++){
if (red_warrior[i]->name=="lion") {
red_warrior[i]->flee(timeclock);
if (red_warrior[i]->live==false){
red_warrior.erase(red_warrior.begin()+i);
}
}
}
for (int j=0;j<blue_warrior.size();j++){
if (blue_warrior[j]->name=="lion") {
blue_warrior[j]->flee(timeclock);
if (blue_warrior[j]->live==false){
blue_warrior.erase(blue_warrior.begin()+j);
}
}
}
return ;
}
//事件3
void march(){
vector<warrior*>total=red_warrior;
total.insert(total.end(),blue_warrior.begin(),blue_warrior.end());
sort(total.begin(),total.end(),cmp_for_city);
for (int i = 1; i <= N; ++i)
cities[i].red = cities[i].blue = nullptr;
for (int i=0;i<total.size();i++){
if (total[i]->kind=="red"){
// if (cities[total[i]->position].red&&cities[total[i]->position].red->can_move==false) cities[total[i]->position].red=nullptr;
if (total[i]->position==N){
if (total[i]->name=="iceman"){
total[i]->hp=total[i]->hp-total[i]->hp*1/10;
}
total[i]->live=total[i]->check_die();
if (total[i]->live==false){
total.erase(total.begin()+i);
continue;
}
//事件7
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<"0"<<timeclock;
else cout<<"00"<<timeclock;
cout<<":10 "<<"red "<<total[i]->name<<" "<<total[i]->num<<" reached blue headquarter with ";
cout<<total[i]->hp<<" elements and force "<<total[i]->attack<<endl;
//事件8
blue.report_occupy(timeclock);
gameover=true;
continue;
}
total[i]->arrive(timeclock,total[i]->position+1);
if (total[i]->name=="lion"){
total[i]->loyalty-=K;
}
if (total[i]->live==false){
total.erase(total.begin()+i);
continue;
}
cities[total[i]->position].red=total[i];
}
else {
cities[total[i]->position].blue=nullptr;
if (total[i]->position==1){
if (total[i]->name=="iceman"){
total[i]->hp=total[i]->hp-total[i]->hp*1/10;
}
total[i]->live=total[i]->check_die();
if (total[i]->live==false){
total.erase(total.begin()+i);
continue;
}
//事件7
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<"0"<<timeclock;
else cout<<"00"<<timeclock;
cout<<":10 blue "<<total[i]->name<<" "<<total[i]->num<<" reached red headquarter with ";
cout<<total[i]->hp<<" elements and force "<<total[i]->attack<<endl;
//事件8
red.report_occupy(timeclock);
gameover=true;
continue;
}
total[i]->arrive(timeclock,total[i]->position-1);
if (total[i]->name=="lion"){
total[i]->loyalty-=K;
}
if (total[i]->live==false){
total.erase(total.begin()+i);
continue;
}
cities[total[i]->position].blue=total[i];
}
}
return ;
}
//事件4
void wolf_grab(){
for (int i=1;i<=N;i++){
if (!cities[i].red||!cities[i].blue) continue;
if (cities[i].red->name=="wolf"&&cities[i].blue->name!="wolf"){
cities[i].red->grab(cities[i].blue,timeclock,i);
}
else if(cities[i].blue->name=="wolf"&&cities[i].red->name!="wolf"){
cities[i].blue->grab(cities[i].red,timeclock,i);
}
}
return ;
}
//开始战斗并且报告战斗情况
//最后还有武士欢呼
void fight_time(){
for (int i=1;i<=N;i++){
//只有一个武士的城市不发生战斗
if (!cities[i].red||!cities[i].blue) continue;
//双方都没有武器，不战斗
if (cities[i].red->weapons.empty()&&cities[i].blue->weapons.empty()){
cities[i].print_case3(timeclock);
//欢呼
if (cities[i].red->live&&cities[i].red->name=="dragon"){
cities[i].red->yell(timeclock,i);
}
if (cities[i].blue->name=="dragon"&&cities[i].blue->live){
cities[i].blue->yell(timeclock,i);
}
continue;
}
//要战斗
cities[i].red->check_weapons_before_fight();
cities[i].blue->check_weapons_before_fight();
int current_id_weapon_red=0;
int current_id_weapon_blue=0;
//奇数编号的城市
if (i%2==1){
while(cities[i].red->live&&cities[i].blue->live){
//cout<<1<<endl;
int cnt1=0,cnt2=0;
//红方回合
//红方攻击
int find_times=0;
while(!cities[i].red->weapons.empty()&&cities[i].red->weapons[current_id_weapon_red].usetime==0){
if (find_times==cities[i].red->weapons.size()) break;
//找到一个能用的武器
//cout<<2<<endl;
current_id_weapon_red++;
if (current_id_weapon_red==cities[i].red->weapons.size()){
current_id_weapon_red=0;
}
find_times++;
}
if (cities[i].red->weapons.empty()||find_times==cities[i].red->weapons.size()){
goto loop1;
}
//使用武器
cities[i].red->weapons[current_id_weapon_red].update(cities[i].red->attack);
if (cities[i].red->name=="ninja"){
cities[i].red->weapons[current_id_weapon_red].side_effect=0;
}
cities[i].red->hp-=cities[i].red->weapons[current_id_weapon_red].side_effect;
cities[i].blue->hp-=cities[i].red->weapons[current_id_weapon_red].attack;
cities[i].red->weapons[current_id_weapon_red].usetime--;
cities[i].red->live=cities[i].red->check_die();
cities[i].blue->live=cities[i].blue->check_die();
if (cities[i].red->live==false||cities[i].blue->live==false){
break;
}
loop1:;
//蓝方回合
//蓝方攻击
find_times=0;
while (!cities[i].blue->weapons.empty()&&cities[i].blue->weapons[current_id_weapon_blue].usetime==0){
//找一个能用的武器
//cout<<3<<endl;
if (find_times==cities[i].blue->weapons.size()) break;
current_id_weapon_blue++;
if (current_id_weapon_blue==cities[i].blue->weapons.size()){
current_id_weapon_blue=0;
}
find_times++;
}
// if (!cities[i].blue->weapons.empty()) cout<<cities[i].blue->weapons[current_id_weapon_blue].usetime<<" "<<cities[i].blue->name<<" "<<cities[i].blue->weapons[current_id_weapon_blue].name<<endl;
if (cities[i].blue->weapons.empty()||find_times==cities[i].blue->weapons.size()){
goto loop2;
}
//使用武器
cities[i].blue->weapons[current_id_weapon_blue].update(cities[i].blue->attack);
if (cities[i].blue->name=="ninja"){
cities[i].blue->weapons[current_id_weapon_blue].side_effect=0;
}
cities[i].blue->hp-=cities[i].blue->weapons[current_id_weapon_blue].side_effect;
cities[i].red->hp-=cities[i].blue->weapons[current_id_weapon_blue].attack;
cities[i].blue->weapons[current_id_weapon_blue].usetime--;
loop2:;
//结算这一回合的战斗
cities[i].blue->live=cities[i].blue->check_die();
cities[i].red->live=cities[i].red->check_die();
if (cities[i].blue->live==false||cities[i].red->live==false){
break;
}
current_id_weapon_blue++;
current_id_weapon_red++;
//使用完一轮，再用一轮
if (current_id_weapon_blue==cities[i].blue->weapons.size()){
current_id_weapon_blue=0;
}
if (current_id_weapon_red==cities[i].red->weapons.size()){
current_id_weapon_red=0;
}
//特判一下是否出现打不死 注意attack=0必须是sword才算加1！！
for (int j=0;j<cities[i].red->weapons.size();j++){
if (cities[i].red->weapons[j].usetime==0||(cities[i].red->weapons[j].attack==0&&cities[i].red->weapons[j].kind_ID==0)) cnt1++;
}
for (int j=0;j<cities[i].blue->weapons.size();j++){
if (cities[i].blue->weapons[j].usetime==0||(cities[i].blue->weapons[j].attack==0&&cities[i].blue->weapons[j].kind_ID==0)) cnt2++;
}
if (cnt1==cities[i].red->weapons.size()&&cnt2==cities[i].blue->weapons.size()) break;
}
}
//同理，偶数编号的城市
else{
while(cities[i].red->live&&cities[i].blue->live){
//cout<<4<<endl;
int cnt1=0,cnt2=0;
//蓝方回合
//蓝方攻击
int find_times=0;
while(!cities[i].blue->weapons.empty()&&cities[i].blue->weapons[current_id_weapon_blue].usetime==0){
//找到一个能用的武器
//cout<<5<<endl;
if (find_times==cities[i].blue->weapons.size()) break;
current_id_weapon_blue++;
if (current_id_weapon_blue==cities[i].blue->weapons.size()){
current_id_weapon_blue=0;
}
find_times++;
}
if (cities[i].blue->weapons.empty()||find_times==cities[i].blue->weapons.size()){
goto loop3;
}
//使用武器
cities[i].blue->weapons[current_id_weapon_blue].update(cities[i].blue->attack);
if (cities[i].blue->name=="ninja"){
cities[i].blue->weapons[current_id_weapon_blue].side_effect=0;
}
cities[i].blue->hp-=cities[i].blue->weapons[current_id_weapon_blue].side_effect;
cities[i].red->hp-=cities[i].blue->weapons[current_id_weapon_blue].attack;
cities[i].blue->weapons[current_id_weapon_blue].usetime--;
cities[i].blue->live=cities[i].blue->check_die();
cities[i].red->live=cities[i].red->check_die();
if (cities[i].blue->live==false||cities[i].red->live==false){
break;
}
loop3:;
//红方回合
//红方攻击
find_times=0;
while (!cities[i].red->weapons.empty()&&cities[i].red->weapons[current_id_weapon_red].usetime==0){
//找一个能用的武器
if (find_times==cities[i].red->weapons.size()) break;
//cout<<6<<endl;
current_id_weapon_red++;
if (current_id_weapon_red==cities[i].red->weapons.size()){
current_id_weapon_red=0;
}
find_times++;
}
if (cities[i].red->weapons.empty()||find_times==cities[i].red->weapons.size()){
goto loop4;
}
//使用武器
if (cities[i].red->name=="ninja"){
cities[i].red->weapons[current_id_weapon_red].update(cities[i].red->attack);
cities[i].red->weapons[current_id_weapon_red].side_effect=0;
}
cities[i].red->hp-=cities[i].red->weapons[current_id_weapon_red].side_effect;
cities[i].blue->hp-=cities[i].red->weapons[current_id_weapon_red].attack;
cities[i].red->weapons[current_id_weapon_red].usetime--;
loop4:;
//结算这一回合的战斗
cities[i].blue->live=cities[i].blue->check_die();
cities[i].red->live=cities[i].red->check_die();
if (cities[i].red->live==false||cities[i].blue->live==false){
break;
}
current_id_weapon_blue++;
current_id_weapon_red++;
//使用完一轮，再用一轮
if (current_id_weapon_blue==cities[i].blue->weapons.size()){
current_id_weapon_blue=0;
}
if (current_id_weapon_red==cities[i].red->weapons.size()){
current_id_weapon_red=0;
}
//特判一下是否出现打不死
for (int j=0;j<cities[i].red->weapons.size();j++){
if (cities[i].red->weapons[j].usetime==0||(cities[i].red->weapons[j].attack==0&&cities[i].red->weapons[j].kind_ID==0)) cnt1++;
}
for (int j=0;j<cities[i].blue->weapons.size();j++){
if (cities[i].blue->weapons[j].usetime==0||(cities[i].blue->weapons[j].attack==0&&cities[i].blue->weapons[j].kind_ID==0)) cnt2++;
}
if (cnt1==cities[i].red->weapons.size()&&cnt2==cities[i].blue->weapons.size()) break;
}
}
cities[i].red->check_weapons_after_fight();
cities[i].blue->check_weapons_after_fight();
//平局都存活
if (cities[i].red->live&&cities[i].blue->live){
cities[i].print_case3(timeclock);
}
//平局都死了
else if (cities[i].red->live==false&&cities[i].blue->live==false){
cities[i].print_case2(timeclock);
}
//分出胜负
else{
if (cities[i].red->live){
cities[i].winner=cities[i].red;
cities[i].loser=cities[i].blue;
}
else {
cities[i].winner=cities[i].blue;
cities[i].loser=cities[i].red;
}
cities[i].print_case1(timeclock);
if (cities[i].winner->kind=="red"){
cities[i].red->capture(cities[i].blue);
}
else {
cities[i].blue->capture(cities[i].red);
}
}
//欢呼
if (cities[i].red->live&&cities[i].red->name=="dragon"){
cities[i].red->yell(timeclock,i);
}
if (cities[i].blue->name=="dragon"&&cities[i].blue->live){
cities[i].blue->yell(timeclock,i);
}
//把城市里面的战斗状况返回给武士序列
for (int j=0;j<red_warrior.size();j++){
if (red_warrior[j]->position==i){
red_warrior[j]=cities[i].red;
break;
}
}
for (int j=0;j<blue_warrior.size();j++){
if (blue_warrior[j]->position==i){
blue_warrior[j]=cities[i].blue;
break;
}
}
}
return ;
}
// void warrior_yell(){
// for (int i=0;i<=N;i++){
// if (cities[i].red.name=="dragon"&&cities[i].red.live){
// cities[i].red.yell(timeclock,i);
// }
// if (cities[i].blue.name=="dragon"&&cities[i].blue.live){
// cities[i].blue.yell(timeclock,i);
// }
// }
// return ;
// }
//事件9
void report_headquarter_elements(){
red.report_element(timeclock);
blue.report_element(timeclock);
return ;
}
//打扫战场
void check_warrior_live(){
for (int i=0;i<red_warrior.size();i++){
if (red_warrior[i]->live==false){
red_warrior.erase(red_warrior.begin()+i);
i--;
}
}
for (int j=0;j<blue_warrior.size();j++){
if (blue_warrior[j]->live==false){
blue_warrior.erase(blue_warrior.begin()+j);
j--;
}
}
return ;
}
//事件10
void report_warrior_weapons(){
vector<warrior*>total=red_warrior;
total.insert(total.end(),blue_warrior.begin(),blue_warrior.end());
sort(total.begin(),total.end(),cmp_for_city_);
for (int i=0;i<total.size();i++){
total[i]->report_current(timeclock);
}
return ;
}
//每一局游戏的时间线
void start(){
while(timeclock*60<=T){
//00:
if (red.can_make||blue.can_make) warrior_born();
//05:
//if (timeclock*60+5>T) break;
lion_flee();
//10:
//if (timeclock*60+10>T) break;
//update_can_move();
march();
if (gameover) break;
//35:
//if (timeclock*60+35>T) break;
wolf_grab();
//45:
//if (timeclock*60+45>T) break;
fight_time();
//50:
if (timeclock*60+50>T) break;
report_headquarter_elements();
//55:
//if (timeclock*60+55>T) break;
check_warrior_live();
report_warrior_weapons();
timeclock++;
}
return ;
}
};
//主函数
int main(){
freopen("my_in.txt", "r", stdin);
freopen("my_out.txt","w",stdout);
cin>>cases;
int cnt=1;
while (cases--){
timeclock=0;
gameover=false;
cout<<"Case "<<cnt<<":"<<endl;
cnt++;
get_data();
a_round START;
START.start();
}
return 0;
}魔兽世界之四：终极版
描述
魔兽世界的西面是红魔军的司令部，东面是蓝魔军的司令部。两个司令部之间是依次排列的若干城市，城市从西向东依次编号为1,2,3 .... N ( N <= 20 )。红魔军的司令部算作编号为0的城市，蓝魔军的司令部算作编号为N+1的城市。司令部有生命元，用于制造武士。
两军的司令部都会制造武士。武士一共有 dragon 、ninja、iceman、lion、wolf 五种。每种武士都有编号、生命值、攻击力这三种属性。
双方的武士编号都是从1开始计算。红方制造出来的第 n 个武士，编号就是n。同样，蓝方制造出来的第 n 个武士，编号也是n。
武士在刚降生的时候有一个初始的生命值，生命值在战斗中会发生变化，如果生命值减少到0（生命值变为负数时应当做变为0处理），则武士死亡（消失）。
有的武士可以拥有武器。武器有三种，sword, bomb,和arrow，编号分别为0,1,2。
武士降生后就朝对方司令部走，在经过的城市如果遇到敌人（同一时刻每个城市最多只可能有1个蓝武士和一个红武士），就会发生战斗。每次战斗只有一方发起主动进攻一次。被攻击者生命值会减去进攻者的攻击力值和进攻者手中sword的攻击力值。被进攻者若没死，就会发起反击，被反击者的生命值要减去反击者攻击力值的一半(去尾取整)和反击者手中sword的攻击力值。反击可能致敌人于死地。
如果武士在战斗中杀死敌人（不论是主动进攻杀死还是反击杀死），则其司令部会立即向其发送8个生命元作为奖励，使其生命值增加8。当然前提是司令部得有8个生命元。如果司令部的生命元不足以奖励所有的武士，则优先奖励距离敌方司令部近的武士。
如果某武士在某城市的战斗中杀死了敌人，则该武士的司令部立即取得该城市中所有的生命元。注意，司令部总是先完成全部奖励工作，然后才开始从各个打了胜仗的城市回收生命元。对于因司令部生命元不足而领不到奖励的武士，司令部也不会在取得战利品生命元后为其补发奖励。
如果一次战斗的结果是双方都幸存(平局)，则双方都不能拿走发生战斗的城市的生命元。
城市可以插旗子，一开始所有城市都没有旗子。在插红旗的城市，以及编号为奇数的无旗城市，由红武士主动发起进攻。在插蓝旗的城市，以及编号为偶数的无旗城市，由蓝武士主动发起进攻。
当某个城市有连续两场战斗都是同一方的武士杀死敌人(两场战斗之间如果有若干个战斗时刻并没有发生战斗，则这两场战斗仍然算是连续的；但如果中间有平局的战斗，就不算连续了) ，那么该城市就会插上胜方的旗帜，若原来插着败方的旗帜，则败方旗帜落下。旗帜一旦插上，就一直插着，直到被敌人更换。一个城市最多只能插一面旗帜，旗帜没被敌人更换前，也不会再次插同颜色的旗。
各种武器有其特点：
sword武器的初始攻击力为拥有它的武士的攻击力的20%（去尾取整）。但是sword每经过一次战斗(不论是主动攻击还是反击)，就会变钝，攻击力变为本次战斗前的80% (去尾取整)。sword攻击力变为0时，视为武士失去了sword。如果武士降生时得到了一个初始攻击力为0的sword，则视为武士没有sword.
arrow有一个攻击力值R。如果下一步要走到的城市有敌人，那么拥有arrow的武士就会放箭攻击下一个城市的敌人（不能攻击对方司令部里的敌人）而不被还击。arrow使敌人的生命值减少R，若减至小于等于0，则敌人被杀死。arrow使用3次后即被耗尽，武士失去arrow。两个相邻的武士可能同时放箭把对方射死。
拥有bomb的武士，在战斗开始前如果判断自己将被杀死（不论主动攻击敌人，或者被敌人主动攻击都可能导致自己被杀死，而且假设武士可以知道敌人的攻击力和生命值），那么就会使用bomb和敌人同归于尽。武士不预测对方是否会使用bomb。
武士使用bomb和敌人同归于尽的情况下，不算是一场战斗，双方都不能拿走城市的生命元，也不影响城市的旗帜。
不同的武士有不同的特点。
dragon可以拥有一件武器。编号为n的dragon降生时即获得编号为 n%3 的武器。dragon还有“士气”这个属性，是个浮点数，其值为它降生后其司令部剩余生命元的数量除以造dragon所需的生命元数量。dragon 在一次在它主动进攻的战斗结束后，如果还没有战死，而且士气值大于0.8，就会欢呼。dragon每取得一次战斗的胜利(敌人被杀死)，士气就会增加0.2，每经历一次未能获胜的战斗，士气值就会减少0.2。士气增减发生在欢呼之前。
ninja可以拥有两件武器。编号为n的ninja降生时即获得编号为 n%3 和 (n+1)%3的武器。ninja 挨打了也从不反击敌人。
iceman有一件武器。编号为n的iceman降生时即获得编号为 n%3 的武器。iceman 每前进两步，在第2步完成的时候，生命值会减少9，攻击力会增加20。但是若生命值减9后会小于等于0，则生命值不减9,而是变为1。即iceman不会因走多了而死。
lion 有“忠诚度”这个属性，其初始值等于它降生之后其司令部剩余生命元的数目。每经过一场未能杀死敌人的战斗，忠诚度就降低K。忠诚度降至0或0以下，则该lion逃离战场,永远消失。但是已经到达敌人司令部的lion不会逃跑。Lion在己方司令部可能逃跑。lion 若是战死，则其战斗前的生命值就会转移到对手身上。所谓“战斗前”，就是每个小时的40分前的一瞬间。
wolf降生时没有武器，但是在战斗中如果获胜（杀死敌人），就会缴获敌人的武器，但自己已有的武器就不缴获了。被缴获的武器当然不能算新的，已经被用到什么样了，就是什么样的。
以下是不同时间会发生的不同事件：
在每个整点，即每个小时的第0分， 双方的司令部中各有一个武士降生。
红方司令部按照 iceman、lion、wolf、ninja、dragon 的顺序制造武士。
蓝方司令部按照 lion、dragon、ninja、iceman、wolf 的顺序制造武士。
制造武士需要生命元。
制造一个初始生命值为 m 的武士，司令部中的生命元就要减少 m 个。
如果司令部中的生命元不足以制造某武士，那么司令部就等待，直到获得足够生命元后的第一个整点，才制造该武士。例如，在2:00，红方司令部本该制造一个 wolf ，如果此时生命元不足，那么就会等待，直到生命元足够后的下一个整点，才制造一个 wolf。
在每个小时的第5分，该逃跑的lion就在这一时刻逃跑了。
在每个小时的第10分：所有的武士朝敌人司令部方向前进一步。即从己方司令部走到相邻城市，或从一个城市走到下一个城市。或从和敌军司令部相邻的城市到达敌军司令部。
在每个小时的第20分：每个城市产出10个生命元。生命元留在城市，直到被武士取走。
在每个小时的第30分：如果某个城市中只有一个武士，那么该武士取走该城市中的所有生命元，并立即将这些生命元传送到其所属的司令部。
在每个小时的第35分，拥有arrow的武士放箭，对敌人造成伤害。放箭事件应算发生在箭发出的城市。注意，放箭不算是战斗，因此放箭的武士不会得到任何好处。武士在没有敌人的城市被箭射死也不影响其所在城市的旗帜更换情况。
在每个小时的第38分，拥有bomb的武士评估是否应该使用bomb。如果是，就用bomb和敌人同归于尽。
在每个小时的第40分：在有两个武士的城市，会发生战斗。 如果敌人在5分钟前已经被飞来的arrow射死，那么仍然视为发生了一场战斗，而且存活者视为获得了战斗的胜利。此情况下不会有“武士主动攻击”，“武士反击”，“武士战死”的事件发生，但战斗胜利后应该发生的事情都会发生。如Wolf一样能缴获武器，旗帜也可能更换，等等。在此情况下,Dragon同样会通过判断是否应该轮到自己主动攻击来决定是否欢呼。
在每个小时的第50分，司令部报告它拥有的生命元数量。
在每个小时的第55分，每个武士报告其拥有的武器情况。
武士到达对方司令部后就算完成任务了，从此就呆在那里无所事事。
任何一方的司令部里若是出现了2个敌人，则认为该司令部已被敌人占领。
任何一方的司令部被敌人占领，则战争结束。战争结束之后就不会发生任何事情了。
给定一个时间，要求你将从0点0分开始到此时间为止的所有事件按顺序输出。事件及其对应的输出样例如下：
1) 武士降生
输出样例： 000:00 blue lion 1 born
表示在 0点0分，编号为1的蓝魔lion武士降生
如果造出的是dragon，那么还要多输出一行，例：
000:00 blue dragon 1 born
Its morale is 23.34
表示该该dragon降生时士气是23. 34(四舍五入到小数点后两位)
如果造出的是lion，那么还要多输出一行，例:
000:00 blue lion 1 born
Its loyalty is 24
表示该lion降生时的忠诚度是24
2) lion逃跑
输出样例： 000:05 blue lion 1 ran away
表示在 0点5分，编号为1的蓝魔lion武士逃走
3) 武士前进到某一城市
输出样例： 000:10 red iceman 1 marched to city 1 with 20 elements and force 30
表示在 0点10分，红魔1号武士iceman前进到1号城市，此时他生命值为20,攻击力为30
对于iceman,输出的生命值和攻击力应该是变化后的数值
4)武士放箭
输出样例： 000:35 blue dragon 1 shot
表示在 0点35分，编号为1的蓝魔dragon武士射出一支箭。如果射出的箭杀死了敌人，则应如下输出：
000:35 blue dragon 1 shot and killed red lion 4
表示在 0点35分，编号为1的蓝魔dragon武士射出一支箭，杀死了编号为4的红魔lion。
5)武士使用bomb
输出样例： 000:38 blue dragon 1 used a bomb and killed red lion 7
表示在 0点38分，编号为1的蓝魔dragon武士用炸弹和编号为7的红魔lion同归于尽。
6) 武士主动进攻
输出样例：000:40 red iceman 1 attacked blue lion 1 in city 1 with 20 elements and force 30
表示在0点40分，1号城市中，红魔1号武士iceman 进攻蓝魔1号武士lion,在发起进攻前，红魔1号武士iceman生命值为20，攻击力为 30
7) 武士反击
输出样例：001:40 blue dragon 2 fought back against red lion 2 in city 1
表示在1点40分，1号城市中，蓝魔2号武士dragon反击红魔2号武士lion
8) 武士战死
输出样例：001:40 red lion 2 was killed in city 1
被箭射死的武士就不会有这一条输出。
9) 武士欢呼
输出样例：003:40 blue dragon 2 yelled in city 4
10) 武士获取生命元( elements )
输出样例：001:40 blue dragon 2 earned 10 elements for his headquarter
输出不包括在30分不是通过战斗获取的elements
11) 旗帜升起
输出样例：004:40 blue flag raised in city 4
12) 武士抵达敌军司令部
输出样例：001:10 red iceman 1 reached blue headquarter with 20 elements and force 30
(此时他生命值为20,攻击力为30）对于iceman,输出的生命值和攻击力应该是变化后的数值
13) 司令部被占领
输出样例：003:10 blue headquarter was taken
14)司令部报告生命元数量
000:50 100 elements in red headquarter
000:50 120 elements in blue headquarter
表示在0点50分，红方司令部有100个生命元，蓝方有120个
15)武士报告武器情况
000:55 blue wolf 2 has arrow(2),bomb,sword(23)
000:55 blue wolf 4 has no weapon
000:55 blue wolf 5 has sword(20)
表示在0点55分，蓝魔2号武士wolf有一支arrow（这支arrow还可以用2次），一个bomb，还有一支攻击力为23的sword。
蓝魔4号武士wolf没武器。
蓝魔5号武士wolf有一支攻击力为20的sword。
交代武器情况时，次序依次是：arrow,bomb,sword。如果没有某种武器，某种武器就不用提。报告时，先按从西向东的顺序所有的红武士报告，然后再从西向东所有的蓝武士报告。
输出事件时：
首先按时间顺序输出；
同一时间发生的事件，按发生地点从西向东依次输出. 武士前进的事件, 算是发生在目的地。
在一次战斗中有可能发生上面的 6 至 11 号事件。这些事件都算同时发生，其时间就是战斗开始时间。一次战斗中的这些事件，序号小的应该先输出。
两个武士同时抵达同一城市，则先输出红武士的前进事件，后输出蓝武士的。
显然，13号事件发生之前的一瞬间一定发生了12号事件。输出时，这两件事算同一时间发生，但是应先输出12号事件
虽然任何一方的司令部被占领之后，就不会有任何事情发生了。但和司令部被占领同时发生的事件，全都要输出。
输入
第一行是t,代表测试数据组数
每组样例共三行。
第一行，五个整数 M,N,R,K, T。其含义为：
每个司令部一开始都有M个生命元( 1 <= M <= 10000)
两个司令部之间一共有N个城市( 1 <= N <= 20 )
arrow的攻击力是R
lion每经过一场未能杀死敌人的战斗，忠诚度就降低K。
要求输出从0时0分开始，到时间T为止(包括T) 的所有事件。T以分钟为单位，0 <= T <= 5000
第二行：五个整数，依次是 dragon 、ninja、iceman、lion、wolf 的初始生命值。它们都大于0小于等于10000
第三行：五个整数，依次是 dragon 、ninja、iceman、lion、wolf 的攻击力。它们都大于0小于等于10000
输出
对每组数据，先输出一行：
Case n:
如对第一组数据就输出 Case1:
然后按恰当的顺序和格式输出到时间T为止发生的所有事件。每个事件都以事件发生的时间开头，时间格式是“时: 分”，“时”有三位，“分”有两位。
样例输入
1 20 1 10 10 1000 20 20 30 10 20 5 5 5 5 5
样例输出
Case 1: 000:00 blue lion 1 born Its loyalty is 10 000:10 blue lion 1 marched to city 1 with 10 elements and force 5 000:30 blue lion 1 earned 10 elements for his headquarter 000:50 20 elements in red headquarter 000:50 20 elements in blue headquarter 000:55 blue lion 1 has no weapon 001:00 blue dragon 2 born Its morale is 0.00 001:10 blue lion 1 reached red headquarter with 10 elements and force 5 001:10 blue dragon 2 marched to city 1 with 20 elements and force 5 001:30 blue dragon 2 earned 10 elements for his headquarter 001:50 20 elements in red headquarter 001:50 10 elements in blue headquarter 001:55 blue lion 1 has no weapon 001:55 blue dragon 2 has arrow(3) 002:10 blue dragon 2 reached red headquarter with 20 elements and force 5 002:10 red headquarter was taken
分析
终极版中武士的攻击方式不再是循环攻击直到死亡，这比三的设定要简单一些。但是，终极版新增了旗子升起，并且炸弹的使用，攻击的顺序，wolf抢武器的规则，dragon的yell，lion的loyalty变化规则都做了修改，我感觉是更复杂了一些。
我保留了三中的那些类，修改了武士类中一些函数的输出，武器类和城市类也做了比较大的改变，a_round类中的事件函数大改。总体思路和三一样，都是维护一条游戏进行的时间线，在相应的时间点输出事件，根据事件来对现有的武士序列，城市序列维护，对武士的武器情况一一更改等等。
我踩的坑点：
如果一个城市中双方都被箭射死了，那么不算平局；
炸弹同归于尽之后不能直接把指针置为nullptr，否则会数据丢失；
dragon只有在士气大于0.8的时候才会yell；
犒赏8个生命元，回传收集到的生命元要同时进行，在一个城市中先进行前者；
同一种颜色的旗子不能反复连续升起；
在地方司令部无所事事的武士也应该报告武器情况；
代码
#include<bits/stdc++.h>
using namespace std;
int cases,M,N,R,K,T;
int d_hp,n_hp,i_hp,l_hp,w_hp;
int d_attack,n_attack,i_attack,l_attack,w_attack;
int timeclock=0;
bool gameover=false;
void get_data(){
cin>>M;
cin>>N;
cin>>R;
cin>>K;
cin>>T;
cin>>d_hp>>n_hp>>i_hp>>l_hp>>w_hp;
cin>>d_attack>>n_attack>>i_attack>>l_attack>>w_attack;
return ;
}
class headquarter{
public:
int color;//0代表红方，1代表蓝方
int num;
int total_hp;
int enemy=0;
string red_kind,blue_kind;
headquarter(){};
//红方应该制造的武士
void set_red_kind(){
switch(num%5){
case 1:red_kind="iceman";break;
case 2:red_kind="lion";break;
case 3:red_kind="wolf";break;
case 4:red_kind="ninja";break;
case 0:red_kind="dragon";break;
}
return ;
}
//蓝方应该制造的武士
void set_blue_kind(){
switch(num%5){
case 1:blue_kind="lion";break;
case 2:blue_kind="dragon";break;
case 3:blue_kind="ninja";break;
case 4:blue_kind="iceman";break;
case 0:blue_kind="wolf";break;
}
return ;
}
//报告司令部生命元数量
void report_element(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":50 "<<total_hp<<" elements in ";
if (color) cout<<"blue ";
else cout<<"red ";
cout<<"headquarter"<<endl;
return ;
}
//报告司令部被占领
void report_occupy(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":10 ";
if (color) cout<<"blue ";
else cout<<"red ";
cout<<"headquarter was taken"<<endl;
return ;
}
};
class weapon{
public:
int kind;
int attack;
int use_time;
string name;
weapon(string _name,int _attack=0):name(_name){
if (name=="sword"){
kind=0;
use_time=INT32_MAX;
attack=_attack*2/10;
}
else if (name=="bomb"){
kind=1;
use_time=1;
attack=INT32_MAX;
}
else {
kind=2;
use_time=3;
attack=R;
}
}
bool check_sword(){
if (attack==0) return true;
else return false;
}
void update_sword(){
attack=attack*8/10;
return ;
}
};
bool cmp_weapon(const weapon&a,const weapon&b){
return a.kind>b.kind;
}
class warrior{
public:
string kind;
string name;
int loyalty;
int step=0;
int position;
int hp;
int attack;
int num;
bool live=true;
double morale;
bool has_arrive=false;
bool die_of_arrow=false;
bool die_of_bomb=false;
bool need_to_reward=false;
vector<weapon>weapons;
warrior(){};
void born(int hour,double marale=0,int loyalty=0){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":00 ";
cout<<kind<<" "<<name<<" "<<num<<" born"<<endl;
if (name=="lion"){
cout<<"Its loyalty is "<<loyalty<<endl;
}
else if (name=="dragon"){
cout<<"Its morale is "<<setprecision(2)<<fixed<<morale<<endl;
}
return ;
}
virtual void flee(int hour) {};
virtual void yell(int hour,int city_num) {};
virtual void morale_change(bool win_or_not){};
virtual void loyalty_change(bool win_or_not){};
virtual void grab(int hour,warrior*w){};
//移动至下一座城市
void arrive(int hour,int city_num){
position=city_num;
if (name=="iceman"){
step++;
if (step==2){
hp-=9;
attack+=20;
step=0;
if (hp<=0) hp=1;
}
}
if (city_num==N+1||city_num==0) return ;
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":10 "<<kind<<" "<<name<<" "<<num<<" marched to city "<<city_num<<" with "<<hp<<" elements and force "<<attack<<endl;
return ;
}
//检查武士是否存活
bool check_die(){
if (hp<=0) return false;
else return true;
}
//武士报告情况
void report_current(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":55 "<<kind<<" "<<name<<" "<<num<<" has ";
for (int i=0;i<weapons.size();++i){
if (weapons[i].attack==0){
weapons.erase(weapons.begin()+i);
}
}
if (weapons.empty()) cout<<"no weapon"<<endl;
else {
sort(weapons.begin(), weapons.end(), cmp_weapon);
for (int i=0;i<weapons.size();++i){
if (i) cout<<',';
cout<<weapons[i].name;
if (weapons[i].name=="sword"){
cout<<"("<<weapons[i].attack<<")";
}
else if (weapons[i].name=="bomb"){
continue;
}
else if(weapons[i].name=="arrow"){
cout<<"("<<weapons[i].use_time<<")";
}
}
cout<<endl;
}
return ;
}
//了解武士的武器情况
bool has_sword(){
if (weapons.empty()) return false;
for (int i=0;i<weapons.size();++i){
if (weapons[i].kind==0) return true;
}
return false;
}
bool has_bomb(){
if (weapons.empty()) return false;
for (int i=0;i<weapons.size();++i){
if (weapons[i].kind==1) return true;
}
return false;
}
bool has_arrow(){
if (weapons.empty()) return false;
for (int i=0;i<weapons.size();++i){
if (weapons[i].kind==2) return true;
}
return false;
}
};
class dragon : public warrior{
public:
dragon(int d_hp,int d_attack,int _num,string _kind,int _position,double _morale,string _name="dragon"){
hp=d_hp;
attack=d_attack;
num=_num;
kind=_kind;
name=_name;
morale=_morale;
position=_position;
}
//修改士气
void morale_change(bool win_or_not){
if (win_or_not) morale+=0.2;
else morale-=0.2;
return ;
}
//dragon欢呼
void yell(int hour,int city_num){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":40 "<<kind<<" dragon "<<num<<" yelled in city "<<city_num<<endl;
return ;
}
void get_weapon(int num){
int ID=num%3;
switch(ID)
{
case 0:weapons.push_back(weapon("sword",d_attack));break;
case 1:weapons.push_back(weapon("bomb"));break;
case 2:weapons.push_back(weapon("arrow"));break;
}
return;
}
};
bool cmp_for_ninja(const weapon&a,const weapon&b){
return a.kind>b.kind;
}
class ninja : public warrior{
public:
ninja(int n_hp,int n_attack,int _num,string _kind,int _position,string _name="ninja"){
hp=n_hp;
attack=n_attack;
num=_num;
kind=_kind;
name=_name;
position=_position;
}
void get_weapon(int num){
int ID=num%3;
switch(ID)
{
case 0:weapons.push_back(weapon("sword",n_attack));break;
case 1:weapons.push_back(weapon("bomb"));break;
case 2:weapons.push_back(weapon("arrow"));break;
}
ID=(num+1)%3;
switch(ID)
{
case 0:weapons.push_back(weapon("sword",n_attack));break;
case 1:weapons.push_back(weapon("bomb"));break;
case 2:weapons.push_back(weapon("arrow"));break;
}
return ;
sort(weapons.begin(),weapons.end(),cmp_for_ninja);
}
};
class iceman : public warrior{
public:
iceman(int i_hp,int i_attack,int _num,string _kind,int _position,string _name="iceman"){
hp=i_hp;
attack=i_attack;
num=_num;
kind=_kind;
name=_name;
position=_position;
}
void get_weapon(int num){
int ID=num%3;
switch(ID)
{
case 0:weapons.push_back(weapon("sword",i_attack));break;
case 1:weapons.push_back(weapon("bomb"));break;
case 2:weapons.push_back(weapon("arrow"));break;
}
return ;
}
};
class lion : public warrior{
public:
lion(int l_hp,int l_attack,int _num,string _kind,int _position,int _loyalty,string _name="lion"){
hp=l_hp;
attack=l_attack;
num=_num;
kind=_kind;
name=_name;
loyalty=_loyalty;
position=_position;
}
void loyalty_change(bool win_or_not){
if (win_or_not==false) loyalty-=K;
return ;
}
//lion逃跑
void flee(int hour){
//如果忠诚度满足要求那么就什么都不做
if (loyalty<=0) {
live=false;
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":05 "<<kind<<" lion "<<num<<" ran away"<<endl;
}
return ;
}
};
bool cmp_for_wolf(const weapon&a,const weapon &b){
if (a.kind>b.kind) return true;
else return false;
}
class wolf : public warrior{
public:
wolf(int w_hp,int w_attack,int _num,string _kind,int _position,string _name="wolf"){
hp=w_hp;
attack=w_attack;
num=_num;
kind=_kind;
name=_name;
position=_position;
}
//wolf抢武器
void grab(int hour,warrior*w){
if (w->weapons.empty()) return ;
for (int i=0;i<w->weapons.size();++i){
int id=w->weapons[i].kind;
bool flag=true;
for (int j=0;j<weapons.size();++j){
if (weapons[j].kind==id){
flag=false;
break;
}
}
if (flag==false) continue;
weapons.push_back(w->weapons[i]);
}
sort(weapons.begin(),weapons.end(),cmp_for_wolf);
}
};
class city{
public:
warrior* red=nullptr;
warrior* blue=nullptr;
int ID_city=0;
string flag="none";
int elements=0;
int cnt_red=0,cnt_blue=0;
bool cnt_inc=false;
city(){};
void inc_elements(){
elements+=10;
return ;
}
int get_elements(){
int t=elements;
elements=0;
return t;
}
//使用bomb同归于尽
void report_use_bomb_red(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":38 red "<<red->name<<" "<<red->num<<" used a bomb and killed blue "<<blue->name<<" "<<blue->num<<endl;
return ;
}
void report_use_bomb_blue(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":38 blue "<<blue->name<<" "<<blue->num<<" used a bomb and killed red "<<red->name<<" "<<red->num<<endl;
return ;
}
//主动进攻
void attacked_red(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":40 red "<<red->name<<" "<<red->num<<" attacked blue "<<blue->name<<" "<<blue->num<<" in city "<<ID_city<<" with ";
cout<<red->hp<<" elements and force "<<red->attack<<endl;
return ;
}
void attacked_blue(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":40 blue "<<blue->name<<" "<<blue->num<<" attacked red "<<red->name<<" "<<red->num<<" in city "<<ID_city<<" with ";
cout<<blue->hp<<" elements and force "<<blue->attack<<endl;
return ;
}
//武士反击
void attacked_back_red(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":40 red "<<red->name<<" "<<red->num<<" fought back against blue "<<blue->name<<" "<<blue->num<<" in city "<<ID_city<<endl;
return ;
}
void attacked_back_blue(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":40 blue "<<blue->name<<" "<<blue->num<<" fought back against red "<<red->name<<" "<<red->num<<" in city "<<ID_city<<endl;
return ;
}
//武士战死
void die_red(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":40 red "<<red->name<<" "<<red->num<<" was killed in city "<<ID_city<<endl;
return ;
}
void die_blue(int hour){
if (hour>99) cout<<hour;
else if (hour>9) cout<<0<<hour;
else cout<<"00"<<hour;
cout<<":40 blue "<<blue->name<<" "<<blue->num<<" was killed in city "<<ID_city<<endl;
return ;
}
};
bool cmp_for_city(warrior *p, warrior *q){
int pposition=0,qposition=0;
if (p->kind=="red") pposition=p->position+1;
else if (p->kind=="blue") pposition=p->position-1;
if (q->kind=="red") qposition=q->position+1;
else if (q->kind=="blue") qposition=q->position-1;
if (pposition==qposition) return p->kind=="red";
return pposition<qposition;
}//把城市按照从西到东排列(march)
bool cmp_for_report(warrior*p,warrior*q){
return p->position<q->position;
}
class a_round{
public:
//两方制造的武士序列
vector<warrior*>red_warrior;
vector<warrior*>blue_warrior;
//两方司令部
headquarter red;
headquarter blue;
//司令部之间的城市
city *cities=new city[25];
a_round(){
red.color=0,blue.color=1;
red.total_hp=blue.total_hp=M;
red.num=blue.num=1;
for (int i=0;i<=N+1;i++){
cities[i].ID_city=i;
}
}
void warrior_born(){
//红色
red.set_red_kind();
if (red.red_kind=="dragon"){
if (red.total_hp<d_hp) {
goto loop;
}
else {
dragon* d=new dragon(d_hp,d_attack,red.num,"red",0,(double)(red.total_hp-d_hp)/d_hp);
d->get_weapon(d->num);
d->born(timeclock,d->morale);
red_warrior.push_back(d);
red.total_hp-=d_hp;
cities[0].red=d;
red.num++;
}
}
else if (red.red_kind=="ninja"){
if (red.total_hp<i_hp){
goto loop;
}
else {
ninja* n=new ninja(n_hp,n_attack,red.num,"red",0);
n->get_weapon(n->num);
n->born(timeclock);
red_warrior.push_back(n);
red.total_hp-=n_hp;
cities[0].red=n;
red.num++;
}
}
else if (red.red_kind=="iceman"){
if (red.total_hp<i_hp){
goto loop;
}
else {
iceman* i=new iceman(i_hp,i_attack,red.num,"red",0);
i->get_weapon(i->num);
i->born(timeclock);
red_warrior.push_back(i);
red.total_hp-=i_hp;
cities[0].red=i;
red.num++;
}
}
else if (red.red_kind=="lion"){
if (red.total_hp<l_hp){
goto loop;
}
else {
lion* l=new lion(l_hp,l_attack,red.num,"red",0,red.total_hp-l_hp);
l->born(timeclock,0,l->loyalty);
red_warrior.push_back(l);
red.total_hp-=l_hp;
cities[0].red=l;
red.num++;
}
}
else if (red.red_kind=="wolf"){
if (red.total_hp<w_hp){
goto loop;
}
else {
wolf* w=new wolf(w_hp,w_attack,red.num,"red",0);
w->born(timeclock);
red_warrior.push_back(w);
red.total_hp-=w_hp;
cities[0].red=w;
red.num++;
}
}
loop:;
//蓝色
blue.set_blue_kind();
if (blue.blue_kind=="dragon"){
if (blue.total_hp<d_hp) {
return ;
}
else {
dragon* d=new dragon(d_hp,d_attack,blue.num,"blue",N+1,(double)(blue.total_hp-d_hp)/d_hp);
d->get_weapon(d->num);
d->born(timeclock,d->morale);
blue_warrior.push_back(d);
blue.total_hp-=d_hp;
cities[N+1].blue=d;
blue.num++;
}
}
else if (blue.blue_kind=="ninja"){
if (blue.total_hp<i_hp){
return ;
}
else {
ninja* n=new ninja(n_hp,n_attack,blue.num,"blue",N+1);
n->get_weapon(n->num);
n->born(timeclock);
blue_warrior.push_back(n);
blue.total_hp-=n_hp;
cities[N+1].blue=n;
blue.num++;
}
}
else if (blue.blue_kind=="iceman"){
if (blue.total_hp<i_hp){
return ;
}
else {
iceman* i=new iceman(i_hp,i_attack,blue.num,"blue",N+1);
i->get_weapon(i->num);
i->born(timeclock);
blue_warrior.push_back(i);
blue.total_hp-=i_hp;
cities[N+1].blue=i;
blue.num++;
}
}
else if (blue.blue_kind=="lion"){
if (blue.total_hp<l_hp){
return ;
}
else {
lion* l=new lion(l_hp,l_attack,blue.num,"blue",N+1,blue.total_hp-l_hp);
l->born(timeclock,0,l->loyalty);
blue_warrior.push_back(l);
blue.total_hp-=l_hp;
cities[N+1].blue=l;
blue.num++;
}
}
else if (blue.blue_kind=="wolf"){
if (blue.total_hp<w_hp){
return ;
}
else {
wolf* w=new wolf(w_hp,w_attack,blue.num,"blue",N+1);
w->born(timeclock);
blue_warrior.push_back(w);
blue.total_hp-=w_hp;
cities[N+1].blue=w;
blue.num++;
}
}
return ;
}
void lion_flee(){
for (int i=0;i<red_warrior.size();i++){
if (red_warrior[i]->name=="lion") {
red_warrior[i]->flee(timeclock);
if (red_warrior[i]->live==false){
red_warrior.erase(red_warrior.begin()+i);
i--;
}
}
}
for (int j=0;j<blue_warrior.size();j++){
if (blue_warrior[j]->name=="lion") {
blue_warrior[j]->flee(timeclock);
if (blue_warrior[j]->live==false){
blue_warrior.erase(blue_warrior.begin()+j);
j--;
}
}
}
return ;
}
void march(){
vector<warrior*>total=red_warrior;
total.insert(total.end(),blue_warrior.begin(),blue_warrior.end());
sort(total.begin(),total.end(),cmp_for_city);
for (int i = 0; i <= N+1; ++i)
{
cities[i].red=cities[i].blue=nullptr;
}
for (int i=0;i<total.size();i++){
if (total[i]->kind=="red"){
if (total[i]->position==N+1) continue;
if (total[i]->position==N){
if (total[i]->has_arrive) continue;
blue.enemy++;
//
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<"0"<<timeclock;
else cout<<"00"<<timeclock;
cout<<":10 "<<"red "<<total[i]->name<<" "<<total[i]->num<<" reached blue headquarter with ";
if (total[i]->name=="iceman"&&total[i]->step==1) {total[i]->hp-=9;total[i]->attack+=20;}
cout<<total[i]->hp<<" elements and force "<<total[i]->attack<<endl;
total[i]->has_arrive=true;
//
if (blue.enemy==2){
blue.report_occupy(timeclock);
gameover=true;
}
// continue;
}
total[i]->arrive(timeclock,total[i]->position+1);
cities[total[i]->position].red=total[i];
}
else {
if (total[i]->position==0) continue;
//cities[total[i]->position].blue=nullptr;
if (total[i]->position==1){
if (total[i]->has_arrive) continue;
red.enemy++;
//
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<"0"<<timeclock;
else cout<<"00"<<timeclock;
cout<<":10 blue "<<total[i]->name<<" "<<total[i]->num<<" reached red headquarter with ";
cout<<total[i]->hp<<" elements and force "<<total[i]->attack<<endl;
total[i]->has_arrive=true;
//
if (red.enemy==2){
red.report_occupy(timeclock);
gameover=true;
}
// continue;
}
total[i]->arrive(timeclock,total[i]->position-1);
cities[total[i]->position].blue=total[i];
}
}
return ;
}
void generate_elements(){
for (int i=1;i<=N;i++){
cities[i].inc_elements();
}
return ;
}
void get_elements_in_a_empty_city(){
for (int i=1;i<=N;i++){
if (cities[i].red==nullptr&&cities[i].blue!=nullptr){
int m=cities[i].get_elements();
blue.total_hp+=m;
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<0<<timeclock;
else cout<<"00"<<timeclock;
cout<<":30 blue "<<cities[i].blue->name<<" "<<cities[i].blue->num<<" earned "<<m<<" elements for his headquarter"<<endl;
}
else if (cities[i].blue==nullptr&&cities[i].red!=nullptr){
int m=cities[i].get_elements();
red.total_hp+=m;
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<0<<timeclock;
else cout<<"00"<<timeclock;
cout<<":30 red "<<cities[i].red->name<<" "<<cities[i].red->num<<" earned "<<m<<" elements for his headquarter"<<endl;
}
else continue;
}
return ;
}
void arrow_attack(){
for (int i=0;i<=N+1;++i){
if (cities[i].red!=nullptr&&cities[i].red->has_arrow()){
if (i<=N-1&&cities[i+1].blue!=nullptr){
for (int j=0;j<cities[i].red->weapons.size();++j){
if (cities[i].red->weapons[j].kind==2){
cities[i].red->weapons[j].use_time--;
cities[i+1].blue->hp-=cities[i].red->weapons[j].attack;
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<0<<timeclock;
else cout<<"00"<<timeclock;
cout<<":35 red "<<cities[i].red->name<<" "<<cities[i].red->num<<" shot";
if (cities[i+1].blue->hp<=0){
cout<<" and killed blue "<<cities[i+1].blue->name<<" "<<cities[i+1].blue->num;
cities[i+1].blue->die_of_arrow=true;
cities[i+1].blue->live=false;
}
cout<<endl;
}
}
}
}
if (cities[i].blue!=nullptr&&cities[i].blue->has_arrow()){
if (i>=2&&cities[i-1].red!=nullptr){
for (int j=0;j<cities[i].blue->weapons.size();++j){
if (cities[i].blue->weapons[j].kind==2){
cities[i].blue->weapons[j].use_time--;
cities[i-1].red->hp-=cities[i].blue->weapons[j].attack;
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<0<<timeclock;
else cout<<"00"<<timeclock;
cout<<":35 blue "<<cities[i].blue->name<<" "<<cities[i].blue->num<<" shot";
if (cities[i-1].red->hp<=0){
cout<<" and killed red "<<cities[i-1].red->name<<" "<<cities[i-1].red->num;
cities[i-1].red->die_of_arrow=true;
cities[i-1].red->live=false;
}
cout<<endl;
}
}
}
}
}
return ;
}
void update_arrow(){
for (int i=0;i<red_warrior.size();i++){
for (int j=0;j<red_warrior[i]->weapons.size();++j){
if (red_warrior[i]->weapons[j].kind==2){
if (red_warrior[i]->weapons[j].use_time==0){
red_warrior[i]->weapons.erase(red_warrior[i]->weapons.begin()+j);
j--;
}
}
}
}
for (int i=0;i<blue_warrior.size();i++){
for (int j=0;j<blue_warrior[i]->weapons.size();++j){
if (blue_warrior[i]->weapons[j].kind==2){
if (blue_warrior[i]->weapons[j].use_time==0){
blue_warrior[i]->weapons.erase(blue_warrior[i]->weapons.begin()+j);
j--;
}
}
}
}
return ;
}
void bomb_time(){
for (int i=1;i<=N;++i){
if (cities[i].red!=nullptr&&cities[i].blue!=nullptr&&cities[i].red->live&&cities[i].blue->live){
if (cities[i].red->has_bomb()){
if (cities[i].flag=="red"||(cities[i].flag=="none"&&i%2==1)){
int power=cities[i].red->attack;
for (int j=0;j<cities[i].red->weapons.size();++j){
if (cities[i].red->weapons[j].kind==0){
power+=cities[i].red->weapons[j].attack;
break;
}
}
if (power<cities[i].blue->hp){
if (cities[i].blue->name=="ninja"){
continue;
}
int opp_power=cities[i].blue->attack*5/10;
for (int j=0;j<cities[i].blue->weapons.size();++j){
if (cities[i].blue->weapons[j].kind==0){
opp_power+=cities[i].blue->weapons[j].attack;
break;
}
}
if (opp_power>=cities[i].red->hp){
cities[i].report_use_bomb_red(timeclock);
cities[i].red->die_of_bomb=cities[i].blue->die_of_bomb=true;
cities[i].red->live=cities[i].blue->live=false;
continue;
}
}
}
else {
int power=cities[i].blue->attack;
for (int j=0;j<cities[i].blue->weapons.size();++j){
if (cities[i].blue->weapons[j].kind==0){
power+=cities[i].blue->weapons[j].attack;
break;
}
}
if (power>=cities[i].red->hp){
cities[i].report_use_bomb_red(timeclock);
cities[i].red->die_of_bomb=cities[i].blue->die_of_bomb=true;
cities[i].red->live=cities[i].blue->live=false;
continue ;
}
}
}
loop1:;
if (cities[i].blue->has_bomb()){
if (cities[i].flag=="blue"||(cities[i].flag=="none"&&i%2==0)){
int power=cities[i].blue->attack;
for (int j=0;j<cities[i].blue->weapons.size();++j){
if (cities[i].blue->weapons[j].kind==0){
power+=cities[i].blue->weapons[j].attack;
break;
}
}
if (power<cities[i].red->hp){
if (cities[i].red->name=="ninja"){
goto loop2;
}
int opp_power=cities[i].red->attack*5/10;
for (int j=0;j<cities[i].red->weapons.size();++j){
if (cities[i].red->weapons[j].kind==0){
opp_power+=cities[i].red->weapons[j].attack;
break;
}
}
if (opp_power>=cities[i].blue->hp){
cities[i].report_use_bomb_blue(timeclock);
cities[i].red->die_of_bomb=cities[i].blue->die_of_bomb=true;
cities[i].red->live=cities[i].blue->live=false;
goto loop2; ;
}
}
}
else {
int power=cities[i].red->attack;
for (int j=0;j<cities[i].red->weapons.size();++j){
if (cities[i].red->weapons[j].kind==0){
power+=cities[i].red->weapons[j].attack;
break;
}
}
if (power>=cities[i].blue->hp){
cities[i].report_use_bomb_blue(timeclock);
cities[i].red->die_of_bomb=cities[i].blue->die_of_bomb=true;
cities[i].red->live=cities[i].blue->live=false;
goto loop2 ;
}
}
}
}
loop2:;
}
return ;
}
void report_headquarter_elements(){
red.report_element(timeclock);
blue.report_element(timeclock);
return ;
}
void check_warrior_live(){
for (int i=0;i<red_warrior.size();i++){
if (red_warrior[i]==nullptr) {
red_warrior.erase(red_warrior.begin()+i);
i--;
}
else if (red_warrior[i]->die_of_bomb||red_warrior[i]->live==false){
red_warrior.erase(red_warrior.begin()+i);
i--;
}
}
for (int j=0;j<blue_warrior.size();j++){
if (blue_warrior[j]==nullptr) {
blue_warrior.erase(blue_warrior.begin()+j);
j--;
}
else if (blue_warrior[j]->die_of_bomb||blue_warrior[j]->live==false){
blue_warrior.erase(blue_warrior.begin()+j);
j--;
}
}
return ;
}
void report_warrior_weapons(){
sort(red_warrior.begin(),red_warrior.end(),cmp_for_report);
sort(blue_warrior.begin(),blue_warrior.end(),cmp_for_report);
for (int i=0;i<red_warrior.size();++i){
red_warrior[i]->report_current(timeclock);
}
for (int i=0;i<blue_warrior.size();++i){
blue_warrior[i]->report_current(timeclock);
}
return ;
}
void fight_time(){
for (int i=1;i<=N;i++){
if (cities[i].red==nullptr||cities[i].blue==nullptr) continue;
bool loop=false;
if (cities[i].red->live==false||cities[i].blue->live==false){
loop=true;
}
int red_hp_before=cities[i].red->hp;
int blue_hp_before=cities[i].blue->hp;
if (loop==false&&(cities[i].flag=="red"||(cities[i].flag=="none"&&i%2==1))){
int power=cities[i].red->attack;
for (int j=0;j<cities[i].red->weapons.size();j++){
if (cities[i].red->weapons[j].kind==0){
power+=cities[i].red->weapons[j].attack;
cities[i].red->weapons[j].update_sword();
if (cities[i].red->weapons[j].check_sword()){
cities[i].red->weapons.erase(cities[i].red->weapons.begin()+j);
}
break;
}
}
cities[i].attacked_red(timeclock);
cities[i].blue->hp-=power;
if (cities[i].blue->hp<=0) {cities[i].blue->live=false;cities[i].die_blue(timeclock);}
if (cities[i].blue->live&&cities[i].blue->name!="ninja"){
power=cities[i].blue->attack/2;
for (int j=0;j<cities[i].blue->weapons.size();++j){
if (cities[i].blue->weapons[j].kind==0){
power+=cities[i].blue->weapons[j].attack;
cities[i].blue->weapons[j].update_sword();
if (cities[i].blue->weapons[j].check_sword()){
cities[i].blue->weapons.erase(cities[i].blue->weapons.begin()+j);
}
break;
}
}
cities[i].attacked_back_blue(timeclock);
cities[i].red->hp-=power;
if (cities[i].red->hp<=0) {cities[i].red->live=false;cities[i].die_red(timeclock);}
}
}
else if (loop==false&&(cities[i].flag=="blue"||(cities[i].flag=="none"&&i%2==0))){
int power=cities[i].blue->attack;
for (int j=0;j<cities[i].blue->weapons.size();++j){
if (cities[i].blue->weapons[j].kind==0){
power+=cities[i].blue->weapons[j].attack;
cities[i].blue->weapons[j].update_sword();
if (cities[i].blue->weapons[j].check_sword()){
cities[i].blue->weapons.erase(cities[i].blue->weapons.begin()+j);
}
break;
}
}
cities[i].attacked_blue(timeclock);
cities[i].red->hp-=power;
if (cities[i].red->hp<=0) {cities[i].red->live=false;cities[i].die_red(timeclock);}
if (cities[i].red->live&&cities[i].red->name!="ninja"){
power=cities[i].red->attack/2;
for (int j=0;j<cities[i].red->weapons.size();++j){
if (cities[i].red->weapons[j].kind==0){
power+=cities[i].red->weapons[j].attack;
cities[i].red->weapons[j].update_sword();
if (cities[i].red->weapons[j].check_sword()){
cities[i].red->weapons.erase(cities[i].red->weapons.begin()+j);
}
break;
}
}
cities[i].attacked_back_red(timeclock);
cities[i].blue->hp-=power;
if (cities[i].blue->hp<=0) {cities[i].blue->live=false;cities[i].die_blue(timeclock);}
}
}
if (cities[i].red->live==false&&cities[i].blue->live==false){
continue;
}
else if (cities[i].red->live&&cities[i].blue->live){
cities[i].cnt_blue=0;
cities[i].cnt_red=0;
if (cities[i].red->name=="dragon"){
cities[i].red->morale_change(false);
if (cities[i].flag=="red"||(cities[i].flag=="none"&&i%2==1)){
if (cities[i].red->morale>0.8){
cities[i].red->yell(timeclock,i);
}
}
}
else if (cities[i].red->name=="lion"){
cities[i].red->loyalty_change(false);
}
if (cities[i].blue->name=="dragon"){
cities[i].blue->morale_change(false);
if (cities[i].flag=="blue"||(cities[i].flag=="none"&&i%2==0)){
if (cities[i].blue->morale>0.8){
cities[i].blue->yell(timeclock,i);
}
}
}
else if (cities[i].blue->name=="lion"){
cities[i].blue->loyalty_change(false);
}
}
else if (cities[i].red->live&&cities[i].blue->live==false){
cities[i].cnt_red++;
cities[i].cnt_blue=0;
if (cities[i].red->name=="dragon"){
cities[i].red->morale_change(true);
if (cities[i].flag=="red"||(cities[i].flag=="none"&&i%2==1)){
if (cities[i].red->morale>0.8){
cities[i].red->yell(timeclock,i);
}
}
}
else if (cities[i].red->name=="lion"){
cities[i].red->loyalty_change(true);
}
else if (cities[i].red->name=="wolf"){
cities[i].red->grab(timeclock,cities[i].blue);
}
if (cities[i].blue->name=="lion"&&loop==false){
cities[i].red->hp+=blue_hp_before;
}
int m=cities[i].elements;
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<0<<timeclock;
else cout<<"00"<<timeclock;
cout<<":40 red "<<cities[i].red->name<<" "<<cities[i].red->num<<" earned "<<m<<" elements for his headquarter"<<endl;
}
else {
cities[i].cnt_blue++;
cities[i].cnt_red=0;
if (cities[i].blue->name=="dragon"){
cities[i].blue->morale_change(true);
if (cities[i].flag=="blue"||(cities[i].flag=="none"&&i%2==0)){
if (cities[i].blue->morale>0.8){
cities[i].blue->yell(timeclock,i);
}
}
}
else if (cities[i].blue->name=="lion"){
cities[i].blue->loyalty_change(true);
}
else if (cities[i].blue->name=="wolf"){
cities[i].blue->grab(timeclock,cities[i].red);
}
if (cities[i].red->name=="lion"&&loop==false){
cities[i].blue->hp+=red_hp_before;
}
int m=cities[i].elements;
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<0<<timeclock;
else cout<<"00"<<timeclock;
cout<<":40 blue "<<cities[i].blue->name<<" "<<cities[i].blue->num<<" earned "<<m<<" elements for his headquarter"<<endl;
}
if (cities[i].cnt_blue==2&&cities[i].flag!="blue"){
cities[i].flag="blue";
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<"0"<<timeclock;
else cout<<"00"<<timeclock;
cout<<":40 blue flag raised in city "<<i<<endl;
}
if (cities[i].cnt_red==2&&cities[i].flag!="red"){
cities[i].flag="red";
if (timeclock>99) cout<<timeclock;
else if (timeclock>9) cout<<"0"<<timeclock;
else cout<<"00"<<timeclock;
cout<<":40 red flag raised in city "<<i<<endl;
}
}
for (int i=1;i<=N;++i){
if (cities[i].red==nullptr||cities[i].blue==nullptr) continue;
if (cities[i].red->live==false&&cities[i].blue->live){
if (blue.total_hp>=8){
cities[i].blue->hp+=8;
blue.total_hp-=8;
}
int m=cities[i].get_elements();
blue.total_hp+=m;
}
}
for (int i=N;i>=1;i--){
if (cities[i].red==nullptr||cities[i].blue==nullptr) continue;
if (cities[i].red->live&&cities[i].blue->live==false){
if (red.total_hp>=8){
cities[i].red->hp+=8;
red.total_hp-=8;
}
int m=cities[i].get_elements();
red.total_hp+=m;
}
}
for (int i=1;i<=N;++i){
for (int j=0;j<red_warrior.size();j++){
if (red_warrior[j]==nullptr) continue;
if (red_warrior[j]->position==i){
red_warrior[j]=cities[i].red;
break;
}
}
for (int j=0;j<blue_warrior.size();j++){
if (blue_warrior[j]==nullptr) continue;
if (blue_warrior[j]->position==i){
blue_warrior[j]=cities[i].blue;
break;
}
}
}
return ;
}
//每一句游戏的时间线
void start(){
while(timeclock*60<=T){
//00:
warrior_born();
//05:
if (timeclock*60+5>T) break;
lion_flee();
//10:
if (timeclock*60+10>T) break;
march();
if (gameover) break;
//20:
if (timeclock*60+20>T) break;
generate_elements();
//30:
if (timeclock*60+30>T) break;
get_elements_in_a_empty_city();
//35:
if (timeclock*60+35>T) break;
arrow_attack();
update_arrow();
//38:
if (timeclock*60+38>T) break;
bomb_time();
//40:
if (timeclock*60+40>T) break;
fight_time();
//50:
if (timeclock*60+50>T) break;
report_headquarter_elements();
//55:
if (timeclock*60+55>T) break;
check_warrior_live();
report_warrior_weapons();
timeclock++;
}
return ;
};
};
int main(){
// freopen("standard_in.txt", "r", stdin);
// freopen("my_out.txt","w",stdout);
cin>>cases;
int n=1;
while(cases--){
timeclock=0;
gameover=false;
cout<<"Case "<<n++<<":"<<endl;
get_data();
a_round START;
START.start();
}
return 0;
}第一篇文章，求轻喷，也求大神指导更为简单的方法！！！！！
488
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
