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[444][444],f[444][444],level[444];
bool bfs(){
    memset(level,0,sizeof(level));
    bool vis[444]={0};
    vis[vs]=1;
    int que[444],front=0,rear=0;
    que[rear++]=vs;
    while(front<rear){
        int u=que[front++];
        for(int v=1; v<=NV; ++v){
            if(vis[v] || c[u][v]==f[u][v]) continue;
            level[v]=level[u]+1;
            vis[v]=1;
            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=1; v<=NV; ++v){
        if(level[v]!=level[u]+1 || 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=0;
    while(bfs()) res+=dfs(vs,INF);
    return res;
}
int main(){
    int a;
    scanf("%d%d%d",&n,&vs,&vt);
    NV=n<<1;
    for(int i=1;i<=n;++i){
        c[i][i+n]=1;
        for(int j=1;j<=n;++j){
            scanf("%d",&a);
            if(i==j || a==0) 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 0;
    }
    int ans=dinic();
    printf("%d
",ans);
    for(int i=1; i<=n&&ans; ++i){
        if(i==vs||i==vt || f[i][i+n]==0) continue;
        memset(f,0,sizeof(f));
        c[i][i+n]=0;
        if(dinic()<ans){
            --ans;
            printf("%d ",i);
        }else{
            c[i][i+n]=1;
        }
    }
    return 0;
}