BZOJ1822 Frozen Nova 冷冻波

1822: [JSOI2010]Frozen Nova 冷冻波

Time Limit: 10 Sec  Memory Limit: 64 MB

Description

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

Input

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

Output

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

Sample Input

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

Sample Output

5

Source

JSOI2010第二轮Contest1

---

题解

网络流 +　二分答案 +　计算几何

计算几何用点积和叉积计算点到线段距离，二分所需时间，网络流验证是否可行

大水题，数据有点坑qwq

代码

 #include<bits/stdc++.h>
 using namespace std;
 template <class _T> inline void read(_T &_x) {
     int _t; bool flag = false;
     while ((_t = getchar()) != '-' && (_t < '' || _t > '')) ;
     if (_t == '-') _t = getchar(), flag = true; _x = _t - '';
     while ((_t = getchar()) >= '' && _t <= '') _x = _x *  + _t - '';
     if (flag) _x = -_x;
 }
 typedef long long LL;
 const int maxn = ;
 const int maxm = ;
 const double eps = 1e-;
 inline int sign(double val) {return val < -eps ? - : val > eps; }
 struct Point {
     double x, y;
     Point (double a = , double b = ):x(a), y(b) {}
 }A[maxn], B[maxn], C[maxn];
 double rA[maxn], rC[maxn];
 double dot(Point a, Point b, Point c) {
     return (b.x - a.x) * (c.x - a.x) + (b.y - a.y) * (c.y - a.y);
 }
 double cross(Point a, Point b, Point c) {
     return (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
 }
 double dist(Point a, Point b) {
     return hypot(a.x - b.x, a.y - b.y);
 }
 double ldis(Point a, Point b, Point c) {
     if (dot(c, a, b) > ) return min(dist(a, c), dist(b, c));
     return fabs(cross(a, b, c) / dist(a, b));
 }
 bool check(Point a, Point b, Point c, int pc) {
     double dis = dist(a, b), r = dot(a, b, c) / dis;
     if (r <  || r > dis) return true;
     return sign(fabs(cross(a, b, c) / r) - rC[pc]) > ;
 }
 struct Edge {
     int v, flow, nxt;
     Edge () {}
     Edge (int a, int b, int c):v(a), flow(b), nxt(c) {}
 }e[maxm];
 int n, m, k, t[maxn], sink;
 int fir[maxn], tag[maxn], cur[maxn], ecnt;
 bool can[maxn][maxn];
 inline void addedge (int a, int b, int c) {
     e[++ecnt] = Edge (b, c, fir[a]), fir[a] = ecnt;
     e[++ecnt] = Edge (a, , fir[b]), fir[b] = ecnt;
 }
 inline bool bfs() {
     memset(tag, , sizeof (int) * (sink + ));
     queue<int> q; q.push(), tag[] = ;
     while (!q.empty()) {
         int now = q.front(); q.pop();
         for (int u = fir[now]; u; u = e[u].nxt) {
             if (e[u].flow && !tag[e[u].v]) {
                 tag[e[u].v] = tag[now] + ;
                 q.push(e[u].v);
             }
         }
     }
     return tag[sink] != ;
 }
 int dfs(int now, int flow) {
     if (now == sink) return flow;
     int usd = ;
     for (int &u = cur[now]; u; u = e[u].nxt) {
         if (e[u].flow && tag[e[u].v] > tag[now]) {
             int ret = dfs(e[u].v, min(e[u].flow, flow - usd));
             if (ret) {
                 e[u].flow -= ret;
                 e[u ^ ].flow += ret;
                 usd += ret;
                 if (usd == flow) return flow;
             }
         }
     }
     return usd;
 }
 inline int dinic() {
     int flow = ;
     while (bfs()) {
         for (int i = ; i <= sink; ++i) cur[i] = fir[i];
         flow += dfs(, m);
     }
     return flow;
 }
 bool check(int tim) {
     memset(fir, , sizeof (int) * (sink + ));
     ecnt = ;
     for (int i = ; i <= n; ++i) {
         addedge(, i, tim / t[i] + );
         for (int j = ; j <= m; ++j) if (can[i][j]) {
             addedge(i, n + j, );
         }
     }
     for (int i = ; i <= m; ++i) addedge(n + i, sink, );
     return dinic() >= m;
 }
 int main() {
     //freopen(".in", "r", stdin);
     //freopen(".out", "w", stdout);
     read(n), read(m), read(k);
     for (int i = ; i <= n; ++i) {
         scanf("%lf%lf%lf%d", &A[i].x, &A[i].y, &rA[i], &t[i]);
     }
     for (int i = ; i <= m; ++i) {
         scanf("%lf%lf", &B[i].x, &B[i].y);
     }
     for (int i = ; i <= k; ++i) {
         scanf("%lf%lf%lf", &C[i].x, &C[i].y, &rC[i]);
     }
     for (int i = ; i <= n; ++i) {
         for (int j = ; j <= m; ++j) {
             bool flag = true;
             double dis = dist(A[i], B[j]);
             if (dis > rA[i]) continue;
             for (int x = ; x <= k; ++x) {
                 if (ldis(A[i], B[j], C[x]) < rC[x]) {
                     flag = false;
                     break;
                 }
             }
             if (flag) can[i][j] = true;
         }
     }
     for (int i = ; i <= m; ++i) {
         bool flag = false;
         for (int j = ; j <= n; ++j) if (can[j][i]) {
             flag = true; break;
         }
         if (!flag) {
             puts("-1");
             return ;
         }
     }
     sink = n + m + ;
     int l = , r =  * m, mid;
     while (l < r) {
         if (check(mid = (l + r) >> )) r = mid;
         else l = mid + ;
     }
     cout << l << endl;
     return ;
 }