Bzoj1822 [JSOI2010]Frozen Nova 冷冻波

时间：2020-12-12 20:02:31

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

图论 网络流 计算几何

没什么意义的板子题

$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 ;

 }

相关文章