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=100010;
const int mxn=205;
int read(){
int x=0,f=1;char ch=getchar();
while(ch<'0' || ch>'9'){if(ch=='-')f=-f;ch=getchar();}
while(ch>='0' && ch<='9'){x=x*10-'0'+ch;ch=getchar();}
return x*f;
}
struct edge{
int u,v,nxt,f;
}e[mxN];
int hd[mxn*mxn],mct=1;
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,0);return;
}
//
queue<int>q;
bool BFS(){
for(int i=0;i<=T;i++)d[i]=0;
d[S]=1; 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]+1;
q.push(v);
}
}
}
return d[T];
}
int DFS(int u,int lim){
if(u==T)return lim;
int f=0,tmp;
for(int i=hd[u];i;i=e[i].nxt){
int v=e[i].v;
if(e[i].f && d[v]==d[u]+1 && (tmp=DFS(v,min(lim,e[i].f)))){
e[i].f-=tmp;
e[i^1].f+=tmp;
lim-=tmp;
f+=tmp;
if(!lim)return f;
}
}
d[u]=0;
return f;
}
int Dinic(){
int res=0;
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-6)return 0;
return (x>0)?1:-1;
}
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-6>(double)range[a])return 0;
for(int i=1;i<=K;i++){
double res=Cross(wisp[b]-lich[a],tr[i]-lich[a]);
if(DT(res)==0){
if(Dist(lich[a],wisp[b])+R[i]<max(Dist(lich[a],tr[i]),Dist(wisp[b],tr[i])))return 0;
continue;
}
else{
double h=fabs(res)/tmp;
if(h+1e-6<R[i])return 0;
}
}
return 1;
}
//
vector<int>ve[mxn];
bool vis[mxn];
void Build(int lim){
memset(hd,0,sizeof hd);mct=1;
int i,j;
for(i=1;i<=m;i++)insert(S,i,1);
for(i=1;i<=n;i++)insert(m+i,T,lim/CD[i]+1);
for(i=1;i<=n;i++)
for(j=0;j<ve[i].size();j++)
insert(ve[i][j],m+i,1);
return;
}
void solve(){
S=0;T=n+m+1;
int l=0,r=1e7,ans=INF;
while(l<=r){
int mid=(l+r)>>1;
Build(mid);
int tmp=Dinic();
if(tmp==m){
ans=mid;r=mid-1;
}else l=mid+1;
}
printf("%d\n",ans);
return;
}
//

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