题目意思:汉字描述的很清楚
注意事项:1、可能出现不能走动的情况;2、在初始状态时也可能比武;3、只有在同一个位置只有两个不同门派的弟子的时候才会比武,4、死掉的直接删除。
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
#define ROWS 13
#define COLUMNS 13
//directions index 0 for down, 1 for up, 2 for right, 3 for left, 4 for right down, 5 for left up
int dir[6][2] = {{1, 0}, {-1, 0},
{0, 1}, {0, -1},
{1, 1}, {-1, -1}};
// Position
class Position
{
public:
int row;
int column;
public:
Position(){}
Position(int row, int column)
:row(row), column(column){}
~Position(){}
// judge where the current position is valid;
bool valid()
{
return (row>0&&row<ROWS&&column>0&&column<COLUMNS);
}
//--------------------DebugS--------------------
friend ostream&operator<<(ostream &out, const Position &p);
friend istream&operator>>(istream&in, Position &p);
//--------------------DebugE--------------------
};
//--------------------DebugS--------------------
ostream&operator<<(ostream &out, const Position &p)
{
out << "(" << p.row << "," << p.column << ")";
return out;
}
istream&operator>>(istream&in, Position &p)
{
in>>p.row>>p.column;
return in;
}
//--------------------DebugE--------------------
//wulin different school
class WLin
{
public:
char school;
Position curPos;
int vitality;
int interForce;
int skill;
int d;//current direction
bool alive;//where alive
public:
WLin()
{
if (school == 'S')d = 0;
else if (school == 'W')d = 2;
else d = 4;
alive = true;
}
WLin(char school, Position p, int v, int i, int s)
:school(school), curPos(p), vitality(v), interForce(i), skill(s)
{
if (school == 'S')d = 0;
else if (school == 'W')d = 2;
else d = 4;
alive = true;
}
~WLin(){}
// 1 for 'S', 2 for 'W', 4 for 'E'
int getValue()
{
if (school == 'S')return 1;
if (school == 'W')return 2;
if (school == 'E')return 4;
return 1024;
}
bool isS()
{
return school == 'S';
}
bool isW()
{
return school == 'W';
}
bool isE()
{
return school == 'E';
}
/calculate the attack power
int attackPower()
{
if (school == 'S'){
return (int)((0.5*interForce+0.5*skill)*(vitality+10)/100);
}
if (school == 'W'){
return (int)((0.8*interForce+0.2*skill)*(vitality+10)/100);
}
if (school == 'E'){
return (int)((0.2*interForce+0.8*skill)*(vitality+10)/100);
}
return -1;
}
//--------------------DebugS--------------------
friend ostream& operator<<(ostream &out, const WLin &wl);
//--------------------DebugE--------------------
};
//--------------------DebugS--------------------
ostream& operator<<(ostream&out, const WLin &wl)
{
out << wl.school << ": P->" << wl.curPos << "<- S->(" << wl.vitality
<< "," << wl.interForce << "," << wl.skill << ")<- L->" << wl.alive << "<- D->"
<< wl.d << "<-";
return out;
}
//--------------------DebugE--------------------
vector <WLin > disciple;
int N;
//--------------------DebugS--------------------
ostream& operator<<(ostream&out, const vector<WLin > &d)
{
for (int i = 0; i < (int)d.size(); ++i){
out << d[i] << endl;
}
return out;
}
//--------------------DebugE--------------------
class Grid //grid
{
public:
int ct;
int value;//S=1, W=2, E=4;
vector <int > diIndex;
public :
Grid(){}
Grid(int ct, int value)
:ct(ct), value(value){}
~Grid(){}
//two disciple with different school
bool differentSchool()
{
return (ct==2&&(value==3||value==5||value==6));
}
};
Grid grid[ROWS][COLUMNS];
//reset grid
void resetGrid()
{
for (int i = 1; i < ROWS; ++i){
for (int j = 1; j < COLUMNS; ++j){
grid[i][j].diIndex.clear();
grid[i][j].ct = grid[i][j].value = 0;
}
}
}
//go one step
void go()
{
for (int i = 0; i < (int)disciple.size(); ++i){
if (disciple[i].alive){
Position curPos = disciple[i].curPos;
int d = disciple[i].d;
Position tmp(curPos.row+dir[d][0], curPos.column+dir[d][1]);
if (!tmp.valid()){
d ^= 1;
tmp = Position(curPos.row+dir[d][0], curPos.column+dir[d][1]);
if (!tmp.valid()){
grid[curPos.row][curPos.column].ct++;
grid[curPos.row][curPos.column].value += disciple[i].getValue();
grid[curPos.row][curPos.column].diIndex.push_back(i);
continue;
}
disciple[i].d = d;
}
disciple[i].curPos = tmp;
grid[tmp.row][tmp.column].ct++;
grid[tmp.row][tmp.column].value += disciple[i].getValue();
grid[tmp.row][tmp.column].diIndex.push_back(i);
}
}
}
//count and print the final state
void coutAndPrintAns()
{
int cts = 0, ctw = 0, cte = 0;
int vs = 0, vw = 0, ve = 0;
for (int i = 0; i < (int)disciple.size(); ++i){
if (disciple[i].alive){
if (disciple[i].isS()){
cts++;
vs += disciple[i].vitality;
}
else if (disciple[i].isW()){
ctw++;
vw += disciple[i].vitality;
}
else if (disciple[i].isE()){
cte++;
ve += disciple[i].vitality;
}
}
}
printf ("%d %d\n%d %d\n%d %d\n***\n", cts, vs, ctw, vw, cte, ve);
}
//solve the problem
void solve()
{
do{
for (int i = 1; i < ROWS; ++i){
for (int j = 1; j < COLUMNS; ++j){
if (grid[i][j].differentSchool()){
int ii1 = grid[i][j].diIndex[0];
int ii2 = grid[i][j].diIndex[1];
int ii1ap = disciple[ii1].attackPower();
int ii2ap = disciple[ii2].attackPower();
disciple[ii1].vitality -= ii2ap;
if (disciple[ii1].vitality <= 0){
disciple[ii1].alive = false;
}
disciple[ii2].vitality -= ii1ap;
if (disciple[ii2].vitality <= 0){
disciple[ii2].alive = false;
}
}
}
}
resetGrid();
go();
N--;
//--------------------DebugS--------------------
//cout << disciple << endl;
//--------------------DebugE--------------------
}while (N>0);
coutAndPrintAns();
}
int main()
{
int t;
cin >> t;
while (t--){
cin >> N;
disciple.clear();
char school;
Position p;
int v, s, i, index = 0;
resetGrid();
while (cin >> school){
if (school == '0')break;
cin >> p >> i >> s >> v;
//--------------------DebugS--------------------
//cout << "out : " << school << " " << p << " " << i << " " << s << " " << v << endl;
//--------------------DebugE--------------------
WLin tmp(school, p, v, i, s);
disciple.push_back(tmp);
grid[p.row][p.column].ct++;
grid[p.row][p.column].value += tmp.getValue();
grid[p.row][p.column].diIndex.push_back(index);
index++;
}
//--------------------DebugS--------------------
//cout << disciple << endl;
//--------------------DebugE--------------------
solve();
}
return 0;
}