Bzoj1822 [JSOI2010]Frozen Nova 冷冻波

Time Limit: 10 Sec  Memory Limit: 64 MB
Submit: 1933  Solved: 608

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

HINT

Source

JSOI2010第二轮Contest1

图论 网络流 计算几何

没什么意义的板子题

$O(n^3)$用计算几何判断每个巫妖能攻击到哪些小精灵。只需要判断巫妖到小精灵的连线是否与代表树的圆相离即可。

二分答案，用最大流check限定时间内能否将小精灵消灭完：

　　源点向每个小精灵连边，容量为1;

　　每个小精灵向能攻击到它的巫妖连边，容量为1

　　每个巫妖向汇点连边，容量为限定时间内的最多攻击次数。

　　（注意技能没有开场CD，时间为0时即可攻击）

(看上去像是简单的网络流+简单的计算几何凑了一道码农题)

——Frozen Nova霜冻新星 怎么翻译成冷冻波这种奇怪的名字啊？   （亡灵族玩家激怒）

——为什么要屠杀小精灵啊？  （NE玩家激怒）

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<cmath>
 #include<queue>
 #include<vector>
 #define LL long long
 using namespace std;
 const int INF=0x3f3f3f3f;
 const int mxN=;
 const int mxn=;
 int read(){
     int x=,f=;char ch=getchar();
     while(ch<'' || ch>''){if(ch=='-')f=-f;ch=getchar();}
     while(ch>='' && ch<=''){x=x*-''+ch;ch=getchar();}
     return x*f;
 }
 struct edge{
     int u,v,nxt,f;
 }e[mxN];
 int hd[mxn*mxn],mct=;
 int n,m,S,T,d[mxN];
 void add_edge(int u,int v,int f){
     e[++mct].v=v;e[mct].u=u;e[mct].nxt=hd[u];e[mct].f=f;hd[u]=mct;return;
 }
 void insert(int u,int v,int f){
     add_edge(u,v,f);add_edge(v,u,);return;
 }
 //
 queue<int>q;
 bool BFS(){
     for(int i=;i<=T;i++)d[i]=;
     d[S]=; q.push(S);
     while(!q.empty()){
         int u=q.front();q.pop();
         for(int i=hd[u];i;i=e[i].nxt){
             int v=e[i].v;
             if(e[i].f && !d[v]){
                 d[v]=d[u]+;
                 q.push(v);
             }
         }
     }
     return d[T];
 }
 int DFS(int u,int lim){
     if(u==T)return lim;
     int f=,tmp;
     for(int i=hd[u];i;i=e[i].nxt){
         int v=e[i].v;
         if(e[i].f && d[v]==d[u]+ && (tmp=DFS(v,min(lim,e[i].f)))){
             e[i].f-=tmp;
             e[i^].f+=tmp;
             lim-=tmp;
             f+=tmp;
             if(!lim)return f;
         }
     }
     d[u]=;
     return f;
 }
 int Dinic(){
     int res=;
     while(BFS())res+=DFS(S,INF);
     return res;
 }
 //
 struct point{
     double x,y;
     point(){}
     point(double _x,double _y):x(_x),y(_y){}
     point operator - (const point &b){return point(x-b.x,y-b.y);}
 }lich[mxn],tr[mxn],wisp[mxn];
 int range[mxn],CD[mxn],R[mxn];
 double Cross(const point &a,const point &b){return a.x*b.y-a.y*b.x;}
 double DT(double x){
     if(fabs(x)<1e-)return ;
     return (x>)?:-;
 }
 double Dist(const point &a,const point &b){
     return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
 }
 int K;
 //
 bool check(int a,int b){
     double tmp=Dist(lich[a],wisp[b]);
     if(tmp+1e->(double)range[a])return ;
     for(int i=;i<=K;i++){
         double res=Cross(wisp[b]-lich[a],tr[i]-lich[a]);
         if(DT(res)==){
             if(Dist(lich[a],wisp[b])+R[i]<max(Dist(lich[a],tr[i]),Dist(wisp[b],tr[i])))return ;
             continue;
         }
         else{
             double h=fabs(res)/tmp;
             if(h+1e-<R[i])return ;
         }
     }
     return ;
 }
 //
 vector<int>ve[mxn];
 bool vis[mxn];
 void Build(int lim){
     memset(hd,,sizeof hd);mct=;
     int i,j;
     for(i=;i<=m;i++)insert(S,i,);
     for(i=;i<=n;i++)insert(m+i,T,lim/CD[i]+);
     for(i=;i<=n;i++)
         for(j=;j<ve[i].size();j++)
             insert(ve[i][j],m+i,);
     return;
 }
 void solve(){
     S=;T=n+m+;
     int l=,r=1e7,ans=INF;
     while(l<=r){
         int mid=(l+r)>>;
         Build(mid);
         int tmp=Dinic();
         if(tmp==m){
             ans=mid;r=mid-;
         }else l=mid+;
     }
     printf("%d\n",ans);
     return;
 }
 //

 int main(){
 //    freopen("in.txt","r",stdin);
     int i,j;
     n=read();m=read();K=read();
     for(i=;i<=n;i++){
         lich[i].x=read();lich[i].y=read();
         range[i]=read();CD[i]=read();
     }
     for(i=;i<=m;i++){
         wisp[i].x=read();wisp[i].y=read();
     }
     for(i=;i<=K;i++){tr[i].x=read();tr[i].y=read();R[i]=read();}
     for(i=;i<=n;i++)
         for(j=;j<=m;j++)
             if(check(i,j)){
                 ve[i].push_back(j);
                 vis[j]=;
             }
     for(i=;i<=m;i++){
         if(!vis[i]){
             printf("-1\n");
             return ;
         }
     }
     solve();
     return ;
 }