hdu 4289 最大流拆点

大致题意：
    给出一个又n个点，m条边组成的无向图。给出两个点s，t。对于图中的每个点，去掉这个点都需要一定的花费。求至少多少花费才能使得s和t之间不连通。

大致思路：
    最基础的拆点最大流，把每个点拆作两个点 i 和 i' 连接i->i'费用为去掉这个点的花费，如果原图中有一条边a->b则连接a'->b。对这个图求出最大流即可。

画了个图，仔细看看似乎是这么回事

 //
 /*
 HDU 4289
 G++  62ms  1888K
 最大流
 SAP
 */
 #include<stdio.h>
 #include<iostream>
 #include<map>
 #include<set>
 #include<algorithm>
 #include<string.h>
 #include<stdlib.h>
 using namespace std;

 const int MAXN=;//点数的最大值
 const int MAXM=;//边数的最大值
 const int INF=0x3f3f3f3f;

 struct Node
 {
     int from,to,next;
     int cap;
 }edge[MAXM];
 int tol;
 int head[MAXN];
 int dep[MAXN];
 int gap[MAXN];//gap[x]=y:说明残留网络中 dep[i]==x的个数为y

 int n;//点的实际个数，一定是总的点的个数，包括源点和汇点
 void init()
 {
     tol=;
     memset(head,-,sizeof(head));
 }
 void addedge(int u,int v,int w)
 {
     edge[tol].from=u;
     edge[tol].to=v;
     edge[tol].cap=w;
     edge[tol].next=head[u];
     head[u]=tol++;
     edge[tol].from=v;
     edge[tol].to=u;
     edge[tol].cap=;
     edge[tol].next=head[v];
     head[v]=tol++;
 }
 void BFS(int start,int end)
 {
     memset(dep,-,sizeof(dep));
     memset(gap,,sizeof(gap));
     gap[]=;
     int que[MAXN];
     int front,rear;
     front=rear=;
     dep[end]=;
     que[rear++]=end;
     while(front!=rear)
     {
         int u=que[front++];
         if(front==MAXN)front=;
         for(int i=head[u];i!=-;i=edge[i].next)
         {
             int v=edge[i].to;
             if(edge[i].cap!=||dep[v]!=-)continue;
             que[rear++]=v;
             if(rear==MAXN)rear=;
             dep[v]=dep[u]+;
             ++gap[dep[v]];
         }
     }
 }
 int SAP(int start,int end)
 {
     int res=;
     BFS(start,end);
     int cur[MAXN];
     int S[MAXN];
     int top=;
     memcpy(cur,head,sizeof(head));
     int u=start;
     int i;
     while(dep[start]<n)
     {
         if(u==end)
         {
             int temp=INF;
             int inser;
             for(i=;i<top;i++)
                if(temp>edge[S[i]].cap)
                {
                    temp=edge[S[i]].cap;
                    inser=i;
                }
             for(i=;i<top;i++)
             {
                 edge[S[i]].cap-=temp;
                 edge[S[i]^].cap+=temp;
             }
             res+=temp;
             top=inser;
             u=edge[S[top]].from;
         }
         if(u!=end&&gap[dep[u]-]==)//出现断层，无增广路
           break;
         for(i=cur[u];i!=-;i=edge[i].next)
            if(edge[i].cap!=&&dep[u]==dep[edge[i].to]+)
              break;
         if(i!=-)
         {
             cur[u]=i;
             S[top++]=i;
             u=edge[i].to;
         }
         else
         {
             int min=n;
             for(i=head[u];i!=-;i=edge[i].next)
             {
                 if(edge[i].cap==)continue;
                 if(min>dep[edge[i].to])
                 {
                     min=dep[edge[i].to];
                     cur[u]=i;
                 }
             }
             --gap[dep[u]];
             dep[u]=min+;
             ++gap[dep[u]];
             if(u!=start)
               u=edge[S[--top]].from;
         }

     }
     return res;
 }

 int main()
 {
     //freopen("B.in","r",stdin);
     //freopen("B.out","w",stdout);
     int N,M;
     int u,v;
     int start;
     int end;
     while(scanf("%d%d",&N,&M)!=EOF)
     {
         init();
         scanf("%d%d",&start,&end);
         start=*start-;
         end=*end;
         n=*N;
         for(int i=;i<=N;i++)
         {
             scanf("%d",&u);
             addedge(*i-,*i,u);
             addedge(*i,*i-,u);
         }
         while(M--)
         {
             scanf("%d%d",&u,&v);
             addedge(*u,*v-,INF);
             addedge(*v,*u-,INF);//这里一定要注意
         }
         printf("%d\n",SAP(start,end));
     }
     return ;
 }