POJ1815 Friendship（字典序最小最小割割边集）

看了题解。当时也觉得用邻接矩阵挺好写的，直接memset；然而邻接矩阵不懂得改，于是就放开那个模板，写了Dinic。。

方法是，按字典序枚举每一条满流的边，然后令其容量减1，如果最大流改变了，这条边就是属于某个最小割；接下来一直重复下去，直到得到一个割边集，而它自然是字典序最小的。

我在每次某条边容量减1后都重新计算一遍最大流，简单。。其实我知道是有这么一回事，把边容量减1后可以利用当前求出的最大流来得出新的最大流，这样会快一些，不过我不会。。。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 #define INF (1<<30)
 int n,vs,vt,NV,c[][],f[][],level[];
 bool bfs(){
     memset(level,,sizeof(level));
     bool vis[]={};
     vis[vs]=;
     int que[],front=,rear=;
     que[rear++]=vs;
     while(front<rear){
         int u=que[front++];
         for(int v=; v<=NV; ++v){
             if(vis[v] || c[u][v]==f[u][v]) continue;
             level[v]=level[u]+;
             vis[v]=;
             que[rear++]=v;
         }

     }
     return vis[vt+n];
 }
 int dfs(int u,int s){
     if(u==vt+n) return s;
     int res=s,tmp;
     for(int v=; v<=NV; ++v){
         if(level[v]!=level[u]+ || c[u][v]==f[u][v]) continue;
         tmp=dfs(v,min(s,c[u][v]-f[u][v]));
         f[u][v]+=tmp;
         f[v][u]-=tmp;
         s-=tmp;
     }
     return res-s;
 }
 int dinic(){
     int res=;
     while(bfs()) res+=dfs(vs,INF);
     return res;
 }
 int main(){
     int a;
     scanf("%d%d%d",&n,&vs,&vt);
     NV=n<<;
     for(int i=;i<=n;++i){
         c[i][i+n]=;
         for(int j=;j<=n;++j){
             scanf("%d",&a);
             if(i==j || a==) continue;
             c[i+n][j]=INF;
         }
     }
     c[vs][vs+n]=INF; c[vt][vt+n]=INF;
     if(c[vs+n][vt]){
         puts("NO ANSWER!");
         return ;
     }
     int ans=dinic();
     printf("%d\n",ans);
     for(int i=; i<=n&&ans; ++i){
         if(i==vs||i==vt || f[i][i+n]==) continue;
         memset(f,,sizeof(f));
         c[i][i+n]=;
         if(dinic()<ans){
             --ans;
             printf("%d ",i);
         }else{
             c[i][i+n]=;
         }
     }
     return ;
 }