hihoCoder 1392 War Chess 【模拟】 (ACM-ICPC国际大学生程序设计竞赛北京赛区(2016)网络赛)

#1392 : War Chess

时间限制:1000ms
单点时限:1000ms
内存限制:256MB

描述

Rainbow loves to play kinds of War Chess games. There are many famous War Chess games such as "Biography of Cao Cao", "Anecdotes of Wagang Mountain", etc. In this problem, let's consider a much simpler version of
War Chess games. The game is based on the following features:
MAP
The map is a rectangular area which consists of N rows and M columns. The cells in the rectangular area have various landforms like plain, woods, hill, river, snowfield, etc. Specifically, each cell (i,j) is assigned
an integer of moving property Gi,j, which makes influence on going across it.
CHARACTER
A character can be regarded as a person standing in a cell of the map. Each character has life HP, attacking ability AT, moving ability MV and attacking distance range [AD1,AD2].
Characters are divided into two groups. Group 0 is controlled by the player and group 1 is controlled by the system.
A character can attack a character from the opposite group if the Manhattan distance between them is in the attacker's attacking distance range (inclusive).
 When a character p is attacked by enemy q, its life HPp will be minus by ATq.
A character is driven out of the map immediately when its HP becomes 0 or negative.
Each character can occupy a cell or move on the map. Several rules specify the position and moving limits of them:
OCCUPATION
Initially, characters are generated in different cells. They occupy their own cell separately. A character cannot move when another one is moving.
Once a character starts to move, it will lose occupation of its current standing cell. When the character stops moving, it will gain the occupation of the cell it is standing in.
STEP
A move consists of several steps. Each step, one can walk from a cell to an adjacent cell sharing an edge (up, down, left or right). A step
walking to a cell occupied by the other character is invalid.
When it steps from a cell (i,j) to a cell (x,y), its moving ability MV will be minus by Gx,y. Moving
steps which make MV become negative are invalid. After a valid step, if the current cell is beside (sharing an edge with) someone of the opposite group, the MV of a character will become
0.
A character's MV recovers to the original value immediately when it gains occupation of a cell.
The set of cells, able to be reached by valid steps and stopped at in a move, is called a character’s moving range. Staying at the original cell is also valid and should be counted into the moving range.



The process of the game contains several rounds. In each round, the player's group acts first and the system's group acts next. For each group, the characters of the group act by turns. In each action, a character
first moves to a cell in its moving range, then attacks a character of the opposite group in its attacking distance range or do nothing. When all the characters of a group are driven out of the map, the group loses the game and the opposite group wins.
Rainbow has just got some logs of a game and wants to watch the game. Help him to recover the game process.

输入

There are multiple test cases (no more than 20). For each test case:
The first line contains three integers N,M,C,E (1≤N,M≤100,2≤C≤min(N*M,100),1≤E≤3000), representing the number of rows and columns, the number of characters and the number of events in the log.
Each of the next N lines contains M integers, representing the moving property Gi,j (1≤Gi,j≤102 ).
Each of the next C lines contains eight integers HP, AT, MV, AD1, AD2,
STx, STy, GR,(1≤HP,AT,MV≤103,1≤AD1≤AD2≤20,1<STx≤N,1≤STy≤M,0≤GR≤1),
representing the five properties, the initial position and the group of a character.
The next E lines describe events in the log. Each line is in one of the following formats:
Round of GR – Characters in group GR take the round.
Action of character ID – Character ID takes the action.
Move to (x,y) – Current acting character moves to cell (x,y) by some steps.
Attack ID – Current acting character attacks character ID but ID isn’t driven out.
Drive out ID – Current acting character attacks character ID and ID is driven out.
In the events, 1≤x≤N,1≤y≤M,1≤ID≤C,0≤GR≤1. The row number of cells is marked 1 to N from top to bottom, the column number is marked 1 to M from left to right. Initially, each group has at least one character.

输出

For each event of Move to, output "INVALID" if breaking the moving rules. Otherwise output the maximum rest moving ability when it stepped into the destination.
For each event of Attack or Drive out, output "INVALID" if cannot attack or being wrong at driving out. Otherwise, output the remaining HP of the one being attacked.
Invalid events should be ignored while dealing with the next events. The data ensures that the game has just finished after processing all the valid events. Events of Round
of and Action of are ensured to be well recorded in the log without missing or breaking.

样例输入

5 5 4 12
1 9 1 4 4
1 9 1 2 4
1 9 1 1 2
2 9 2 7 3
2 3 2 6 1
10 5 8 1 3 1 1 0
20 10 5 1 2 2 1 0
19 10 5 1 2 5 2 1
25 25 3 1 1 5 5 0
Round of 0
Action of character 2
Move to (5,1)
Attack 3
Action of character 1
Move to (3,1)
Round of 1
Action of character 3
Drive out 1
Round of 0
Action of character 2
Drive out 3

样例输出

0
9
6
INVALID
-1

题目链接：

　　http://hihocoder.com/problemset/problem/1392


题目大意：

　　N*M的地图，C个游戏角色，E个操作。(1≤N,M≤100,2≤C≤min(N*M,100),1≤E≤3000)

　　地图上为经过这个位置需要消耗的移动值G[i,j]。游戏角色分为两个阵营，Group0由玩家控制，Group1由系统控制。每个角色有几个属性：

　　HP

为

血量, AT为攻击力，MV为移动值，AD1和AD2为角色的攻击范围（曼哈顿距离），X和Y为角色初始位置，Group为角色所属阵营。

　　一开始每个玩家都会占领一个格子，每个人的格子都互不相同。每次只能有一个玩家在移动。如果一个玩家开始移动，那么之前占领的格子会被释放，停止移动后，占领现在的格子。

　　每次移动可以走多步，经过的地方要扣除G，不能走到已经有角色的位置，在行动过程中MV值不能小于0，如果走到当前组的敌方周围（上下左右）则不能再移动，但是在停下之后下一次行动时MV恢复到初始值。

　　如果角色A攻击角色B可行则角色B的HP-角色A的AT。如果角色B死亡则立即移除出游戏。

　　游戏开始后，两个Group轮流操作，先Group0后Group1。选取角色后角色移动到一个位置(不移动也可以)，然后攻击某个敌人(不攻击也可以)。当一个Group的角色都死掉后，游戏结束。

　　现在已知一次游戏的操作，求还原游戏场景。

　　

　　E个操作，操作分几种：

　　Round of X – 现在轮到GroupX 行动，X为0，1。保证合法

　　Action of character ID – 角色ID开始行动。保证合法

　　Move to (x,y) – 当前角色移动到(x,y)位置。如果合法输出最大的剩余移动值，否则输出INVALID

　　Attack ID – 当前角色攻击ID角色且角色不死。如果合法输出被攻击角色剩余HP，否则输出INVALID

　　Drive out ID – 当前角色攻击ID角色且将ID杀死。如果合法输出被攻击角色剩余HP(负)，否则输出INVALID

 

题目思路：

　　【模拟】

　　根据题意慢慢模拟就能AC。。比赛差几秒没交上去。赛后AC了。

　　Move操作就是简单BFS，判断当前能走的格子是否越界，上面有没人，是否是敌方周围的。

　　Attack操作就判断两个人的曼哈顿距离是否在攻击范围内，ID的剩余HP是否大于0，Drive out操作判断是否<=0。

　　还有就是不能攻击友军，已经死的人等等细节。注意一下。

//
//by coolxxx
//#include<bits/stdc++.h>
#include<iostream>
#include<algorithm>
#include<string>
#include<iomanip>
#include<map>
#include<stack>
#include<queue>
#include<set>
#include<bitset>
#include<memory.h>
#include<time.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//#include<stdbool.h>
#include<math.h>
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
#define abs(a) ((a)>0?(a):(-(a)))
#define lowbit(a) (a&(-a))
#define sqr(a) ((a)*(a))
#define swap(a,b) ((a)^=(b),(b)^=(a),(a)^=(b))
#define mem(a,b) memset(a,b,sizeof(a))
#define eps (1e-10)
#define J 10000
#define mod 1000000007
#define MAX 0x7f7f7f7f
#define PI 3.14159265358979323
#pragma comment(linker,"/STACK:1024000000,1024000000")
#define N 104
using namespace std;
typedef long long LL;
double anss;
LL aans;
int cas,cass;
int n,m,lll,ans;
int ro,person,Aperson,sx,sy,ex,ey;
int g

,d

,mark

;
bool u

;
int dx[]={-1,1,0,0};
int dy[]={0,0,-1,1};
struct xxx
{
int HP,AT,MV,D1,D2,X,Y;
bool G,dead;
}a
;
char ss[10];
void Round()
{
scanf("%s%d",ss,&ro);
}
void Action()
{
scanf("%s%s%d",ss,ss,&person);
if(a[person].dead || a[person].G!=ro)puts("INVALID");
}
void bfs()
{
queue<int>q;
int i,j,x,y,xx,yy;
q.push(sx),q.push(sy);
mem(d,MAX);mem(mark,0);
d[sx][sy]=0;
for(i=1;i<=cas;i++)
{
if(a[i].dead)continue;
mark[a[i].X][a[i].Y]=1;
if(a[i].G!=ro)
{
for(j=0;j<4;j++)
{
if(mark[a[i].X+dx[j]][a[i].Y+dy[j]]==0)
mark[a[i].X+dx[j]][a[i].Y+dy[j]]=2;
}
}
}
while(!q.empty())
{
x=q.front(),q.pop();
y=q.front(),q.pop();
if(d[x][y]>a[person].MV)continue;
u[x][y]=0;
for(j=0;j<4;j++)
{
xx=x+dx[j],yy=y+dy[j];
if(xx<1 || xx>n || yy<1 || yy>m)continue;
if(mark[xx][yy]==1)continue;
if(d[x][y]+g[xx][yy]<=a[person].MV)
{
if(mark[xx][yy]==2)
d[xx][yy]=a[person].MV;
else if(d[xx][yy]>d[x][y]+g[xx][yy])
{
d[xx][yy]=d[x][y]+g[xx][yy];
if(u[xx][yy])continue;
u[xx][yy]=1;
q.push(xx),q.push(yy);
}
}
}
}
if(d[ex][ey]==MAX)
puts("INVALID");
else
{
printf("%d\n",a[person].MV-d[ex][ey]);
a[person].X=ex,a[person].Y=ey;
}
}
void Move()
{
scanf("%s (%d,%d)",ss,&ex,&ey);
sx=a[person].X,sy=a[person].Y;
bfs();
}
void Attack()
{
scanf("%d",&Aperson);
if(abs(a[person].X-a[Aperson].X)+abs(a[person].Y-a[Aperson].Y)<=a[person].D2
&& abs(a[person].X-a[Aperson].X)+abs(a[person].Y-a[Aperson].Y)>=a[person].D1
&& a[person].G!=a[Aperson].G && !a[Aperson].dead && Aperson<=cas)
{
if(a[person].AT<a[Aperson].HP)
{
a[Aperson].HP-=a[person].AT;
printf("%d\n",a[Aperson].HP);
}
else
{
puts("INVALID");
}
}
else puts("INVALID");
}
void Drive()
{
scanf("%s%d",ss,&Aperson);
if(abs(a[person].X-a[Aperson].X)+abs(a[person].Y-a[Aperson].Y)<=a[person].D2
&& abs(a[person].X-a[Aperson].X)+abs(a[person].Y-a[Aperson].Y)>=a[person].D1
&& a[person].G!=a[Aperson].G && !a[Aperson].dead && Aperson<=cas)
{
if(a[person].AT>=a[Aperson].HP)
{
a[Aperson].HP-=a[person].AT;
a[Aperson].dead=1;
printf("%d\n",a[Aperson].HP);
}
else
{
puts("INVALID");
}
}
else puts("INVALID");
}
int main()
{
#ifndef ONLINE_JUDGEW
// freopen("1.txt","r",stdin);
// freopen("2.txt","w",stdout);
#endif
int i,j,k;
int x,y,z;
// init();
// for(scanf("%d",&cass);cass;cass--)
// for(scanf("%d",&cas),cass=1;cass<=cas;cass++)
// while(~scanf("%s",s))
while(~scanf("%d",&n))
{
scanf("%d%d%d",&m,&cas,&cass);
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
scanf("%d",&g[i][j]);
for(i=1;i<=cas;i++)
{
scanf("%d%d%d%d%d%d%d%d",&a[i].HP,&a[i].AT,&a[i].MV,&a[i].D1,&a[i].D2,&a[i].X,&a[i].Y,&a[i].G);
a[i].dead=0;
}
while(cass--)
{
scanf("%s",ss);
if(!strcmp(ss,"Round"))Round();
else if(!strcmp(ss,"Action"))Action();
else if(!strcmp(ss,"Move"))Move();
else if(!strcmp(ss,"Attack"))Attack();
else if(!strcmp(ss,"Drive"))Drive();
}
}
return 0;
}
/*
//

//
*/