[ZJOI2008]杀蚂蚁

题意翻译

注意在(0,0)已经有蚂蚁的时候是不会生成新蚂蚁的

还有如果有蚂蚁扛着蛋糕，但是不在某个炮的范围内，炮仍然会打最近的蚂蚁

题目描述

最近，佳佳迷上了一款好玩的小游戏：antbuster。

游戏规则非常简单：在一张地图上，左上角是蚂蚁窝，右下角是蛋糕，蚂蚁会源源不断地从窝里爬出来，试图把蛋糕搬回蚂蚁窝。而你的任务，就是用原始资金以及杀蚂蚁获得的奖金造防御塔，杀掉这些试图跟你抢蛋糕的蚂蚁~

为了拿到尽可能高的分数，佳佳设计了很多种造塔的方案，但在尝试了其中的一小部分后，佳佳发现，这个游戏实在是太费时间了。为了节省时间，佳佳决定写个程序，对于每一种方案，模拟游戏进程，根据效果来判断方案的优劣。

根据自己在游戏中积累的一些经验，以及上网搜到的一些参数，佳佳猜了蚂蚁爬行的算法，并且假设游戏中的蚂蚁也是按这个规则选择路线：

1、每一秒钟开始的时候，蚂蚁都在平面中的某个整点上。如果蚂蚁没有扛着蛋糕，它会在该点留下2单位的信息素，否则它会留下5单位的信息素。然后蚂蚁会在正北、正南、正东、正西四个方向中选择一个爬过去。

2、选择方向的规则是：首先，爬完一个单位长度后到达的那个点上，不能有其他蚂蚁或是防御塔，并且那个点不能是蚂蚁上一秒所在的点（除非上一个时刻蚂蚁就被卡住，且这个时刻它仍无法动），当然，蚂蚁也不会爬出地图的边界（我们定义这些点为不可达点）。如果此时有多个选择，蚂蚁会选择信息素最多的那个点爬过去。

3、如果此时仍有多种选择，蚂蚁先面向正东，如果正东不是可选择的某个方向，它会顺时针转90°，再次判断，如果还不是，再转90°...直到找到可以去的方向。

4、如果将每只蚂蚁在洞口出现的时间作为它的活动时间的第1秒，那么每当这只蚂蚁的活动时间秒数为5的倍数的时候，它先按规则1~3确定一个方向，面对该方向后逆时针转90°，若它沿当前方向会走到一个不可达点，它会不停地每次逆时针转90°，直到它面对着一个可达的点，这样定下的方向才是蚂蚁最终要爬去的方向。

5、如果蚂蚁的四周都是不可达点，那么蚂蚁在这一秒内会选择停留在当前点。下一秒判断移动方向时，它上一秒所在点为其当前停留的点。

6、你可以认为蚂蚁在选定方向后，瞬间移动到它的目标点，这一秒钟剩下的时间里，它就停留在目标点。

7、蚂蚁按出生的顺序移动，出生得比较早的蚂蚁先移动。

然后，是一些有关地图的信息：

1、 每一秒，地图所有点上的信息素会损失1单位，如果那个点上有信息素的话。

2、 地图上某些地方是炮台。炮台的坐标在输入中给出。

3、 地图的长、宽在输入中给出，对于n * m的地图，它的左上角坐标为（0，0），右下角坐标为（n，m）。蚂蚁洞的位置为（0，0），蛋糕的位置为（n，m）。

4、 你可以把蚂蚁看做一个直径为1单位的圆，圆心位于蚂蚁所在的整点。

5、 游戏开始时，地图上没有蚂蚁，每个点上的信息素含量均为0。

一些有关炮塔的信息：

1、 炮塔被放置在地图上的整点处。

2、 为了简单一些，我们认为这些炮塔都是激光塔。激光塔的射速是1秒/次，它的攻击伤害为d/次，攻击范围为r。你可以认为每秒蚂蚁移动完毕后，塔才开始攻击。并且，只有当代表蚂蚁的圆的圆心与塔的直线距离不超过r时，塔才算打得到那只蚂蚁。

3、 如果一只蚂蚁扛着蛋糕，那么它会成为target，也就是说，任何打得到它的塔的炮口都会对准它。如果蛋糕好好地呆在原位，那么每个塔都会挑离它最近的蚂蚁进行攻击，如果有多只蚂蚁，它会选出生较早的一只。

4、 激光塔有个比较奇怪的特性：它在选定了打击目标后，只要目标在其射程内，塔到目标蚂蚁圆心的连线上的所有蚂蚁（这里“被打到”的判定变成了表示激光的线段与表示蚂蚁的圆有公共点）都会被打到并损d格血，但激光不会穿透它的打击目标打到后面的蚂蚁。

5、 尽管在真实游戏中，塔是可以升级的，但在这里我们认为塔的布局和等级就此定了下来，不再变动。

再介绍一下蚂蚁窝：

1、 如果地图上的蚂蚁不足6只，并且洞口没有蚂蚁，那么窝中每秒会爬出一只蚂蚁，直到地图上的蚂蚁数为6只。

2、 刚出生的蚂蚁站在洞口。

3、 每只蚂蚁有一个级别，级别决定了蚂蚁的血量，级别为k的蚂蚁的血量为int(4*1.1^k)int(4∗1.1

k

)（int(x)表示对x取下整）。每被塔打一次，蚂蚁的血减少d。注意，血量为0的蚂蚁仍能精力充沛地四处乱爬，只有一只蚂蚁的血被打成负数时，它才算挂了。

4、 蚂蚁的级别是这样算的：前6只出生的蚂蚁是1级，第7~12只是2级，依此类推。

最后给出关于蛋糕的介绍：

1、 简单起见，你可以认为此时只剩最后一块蛋糕了。如果有蚂蚁走到蛋糕的位置，并且此时蛋糕没有被扛走，那么这只蚂蚁就扛上了蛋糕。蚂蚁被打死后蛋糕归位。

2、 如果一只扛着蛋糕的蚂蚁走到蚂蚁窝的位置，我们就认为蚂蚁成功抢到了蛋糕，游戏结束。

3、 蚂蚁扛上蛋糕时，血量会增加int（该蚂蚁出生时血量 / 2），但不会超过上限。

整理一下1秒钟内发生的事件：

1秒的最初，如果地图上蚂蚁数不足6，一只蚂蚁就会在洞口出生。

接着，蚂蚁们在自己所在点留下一些信息素后，考虑移动。先出生的蚂蚁先移动。

移动完毕后，如果有蚂蚁在蛋糕的位置上并且蛋糕没被拿走，它把蛋糕扛上，血量增加，并在这时被所有塔设成target。

然后所有塔同时开始攻击。如果攻击结束后那只扛着蛋糕的蚂蚁挂了，蛋糕瞬间归位。

攻击结束后，如果发现扛蛋糕的蚂蚁没死并在窝的位置，就认为蚂蚁抢到了蛋糕。

游戏也在此时结束。最后，地图上所有点的信息素损失1单位。所有蚂蚁的年龄加1。漫长的1秒到此结束。

输入输出格式

输入格式：

输入的第一行是2个用空格隔开的整数，n、m，分别表示了地图的长和宽。

第二行是3个用空格隔开的整数，s、d、r，依次表示炮塔的个数、单次攻击伤害以及攻击范围。

接下来s行，每行是2个用空格隔开的整数x、y，描述了一个炮塔的位置。当然，蚂蚁窝的洞口以及蛋糕所在的位置上一定没有炮塔。

最后一行是一个正整数t，表示我们模拟游戏的前t秒钟。

输出格式：

如果在第t秒或之前蚂蚁抢到了蛋糕，输出一行“Game over after x seconds”，其中x为游戏结束的时间，否则输出“The game is going on”。

如果游戏在t秒或之前结束，输出游戏结束时所有蚂蚁的信息，否则输出t秒后所有蚂蚁的信息。格式如下：

第一行是1个整数s，表示此时活着的蚂蚁的总数。

接下来s行，每行5个整数，依次表示一只蚂蚁的年龄（单位为秒）、等级、当前血量，以及在地图上的位置（a，b）。输出按蚂蚁的年龄递减排序。

输入输出样例

输入样例#1：

3 5

1 1 2

2 2

5

输出样例#1：

The game is going on

5

5 1 3 1 4

4 1 3 0 4

3 1 3 0 3

2 1 3 0 2

1 1 4 0 1

说明

样例说明：

3*5的地图，有1个单次伤害为1、攻击范围为2的激光炮塔，它的位置为（2，2），模拟游戏的前5秒。5秒内有5只蚂蚁出生，都是向东爬行，其中第1_{4只在路过（0，2）点时被激光塔伤了1格血。在第5秒的时候，最早出生的蚂蚁按移动规则1}3本来该向东移动，但由于规则4的作用，它在发现向北和向西移动都会到达不可达点后，最终选择了向南移动。

数据说明：

100%的数据满足1 ≤ n,m ≤ 8，s ≤ 20，t ≤ 200,000

---

恶心的模拟

对于我这种代码能力辣鸡的选手真是==

调了快一天了，不想说话

而且最后还是因为有一个地方理解错题意了==

我的语文是得有多差

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cmath>
const int M = 12 ;
const int INF = 10 ;
const int dx[5] = {0 , 0 , 1 , 0 , -1} ;
const int dy[5] = {0 , 1 , 0 , -1 , 0} ;
using namespace std ;
inline int read(){
    char c = getchar() ; int x = 0 , w = 1 ;
    while(c>'9'||c<'0') { if(c=='-') w = -1 ; c = getchar() ; }
    while(c>='0'&&c<='9'){ x = x*10+c-'0' ; c = getchar() ; }
    return x*w ;
}
struct Gun{
    int x , y ;
}g[M<<1];
struct Ant{
    int x , y , sthp , nowhp , old , Lx , Ly , lv ;
    bool target ;
}A[M];
int n , m , pnum , atk , r , Maxtim , tim , num ;
int val[M][M] , lv , Ans ;
bool Cake , vis[M][M] ;
inline bool cmpold(Ant a , Ant b){ return a.old > b.old ; }
inline bool cmpkey(Ant a , Ant b){ return a.target > b.target ; }
inline bool cmphp(Ant a , Ant b){ return a.nowhp > b.nowhp ; }
inline bool Have(int x , int y){
    for(int i=1;i<=num;i++)
      if(A[i].x == x&&A[i].y == y)
        return true ;
    return false ;
}
inline void Clear(int i){
    A[i].lv = A[i].Lx = A[i].Ly = A[i].nowhp =
    A[i].old = A[i].sthp = A[i].target = A[i].x = A[i].y = 0 ;
}
inline bool CanMove(int u,int x,int y){
    if(x<0||y<0||x>n||y>m||vis[x][y]) return false ;
    if(A[u].Lx == x&&A[u].Ly == y)
        return false ;
    for(int i=1;i<=num;i++){
    	if(i == u) continue ;
    	if(A[i].x == x && A[i].y == y)
    	  return false ;
    }
    return true ;
}
inline void Remove(int u , int id){
    int T = 4 ;
    while(T--){
        --id ;
        if(id==0) id = 4 ;
        int x = A[u].x + dx[id] , y = A[u].y + dy[id] ;
        if(CanMove(u , x , y)){
            A[u].Lx = A[u].x ; A[u].Ly = A[u].y ;
            A[u].x += dx[id] ; A[u].y += dy[id] ;
            return ;
        }
    }
}
inline void Move(int u){
    int id = 0 , temp = -1 ;
    for(int j=1;j<=4;j++){
        int x = A[u].x + dx[j] , y = A[u].y + dy[j] ;
        if(val[x][y] <= temp) continue ;
        if(!CanMove(u , x , y)) continue ;
        temp = val[x][y] , id = j ;
    }
    if((A[u].old + 1)%5==0&&id) Remove(u , id) ;
    else {
    	A[u].Lx = A[u].x ;  A[u].Ly = A[u].y ;
        A[u].x += dx[id] ;  A[u].y += dy[id] ;
    }
    if(Cake&&A[u].x==n&&A[u].y==m){
        Cake = 0 ;
        A[u].target = 1 ;
        A[u].nowhp = min(A[u].sthp , A[u].nowhp + (A[u].sthp/2)) ;
    }
}
inline double Calc(int sx , int sy , int tx , int ty){
    double x = (sx*1.0 - tx*1.0) * (sx*1.0 - tx*1.0) ;
    double y = (sy*1.0 - ty*1.0) * (sy*1.0 - ty*1.0) ;
    return sqrt(x + y) ;
}
double dis1 , dis2 , dis3 , dis4 , dis5 ;
double fx , fy , kx , ky ;
inline bool Canhurt(int Fx , int Fy , int Kx , int Ky , int X , int Y){
    fx = Fx*1.0 , fy = Fy*1.0 , kx = Kx * 1.0 , ky = Ky * 1.0 ;
    double x = X * 1.0 , y = Y * 1.0 ;
    double Enddis = 0 ;
    if(x > max(fx , kx) || x < min(fx , kx)) return false ;
    if(y > max(fy , ky) || y < min(fy , ky)) return false ;
    if(fx == kx){
        if(abs(x - fx) <= 0.5) return true ;
        return false ;
    }
    double k = (fy - ky)/(fx - kx) ;
    double b = 	fy - k * fx ;
    Enddis = abs(k * x - y + b) / sqrt(k * k + 1) ;
    if(Enddis <= 0.5) return true ;
    return false ;
}
inline void Attack(){
    for(int i=1;i<=pnum;i++){
        int wh = 0 , birth = -1 ;
        double mindis = 1e4 ;
        for(int j=1;j<=num;j++){
            double dis = Calc(g[i].x , g[i].y , A[j].x , A[j].y) ;
            if(dis<=r){
                if(A[j].target){
                    wh = j ;
                    break ;
                }
                else if(dis<mindis||(dis==mindis&&A[j].old > birth)){
                    mindis = dis ;
                    wh = j ;
                    birth = A[j].old ;
                }
            }
        }
        if(!wh) continue ;
        A[wh].nowhp -= atk ;
        for(int j=1;j<=num;j++){
            if(j == wh) continue ;
            if(Canhurt(g[i].x , g[i].y , A[wh].x , A[wh].y , A[j].x , A[j].y))
              A[j].nowhp -= atk ;
        }
    }
}
inline void Die(){
    sort(A + 1 , A + num + 1 , cmphp) ;
    for(int i=num;i>=1;i--){
        if(A[i].nowhp<0){
            --num ;
            if(A[i].target) Cake = 1 ;
            Clear(i) ;
        }
        else break ;
    }
}
inline bool Success(){
    for(int i=1;i<=num;i++)
      if(A[i].target&&A[i].x==0&&A[i].y==0)
        return true ;
    return false ;
}
inline int Solve(){
    while(tim<Maxtim){
        ++tim ;
        if(num<6&&!Have(0 , 0)){
            Clear(num + 1) ;
            ++lv ;
            A[++num].lv = lv/6 + 1 ;
            if(lv%6 == 0) A[num].lv -- ;
            A[num].old = 0 ;
            A[num].sthp = A[num].nowhp = (int)(4.0 * pow(1.1 , A[num].lv)) ;
            A[num].Lx = A[num].Ly = INF + tim ;
        }
        for(int i=1;i<=num;i++)
            A[i].target ? val[A[i].x][A[i].y] += 5 : val[A[i].x][A[i].y] += 2 ;
        sort(A+1,A+num+1,cmpold) ;
        for(int i=1;i<=num;i++) Move(i) ;
        sort(A+1,A+num+1,cmpkey) ;
        Attack() ;
        Die() ;
        if(Success()) return tim ;
        for(int i=0;i<=n;i++)
          for(int j=0;j<=m;j++)
            if(val[i][j])
              --val[i][j] ;
        for(int i=1;i<=num;i++) A[i].old ++ ;
    }
    return -1 ;
}
int main(){
    n = read() ; m = read() ;
    pnum = read() ; atk = read() ; r = read() ;
    for(int i=1;i<=pnum;i++){
        g[i].x = read() , g[i].y = read() ;
        vis[g[i].x][g[i].y] = 1 ;
    }
    Cake = 1 ; Maxtim = read() ;
    Ans = Solve() ;
    if(Ans>0)	printf("Game over after %d seconds\n",Ans);
    else printf("The game is going on\n") ;
    sort(A + 1 , A + num + 1 , cmpold) ;
    printf("%d\n",num) ;
    for(int i=1;i<=num;i++)
      printf("%d %d %d %d %d\n", A[i].old , A[i].lv , A[i].nowhp , A[i].x , A[i].y) ;
    return 0 ;
}