最大流算法模板

//最大流
//memset(head,-1,sizeof(head));
//en=0;

struct edge{
    int x,y,c,nxt;
}e[E];

bool del[V];

int head[V],d[V],q[V],stk[V],pre[V],en,src,dest;

void addedge(int x,int y,int c){
    e[en].x=x;
    e[en].y=y;
    e[en].c=c;
    e[en].nxt=head[x];
    head[x]=en++;
    e[en].x=y;
    e[en].y=x;
    e[en].c=0;
    e[en].nxt=head[y];
    head[y]=en++;
}

bool bfs(int s){
    int i,j,r=1;
    memset(d,-1,sizeof(d));
    q[0]=s;
    d[s]=0;
    for(i=0;i<r;i++)
        for(j=head[q[i]];j!=-1;j=e[j].nxt)
            if(d[e[j].y]==-1&&e[j].c>0){
                d[e[j].y]=d[q[i]]+1;
                q[r++]=e[j].y;
            }
            if(d[dest]<0)
                return false;
            return true;
}

int dinic_dfs(){
    int top=0,ret=0,cur,ptr,minf,i;
    memset(del,false,sizeof(del));
    stk[top++]=src;
    pre[src]=src;
    cur=src;
    while(top){
        while(cur!=dest&&top){
            for(i=head[cur];i!=-1;i=e[i].nxt)
                if(d[e[i].y]==d[cur]+1&&e[i].c>0&&!del[e[i].y]){
                    stk[top++]=e[i].y;
                    cur=e[i].y;
                    pre[e[i].y]=i;
                    break;
                }
                if(i==-1){
                    del[cur]=true;
                    top--;
                    if(top)
                        cur=stk[top-1];
                }
        }
        if(cur==dest){
            minf=inf;
            while(cur!=src){
                cur=pre[cur];
                if(e[cur].c<minf)
                    minf=e[cur].c;
                cur=e[cur].x;
            }
            cur=dest;
            while(cur!=src){
                cur=pre[cur];
                e[cur].c-=minf;
                e[cur^1].c+=minf;
                if(e[cur].c==0)
                    ptr=e[cur].x;
                cur=e[cur].x;
            }
            while(top>0&&stk[top-1]!=ptr)
                top--;
            if(top)
             cur=stk[top-1];
            ret+=minf;
        }
    }
    return ret;
}

int Dinic(){
    int ret=0;
    while(bfs(src))
        ret+=dinic_dfs();
    return ret;
}

//最大流
//memset(r,0,sizeof(r));

bool visited[N];
int n,r[N][N],pre[N];

bool bfs(int s,int t){
    int cur,i;
    queue<int> Q;
    memset(visited,false,sizeof(visited));
    visited[s]=true;
    Q.push(s);
    while(!Q.empty()){
        cur=Q.front();
        Q.pop();
        for(i=0;i<n;i++)
            if(!visited[i]&&r[cur][i]>0){
                pre[i]=cur;
                if(i==t)
                    return true;
                visited[i]=true;
                Q.push(i);
            }
    }
    return false;
}

int maxflow(int s,int t){
    int i,flow=0,d;
    while(bfs(s,t)){
        d=INT_MAX;
        for(i=t;i!=s;i=pre[i])
            d=min(d,r[pre[i]][i]);
        for(i=t;i!=s;i=pre[i]){
            r[pre[i]][i]-=d;
            r[i][pre[i]]+=d;
        }
        flow+=d;
    }
    return flow;
}