hdu 2334 March of the Penguins

  题意大意

在X,Y坐标系中有N(N<=100)个冰块，有些冰块上有1若干只企鹅，每只企鹅一次最多跳M距离，一个冰块在有Mi个企鹅离开，就会消失，问有哪些冰块可以作为集合点，就是所有企鹅都能成功到这个冰块上来

题目分析

 枚举点作为结束点，由于每个点有出企鹅的限制，用拆点来解决，一个点拆成"起点"和"终点"，“起点"到"终点"的流量为最大离开企鹅数，而超级源点与每个点的"起点"做边，容量为其企鹅的数量，再根据各之间的关系做边，最后跑最  大流判断是否=总企鹅数

 #include<cstdio>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #include<cmath>
 #include<string>
 #include<queue>
 #include<stack>
 #include<map>
 #include<vector>
 #define maxn 5000
 #define MAXN 2005
 #define MAXM 20000005
 #define INF  100000000
 #define oo 1000000007
 using namespace  std;

 struct Dinic
 {
       struct node
       {
              int x,y,c,next;
       }line[MAXM];
       int Lnum,_next[MAXN],dis[MAXN],dp[MAXN];
       bool inqueue[MAXN];
       void initial(int n)
       {
              for (int i=;i<=n;i++) _next[i]=-;
              Lnum=-;
       }
       void addline(int x,int y,int c)
       {
              line[++Lnum].next=_next[x],_next[x]=Lnum;
              line[Lnum].x=x,line[Lnum].y=y,line[Lnum].c=c;
              line[++Lnum].next=_next[y],_next[y]=Lnum;
              line[Lnum].x=y,line[Lnum].y=x,line[Lnum].c=;
       }
       bool BFS(int s,int e)
       {
              queue<int> Q;
              while (!Q.empty()) Q.pop();
              memset(dis,,sizeof(dis));
              dis[s]=,Q.push(s);
              while (!Q.empty())
              {
                    int h,k;
                    h=Q.front(),Q.pop();
                    if (h==e) return dis[e];
                    for (k=_next[h];k!=-;k=line[k].next)
                       if (line[k].c && !dis[line[k].y])
                          dis[line[k].y]=dis[h]+,Q.push(line[k].y);
              }
              return false;
       }
       int dfs(int x,int flow,int e)
       {
              if (x==e) return flow;
              int temp,cost=;
              for (int k=_next[x];k!=-;k=line[k].next)
              if (line[k].c && dis[line[k].y]==dis[x]+)
              {
                     temp=dfs(line[k].y,min(flow-cost,line[k].c),e);
                     if (temp)
                     {
                            line[k].c-=temp,line[k^].c+=temp;
                            cost+=temp;
                            if (flow==cost) return cost;
                     }else dis[line[k].y]=-;
              }
              return cost;
       }
       int MaxFlow(int s,int e)
       {
              int MaxFlow=;
              while (BFS(s,e)) MaxFlow+=dfs(s,oo,e);
              return MaxFlow;
       }
 }T;
 struct Point
 {
     int x,y,n,m;
 };
 Point p[maxn];

 int dist(int s,int t,double dd)
 {
     return (p[s].x-p[t].x)*(p[s].x-p[t].x)+(p[s].y-p[t].y)*(p[s].y-p[t].y)<=dd;
 }
 int vist[maxn][maxn];
 bool judge(int e,int n,int sum)
 {
       int i,j,s=n*+;
       T.initial(n*+);
       for (i=;i<n;i++) T.addline(s,i<<,p[i].n),T.addline(i<<,i<<|,p[i].m);
       for (i=;i<n;i++)
          for (j=;j<n;j++)
             if (i!=j && vist[i][j])
                T.addline(i<<|,j<<,oo);
       return T.MaxFlow(s,e)==sum;
 }
 int main()
 {
     int t,n;
     double d;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d%lf",&n,&d);
         d=d*d;
         int sum=;
         for(int i=;i<n;i++)
             scanf("%d %d %d %d",&p[i].x,&p[i].y,&p[i].n,&p[i].m),sum+=p[i].n;
         //memset(vist,0,sizeof(vist));
         for(int i=;i<n;i++)
             for(int j=;j<n;j++)
             {
               if((p[i].x-p[j].x)*(p[i].x-p[j].x)+(p[i].y-p[j].y)*(p[i].y-p[j].y)<=d)
                  vist[i][j]=;
               else
                  vist[i][j]=;
             }

         int flag=;
         for(int i=;i<n;i++)
         {
             if(judge(i*,n,sum))
             {
                 flag++;
                 if(flag==)
                     printf("%d",i);
                 else
                     printf(" %d",i);
             }
         }
         if(flag==)
             printf("-1");
         printf("\n");
     }
     return ;
 }