POJ 1815 (最小割的点集)

题意 ： 从s到t的连通图中，最少删除多少个点，可以使s和t不连通，也就是求一个最小点割集

解题思路：最大流，拆点和枚举

每个点拆成两个点，这两个点之间的容量为1，源点和终点拆成的点容量为无穷大，这样把删点问题变成删边问题，就可以用最小割搞了

当一个点和另一个点有边时，假设是i和j两个点， 那么i拆成两个点i, i'，j拆成两个点j, j'， i'和j连接，容量为无穷大

但是这个题目要求输出字典序最小的结果，那么就需要依次枚举每个点，如果删掉这个点之后最小割变小了，那么就说明这个点是最小割中的点，将其删除，否则就说名这个点不是最小割中的点，将其恢复。然后重复上面的操作就可以得到字典序最小的序列了。

#include<cstdio>
#include<cstring>
#include<map>
#include<vector>
#include<cmath>
#include<cstdlib>
#include<stack>
#include<queue>
#include <iomanip>
#include<iostream>
#include<algorithm>
using namespace std ;
const int N=500 ;
const int M=100000 ;
const int inf=1<<30 ;
struct node
{
	int u ,v,c,next;
}edge[M] ;
int head[N],pre[N],cur[N],dis[N],gap[N],g[N][N],vist[N],a[N] ;
int top ,n,s,t,S,T,nv;

void add(int u ,int v,int c)     
{    
    edge[top].u=u;    
    edge[top].v=v;    
    edge[top].c=c;    
    edge[top].next=head[u];    
    head[u]=top++;    
    edge[top].u=v;    
    edge[top].v=u;    
    edge[top].c=0;    
    edge[top].next=head[v];    
    head[v]=top++;    
}
int sap()  
{  
    memset(dis,0,sizeof(dis));  
    memset(gap,0,sizeof(gap));  
    int u,v,minflow=inf,flow=0;  
    for(int i = 0 ; i <nv ; i++)  cur[i]=head[i] ;  
    u=pre[s]=s;  
    gap[s]=nv;  
    while(dis[s] < nv )  
    {  
            loop :  
               for(int &j=cur[u] ; j!=-1 ; j=edge[j].next)                 
               {  
                     v=edge[j].v ;  
                     if(edge[j].c > 0 && dis[u] == dis[v] +1 )  
                     {  
                              minflow = min(minflow ,edge[j].c) ;  
                              pre[v]=u;  
                              u=v ;  
                          if(v==t)  
                          {    
                                for( u =pre[v] ; v!=s ;v=u,u=pre[u])  
                                      {  
                                            edge[cur[u]].c -= minflow ;   
                                            edge[cur[u]^1].c += minflow ;  
                                      }   
                                flow += minflow ;  
                                minflow = inf ;  
                          }  
                         goto loop ;  
                     }  
               }  
           int mindis=nv ;  
           for(int i = head[u] ; i!=-1 ; i=edge[i].next)  
           {  
                  v=edge[i].v ;  
                  if(edge[i].c > 0 && dis[v] < mindis)  
                  {  
                       mindis = dis[v] ;  
                       cur[u]=i ;         
                 }  
           }  
          if(--gap[dis[u]]==0) break ;  
          gap[ dis[u] = mindis +1 ]++  ;  
          u=pre[u] ;  
    }  
    return flow ;  
}

void build()
{
	   top = 0 ;
	   memset(head,-1,sizeof(head)) ;
	  for(int i = 1; i <= n; i ++)
        for(int j = i + 1; j <= n; j ++)
            if(g[i][j])
            {
                add(n+i,j,inf) ;
                add(n+j,i,inf) ;   
            }
    for(int i = 1; i <= n; i ++)
        if(!vist[i])
        {
        	if(i==S || i==T)
			  add(i,n+i,inf) ;
             else add(i,n+i,1) ;
		}
}

int main()
{
      int q ;
	 while(~scanf("%d%d%d",&n,&S,&T))
	 {
	 	     for(int i = 1 ; i <= n ; i++)
	 	       for(int j = 1 ; j <= n ; j++)
	 	          scanf("%d",&g[i][j]);
	 	          
	 	    memset(vist,0,sizeof(vist)) ;
	 	    if(g[S][T]) 
	 	    {
	 	    	  printf("NO ANSWER!\n");
	 	    }else
	 	 {
	 	 	 
			s=S;t=n+T;nv=2*n;
	 	    build() ;
	 	    int num,q  ,k=0,tmp=0;
	 	    q=num=sap() ;
	 	  for(int i = 1 ; i <= n && tmp < q ;i++)
	 	  {
	 	  	   if(i!=S && i!=T)
	 	  	   {
	 	  	   	    vist[i]=1;
	 	  	   	    build();
	 	  	   	    if( (k=sap()) < num ) 
	 	  	   	    {
	 	  	   	    	  num = k ;
	 	  	   	    	  a[tmp++]=i;
	 	  	   	    }
	 	  	   	    else   vist[i]=0;
	 	      }
	 	  }
	 	  printf("%d\n",q) ;
	 	 if(q)
         {
              printf("%d", a[0]);
              for(int i = 1; i < q; i++) printf(" %d", a[i]);
                 printf("\n");
         }
       }
	 }
	 return 0 ;
}