杀蚂蚁

还是比较好写的......其中最毒瘤的版块居然TM是计算几何......

巨型模拟。

主要难点是判断线段与圆是否相交，查错困难。

写出来没花太长时间，调试倒是一个状态一个状态的输出，和std对比，烦死了。

// kill ant
#include <cstdio>
#include <cmath>
#include <algorithm>

#define wwx_AK_IOI huyufeifei::main()

namespace huyufeifei {

const int N = 200010, INF = 0x3f3f3f3f;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};

struct ANT {
    int bir, hp, max_hp, x, y, last_x, last_y, level;
    bool cake;
}a[10]; int top;

struct TOWER {
    int x, y;
}b[50];

int tot, G[30][30], cake = -1, d, r, n, m, s, time, vis[30][30];

inline void birth_ant() {
    if(top < 6 && !vis[0][0]) {
        top++;
        tot++;
        a[top].bir = time;
        a[top].level = (tot - 1) / 6 + 1;
        a[top].max_hp = int(4 * pow(1.1, a[top].level));
        a[top].hp = a[top].max_hp;
        a[top].cake = 0;
        a[top].x = 0;
        a[top].y = 0;
        a[top].last_x = -1;
        a[top].last_y = -1;
        vis[0][0] = top;
    }
    return;
}

inline void make_information() {
    for(int i = 1; i <= top; i++) {
        G[a[i].x][a[i].y] += (a[i].cake ? 5 : 2);
    }
    return;
}

inline bool valid(int i, int j) {
    int x = a[i].x + dx[j];
    int y = a[i].y + dy[j];
    if(x == a[i].last_x && y == a[i].last_y) {
        return 0;
    }
    if(x < 0 || y < 0 || x > n || y > m) {
        return 0;
    }
    if(vis[x][y] || G[x][y] == -1) {
        return 0;
    }
    return 1;
}

inline void move() {
    for(int i = 1; i <= top; i++) {
        int direct = -1, large = -1;
        for(int j = 0; j < 4; j++) {
            if(valid(i, j)) {
                if(G[a[i].x + dx[j]][a[i].y + dy[j]] > large) {
                    large = G[a[i].x + dx[j]][a[i].y + dy[j]];
                    direct = j;
                }
            }
        }
        //
        if((time - a[i].bir + 1) % 5 == 0 && direct != -1) {
            do {
                direct--;
                if(direct < 0) {
                    direct = 3;
                }
            } while(!valid(i, direct));
        }
        // go to direct
        a[i].last_x = a[i].x;
        a[i].last_y = a[i].y;
        if(direct != -1) {
            a[i].x += dx[direct];
            a[i].y += dy[direct];
            vis[a[i].x][a[i].y] = i;
            vis[a[i].last_x][a[i].last_y] = 0;
        }
        // over
    }
    return;
}

inline void check_cake() {
    int i = vis[n][m];
    if(i) {
        cake = i;
        a[i].cake = 1;
        a[i].hp += (a[i].max_hp >> 1);
        a[i].hp = std::min(a[i].hp, a[i].max_hp);
    }
    return;
}

inline int get_aim(int x, int y) {
    if(cake != -1 && (x - a[cake].x) * (x - a[cake].x) + (y - a[cake].y) * (y - a[cake].y) <= r * r) {
        return cake;
    }
    int small = INF, aim = -1;
    for(int i = 1; i <= top; i++) {
        if(small > (x - a[i].x) * (x - a[i].x) + (y - a[i].y) * (y - a[i].y)) {
            small = (x - a[i].x) * (x - a[i].x) + (y - a[i].y) * (y - a[i].y);
            aim = i;
        }
    }
    if(small <= r * r) {
        return aim;
    }
    return 0;
}

struct Point {
    double x, y;
    Point(double _x = 0, double _y = 0) {
        x = _x;
        y = _y;
    }
};

inline bool influence(int pa, int pb, int pc) {
    int A = b[pa].x;
    int B = b[pa].y;
    int C = a[pb].x;
    int D = a[pb].y;
    int E = a[pc].x;
    int F = a[pc].y;

    if(A == C) {
        int d2 = (E - C) * (E - C);
        if(F < std::min(B, D) || F > std::max(B, D)) {
            d2 = std::min((E - C) * (E - C) + (F - D) * (F - D),
                          (E - A) * (E - A) + (F - B) * (F - B));
        }
        //printf("%d < %d * %d 
", d2, r, r);
        return (double)d2 <= 0.25;
    }
    if(B == D) {
        int d2 = (F - D) * (F - D);
        if(E < std::min(A, C) || E > std::max(A, C)) {
            d2 = std::min((E - C) * (E - C) + (F - D) * (F - D),
                          (E - A) * (E - A) + (F - B) * (F - B));
        }
        //printf("%d < %d * %d 
", d2, r, r);
        return (double)d2 <= 0.25;
    }

    double A1 = (double)(B - D) / (A - C);
    double C1 = (double)(B) - A1 * A;
    double B1 = -1.0;

    double A2 = -1.0 / A1;
    double B2 = -1.0;
    double C2 = 1.0 * F - A2 * E;
    Point p((B1 * C2 - B2 * C1) / (A1 * B2 - A2 * B1), (A2 * C1 - A1 * C2) / (A1 * B2 - A2 * B1));
    
    double d2 = (p.x - E) * (p.x - E) + (p.y - F) * (p.y - F);
    if(p.x < std::min(A, C) || p.x > std::max(A, C)) {
        d2 = std::min((E - C) * (E - C) + (F - D) * (F - D),
                      (E - A) * (E - A) + (F - B) * (F - B));
    }
    //printf("%d
", d2 < r * r);  <- error 
    return d2 <= 0.25;
}

inline bool update(int i) {
    if(i > top) {
        return 0;
    }
    if(a[i].hp < 0) {
        if(a[i].cake) {
            cake = -1;
        }
        vis[a[i].x][a[i].y] = 0; // error : space
        for(int j = i; j < top; j++) {
            a[j] = a[j + 1];
            if(a[j].cake) {
                cake = j;
            }
            vis[a[j].x][a[j].y] = j; // error : space
        }
        top--;
        return 1;
    }
    return 0;
}

inline void attack() {
    for(int i = 1; i <= s; i++) {
        int j = get_aim(b[i].x, b[i].y);
        if(!j) {
            continue;
        }
        a[j].hp -= d;
        for(int k = 1; k <= top; k++) {
            if(k != j && influence(i, j, k)) {
                a[k].hp -= d;
            }
        }
    }
    for(int i = 1; i <= top; i++) {
        while(update(i)) { // error : space
            update(i);
        }
    }
    return;
}

inline bool check_ed() {
    return cake != -1 && !a[cake].x && !a[cake].y;
}

inline void del_information() {
    for(int i = 0; i <= n; i++) {
        for(int j = 0; j <= m; j++) {
            if(G[i][j] > 0) {
                G[i][j]--;
            }
        }
    }
    return;
}

inline void out() {
    printf("%d
", top);
    for(int i = 1; i <= top; i++) {
        printf("%d %d %d %d %d 
", time - a[i].bir, a[i].level, a[i].hp, a[i].x, a[i].y);
    }
    /*puts("");
    for(int i = 0; i <= n; i++) {
        for(int j = 0; j <= m; j++) {
            if(G[i][j] >= 0) {
                printf("%3d", vis[i][j]);
            }
            else {
                printf(" -1");
            }
        }
        puts("");
    }*/
    return;
}

inline void main() {
    //freopen("in.in", "r", stdin);
    //freopen("my.out", "w", stdout);
    scanf("%d%d", &n, &m);
    scanf("%d%d%d", &s, &d, &r);
    for(int i = 1; i <= s; i++) {
        scanf("%d%d", &b[i].x, &b[i].y);
        G[b[i].x][b[i].y] = -1;
    }
    int T;
    scanf("%d", &T);

    for(time = 1; time <= T; time++) {
        birth_ant();
        make_information();
        move();
        if(cake == -1) {
            check_cake();
        }
        attack();
        int t = check_ed();
        if(t) {
            printf("Game over after %d seconds
", time);
            out();
            return;
        }
        del_information();
        //out();
    }
    printf("The game is going on
");
    out();
    return;
}

}

int main() {
    wwx_AK_IOI;
    return 0;
}