BZOJ 1822 Frozen Nova 冷冻波（最大流）

struct node
{
    int v,cap,next;
};
 
 
node edges[N*N];
int head[N],e;
 
 
void add(int u,int v,int cap)
{
    edges[e].v=v;
    edges[e].cap=cap;
    edges[e].next=head[u];
    head[u]=e++;
}
 
 
void Add(int u,int v,int cap)
{
    add(u,v,cap);
    add(v,u,0);
}
 
 
int cur[N],h[N],num[N],pre[N];
 
 
int Maxflow(int s,int t,int n)
{
    int i;
    for(i=0;i<=n;i++) h[i]=num[i]=0,cur[i]=head[i];
    int u=s,ans=0,Min,k,x;
    while(h[u]<n)
    {
        if(u==t)
        {
            Min=INF+1;
            for(i=s;i!=t;i=edges[cur[i]].v)
            {
                x=cur[i];
                if(edges[x].cap<Min) Min=edges[x].cap,k=i;
            }
            ans+=Min; u=k;
            for(i=s;i!=t;i=edges[cur[i]].v)
            {
                x=cur[i];
                edges[x].cap-=Min;
                edges[x^1].cap+=Min;
            }
        }
        for(i=cur[u];i!=-1;i=edges[i].next)
        {
            if(edges[i].cap>0&&h[u]==1+h[edges[i].v])
            {
                break;
            }
        }
        if(i!=-1)
        {
            cur[u]=i;
            pre[edges[i].v]=u;
            u=edges[i].v;
        }
        else
        {
            if(--num[h[u]]==0) break;
            cur[u]=head[u];
            x=n;
            for(i=head[u];i!=-1;i=edges[i].next)
            {
                k=edges[i].v;
                if(edges[i].cap>0&&h[k]<x) x=h[k]; 
            }
            h[u]=x+1;
            num[x+1]++;
            if(u!=s) u=pre[u];
        }
    }
    return ans;
}
 
 
struct A
{
    int x,y,r,t;
     
    void get()
    {
        RD(x,y); RD(r,t);
    }
};
 
A a[N];
 
struct B
{
    int x,y;
    void get()
    {
        RD(x,y);
    } 
};
 
B b[N];
 
struct C
{
    int x,y,r;
     
    void get()
    {
        RD(x,y,r);
    }
};
 
C c[N];
 
int n,m,K;
vector<int> V[N];
 
int dis(int x,int y)
{
    return x*x+y*y;
}
  
int check(A pa,B pb,C pc)
{
    double a=sqrt(dis(pa.x-pb.x,pa.y-pb.y)*1.0);
    double b=sqrt(dis(pc.x-pb.x,pc.y-pb.y)*1.0);
    double c=sqrt(dis(pa.x-pc.x,pa.y-pc.y)*1.0);
    double p=(a+b+c)/2;
    double s=sqrt(p*(p-a)*(p-b)*(p-c));
    double tmp=a*pc.r/2;
    if(tmp>=s) return 0;
    return 1;
}
  
void init()
{
    int i,j,k;
    FOR1(i,n) FOR1(j,m)
    {
        if(dis(a[i].x-b[j].x,a[i].y-b[j].y)>a[i].r*a[i].r) continue;
        FOR1(k,K) if(!check(a[i],b[j],c[k])) break;
        if(k>K) V[i].pb(j);
    }
}
int OK(int mid)
{
    clr(head,-1); e=0;
    int s=0,t=n+m+1,i,j,k;
    FOR1(i,n) Add(s,i,mid/a[i].t+1);
    FOR1(i,m) Add(n+i,t,1);
    FOR1(i,n) FOR0(j,SZ(V[i]))
    {
        k=V[i][j];
        Add(i,n+k,1);
    }
    return Maxflow(s,t,t+1)==m;
}
 
 
int main()
{
    RD(n,m,K);
    int i,j;
    FOR1(i,n) a[i].get();
    FOR1(i,m) b[i].get();
    FOR1(i,K) c[i].get();
    init();
    int low=0,high=INF,mid,ans=-1;
    while(low<=high)
    {
        mid=(low+high)>>1;
        if(OK(mid)) ans=mid,high=mid-1;
        else low=mid+1;
    }
    PR(ans);
}