题目地址：洛谷：【P4048】[JSOI2010]冷冻波 – 洛谷、BZOJ：Problem 1822. — [JSOI2010]Frozen Nova 冷冻波

题目描述

WJJ喜欢“魔兽争霸”这个游戏。在游戏中，巫妖是一种强大的英雄，它的技能Frozen Nova每次可以杀死一个小精灵。我们认为，巫妖和小精灵都可以看成是平面上的点。
当巫妖和小精灵之间的直线距离不超过R，且巫妖看到小精灵的视线没有被树木阻挡（也就是说，巫妖和小精灵的连线与任何树木都没有公共点）的话，巫妖就可以瞬间杀灭一个小精灵。
在森林里有N个巫妖，每个巫妖释放Frozen Nova之后，都需要等待一段时间，才能再次施放。不同的巫妖有不同的等待时间和施法范围，但相同的是，每次施放都可以杀死一个小精灵。
现在巫妖的头目想知道，若从0时刻开始计算，至少需要花费多少时间，可以杀死所有的小精灵？

题意简述

巫妖一次可以杀死一只圆形范围内且连线与树障（圆形区域）无公共点的精灵，但是攻击有CD。求至少花费多少时间可以杀死全部精灵。

输入输出格式

输入格式：
输入文件第一行包含三个整数N、M、K(N,M,K<=200)，分别代表巫妖的数量、小精灵的数量和树木的数量。
接下来N行，每行包含四个整数x, y, r, t，分别代表了每个巫妖的坐标、攻击范围和施法间隔（单位为秒）。
再接下来M行，每行两个整数x, y，分别代表了每个小精灵的坐标。
再接下来K行，每行三个整数x, y, r，分别代表了每个树木的坐标。
输入数据中所有坐标范围绝对值不超过10000，半径和施法间隔不超过20000。

输出格式：
输出一行，为消灭所有小精灵的最短时间（以秒计算）。如果永远无法消灭所有的小精灵，则输出-1。

输入输出样例

输入样例#1：

2 3 1
-100 0 100 3
100 0 100 5
-100 -10
100 10
110 11
5 5 10

输出样例#1：

5

题解

首先我们可以处理出来每个巫妖可以杀死哪些精灵，简单的实现就是判断距离是否超过以及是否跟某个树有交点。这里判交点用的方法是检查端点及叉积计算出圆心-直线距离再判断是否有交点。
得到了这个表以后，我们就可以二分答案，每次使用最大流检验，建立源→巫妖→精灵→汇的网络，巫妖→精灵→汇中间的所有边容量为1，源→巫妖的所有边容量为floor(答案/该巫妖CD)+1，代表这一次该巫妖最多杀死多少精灵。满流即代表答案可行。
复杂度玄学。

代码

// Code by KSkun, 2018/6
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cmath>

#include <algorithm>
#include <queue>

typedef long long LL;

inline char fgc() {
    static char buf[100000], *p1 = buf, *p2 = buf;
    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2) 
        ? EOF : *p1++;
}

inline LL readint() {
    register LL res = 0, neg = 1;
    register char c = fgc();
    while(!isdigit(c)) {
        if(c == '-') neg = -1;
        c = fgc();
    }
    while(isdigit(c)) {
        res = (res << 1) + (res << 3) + c - '0';
        c = fgc();
    }
    return res * neg;
}

const int MAXN = 1005, INF = 1e9;
const double EPS = 1e-8;

struct Edge {
    int to, cap, nxt;
} gra[MAXN << 8];
int head[MAXN], tot;

inline void addedge(int u, int v, int cap) {
    gra[tot] = Edge {v, cap, head[u]}; head[u] = tot++;
    gra[tot] = Edge {u, 0, head[v]}; head[v] = tot++;
}

int level[MAXN];

inline bool bfs(int s, int t) {
    memset(level, -1, sizeof(level));
    std::queue<int> que;
    que.push(s); level[s] = 0;
    while(!que.empty()) {
        int u = que.front(); que.pop();
        for(int i = head[u]; ~i; i = gra[i].nxt) {
            int v = gra[i].to;
            if(gra[i].cap && level[v] == -1) {
                level[v] = level[u] + 1;
                if(v == t) return true;
                que.push(v);
            }
        }
    }
    return level[t] != -1;
}

int cur[MAXN];

inline int dfs(int u, int t, int left) {
    if(u == t || !left) return left;
    int flow = 0;
    for(int &i = cur[u]; ~i; i = gra[i].nxt) {
        int v = gra[i].to;
        if(level[v] == level[u] + 1 && gra[i].cap) {
            int f = dfs(v, t, std::min(left, gra[i].cap));
            if(f) {
                flow += f; left -= f;
                gra[i].cap -= f; gra[i ^ 1].cap += f;
                if(!left) break;
            }
        }
    }
    return flow;
}

inline int dinic(int s, int t) {
    int flow = 0;
    while(bfs(s, t)) {
        memcpy(cur, head, sizeof(head));
        int f;
        while(f = dfs(s, t, INF)) flow += f;
    }
    return flow;
}

int n, m, k, S, T;
std::vector<int> elfs[MAXN];

class Pos {
public:
    int x, y;
    Pos() {}
    Pos(int x, int y): x(x), y(y) {}
};

class Litch : public Pos {
public:
    int r, t;
} lit[MAXN];

typedef Pos Elf;

Elf elf[MAXN];

class Tree : public Pos {
public:
    int r;
} tre[MAXN];

inline double dis(Pos x, Pos y) {
    return sqrt((x.x - y.x) * (x.x - y.x) + (x.y - y.y) * (x.y - y.y));
}

inline bool inter(Pos x, Pos y, Tree tr) {
    double dis1 = dis(x, tr), dis2 = dis(y, tr), dis3 = dis(x, y);
    if(dis1 - tr.r < EPS || dis2 - tr.r < EPS) return true;
    double dis4 = fabs((x.x - y.x) * (x.y - tr.y) - (x.y - y.y) * (x.x - tr.x)) / dis3;
    double dis5 = sqrt(dis1 * dis1 - dis4 * dis4), dis6 = sqrt(dis2 * dis2 - dis4 * dis4);
    return dis5 + dis6 - dis3 < EPS && dis4 - tr.r < EPS;
}

inline bool check(int x) {
    tot = 0; memset(head, -1, sizeof(head));
    for(int i = 1; i <= n; i++) {
        addedge(S, i, x / lit[i].t + 1);
        for(int j = 0; j < elfs[i].size(); j++) {
            addedge(i, elfs[i][j] + n, 1);
        }
    }
    for(int i = 1; i <= m; i++) {
        addedge(i + n, T, 1);
    }
    return dinic(S, T) >= m;
}

int main() {
    n = readint(); m = readint(); k = readint(); S = n + m + 1; T = S + 1;
    for(int i = 1; i <= n; i++) {
        lit[i].x = readint(); lit[i].y = readint(); lit[i].r = readint(); lit[i].t = readint();
    }
    for(int i = 1; i <= m; i++) {
        elf[i].x = readint(); elf[i].y = readint();
    }
    for(int i = 1; i <= k; i++) {
        tre[i].x = readint(); tre[i].y = readint(); tre[i].r = readint();
    }
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            if(dis(lit[i], elf[j]) - lit[i].r > EPS) continue;
            bool success = true;
            for(int jj = 1; jj <= k; jj++) {
                if(inter(lit[i], elf[j], tre[jj])) {
                    success = false; break;
                }
            }
            if(success) elfs[i].push_back(j);
        }
    }
    int l = 0, r = INF, mid;
    if(check(0)) {
        printf("0"); return 0;
    }
    while(r - l > 1) {
        mid = (l + r) >> 1;
        if(check(mid)) r = mid; else l = mid;
    }
    printf("%d", r == INF ? -1 : r);
    return 0;
}