HDOJ 4183 - Pahom on Water 拆点最大流

                 题意:

                          有很多的圆..每个圆有颜色(颜色用频率来表示)...可以从一个圆走到另一个圆必须当他们有交集,....并且保证图中有且仅有一个红色圆和一个紫色圆....除了红色和紫色..每个圆经过一次就消失了...问能否从红色到紫色再从紫色回到红色..从红色往紫色走的时候必须保证路径上的颜色频率不递减.从紫色往红色走时必须保证路径上的颜色不递增..

                 题解:

                          由于一个点至多经过一次..那么就想到了用拆点来限制点的经过次数...这里注意的是起点和终点拆点后入点到出点的容量是2...其他点的都是1..这样满足题目要求...然后就是根据圆相交的关系来做有向边了..题目是说要走来回..可以理解为从红色走到紫色.两条除了起点终点没有共同点的路径...这样..就圆与圆之间有交集并且起点的频率不大于终点的频率的就构有向边.容量为无穷大...最后跑最大流..流量为2就说明是valid的...                         

Program:

#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<queue>
#define MAXN 2005
#define MAXM 20000005
#define oo 1000000007
#define ll long long
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=0;i<=n;i++) _next[i]=-1;   
             Lnum=-1;    
      }     
      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=0;                 
      }    
      bool BFS(int s,int e)    
      {     
             queue<int> Q;    
             while (!Q.empty()) Q.pop();    
             memset(dis,0,sizeof(dis));    
             dis[s]=1,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!=-1;k=line[k].next)    
                      if (line[k].c && !dis[line[k].y])    
                         dis[line[k].y]=dis[h]+1,Q.push(line[k].y);                     
             }     
             return false;    
      }    
      int dfs(int x,int flow,int e)      
      {          
             if (x==e) return flow;       
             int temp,cost=0;      
             for (int k=_next[x];k!=-1;k=line[k].next)      
             if (line[k].c && dis[line[k].y]==dis[x]+1)      
             {      
                    temp=dfs(line[k].y,min(flow-cost,line[k].c),e);       
                    if (temp)      
                    {      
                           line[k].c-=temp,line[k^1].c+=temp;      
                           cost+=temp;      
                           if (flow==cost) return cost;      
                    }else dis[line[k].y]=-1;      
             }      
             return cost;      
      }      
      int MaxFlow(int s,int e)    
      {    
             int MaxFlow=0;     
             while (BFS(s,e)) MaxFlow+=dfs(s,oo,e);     
             return MaxFlow;    
      } 
}T;  
struct node
{
      int x,y,r;
      double f;
      bool operator <(node a) const
      {
              return f<a.f;
      }
}P[305];
bool intersection(node a,node b)
{
      int dis=(a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y),R=(a.r+b.r)*(a.r+b.r);
      return dis<=R;
}
int main() 
{
      int C,cases,s,e,n,i,j; 
      scanf("%d",&C);
      for (cases=1;cases<=C;cases++)
      {
              scanf("%d",&n);
              T.initial(n<<2);
              for (i=0;i<n;i++) scanf("%lf%d%d%d",&P[i].f,&P[i].x,&P[i].y,&P[i].r); 
              sort(P,P+n);
              for (i=0;i<n;i++)
              {
                     T.addline(i<<1,i<<1|1,1);
                     for (j=i+1;j<n;j++) 
                        if (intersection(P[i],P[j]))
                           T.addline(i<<1|1,j<<1,oo);
              }
              T.addline(0,1,1);
              T.addline((n-1)<<1,(n-1)<<1|1,1); // 起点和终点是可以经过两次的..加容量
              s=0,e=(n-1)<<1|1;
              if (T.MaxFlow(s,e)==2) printf("Game is VALID\n");
                               else  printf("Game is NOT VALID\n");
      }
      return 0;
}