【网络流各种模板】

EK 复杂度O(V*E*E)

#define N 204  
  
int c[N][N];//边容量  
int f[N][N];//边实际流量  
int pre[N];//记录增广路径  
int res[N];//残余网络  
queue<int> qq;  
void init(){  
    while(!qq.empty())qq.pop();  
    memset(c,0,sizeof(c));  
    memset(f,0,sizeof(f));  
}  
int EK(int s,int t){  
    int i,j;  
    int ans=0;  
    while(1){  
        memset(res,0,sizeof(res));  
        res[s] = MAX;//源点的残留网络要置为无限大！否则下面找增广路出错  
        pre[s] = -1;  
        qq.push(s);  
        //bfs找增广路径  
        while(!qq.empty()){  
            int x = qq.front();  
            qq.pop();  
            for(i=1;i<=t;i++){  
                if(!res[i] && f[x][i] < c[x][i]){  
                    qq.push(i);  
                    pre[i] = x;  
                    res[i] = min(c[x][i] - f[x][i], res[x]);//这里类似dp，如果有增广路，那么res[t]就是增广路的最小权  
                }  
            }  
        }  
        if(res[t]==0)break;//找不到增广路就退出  
        int k = t;  
        while(pre[k]!=-1){  
            f[pre[k]][k] += res[t];//正向边加上新的流量  
            f[k][pre[k]] -= res[t];//反向边要减去新的流量，反向边的作用是给程序一个后悔的机会  
            k = pre[k];  
        }  
        ans += res[t];  
    }  
    return ans;  
}  

Dinic递归（推荐）

#define M 400  
  
struct node {  
    int u, v, next, cap;  
} edge[M*M];  
int next[M], head[M], layer[M], Q[M * 2], mark[M];  
int ecnt;  
void init(){  
    ecnt= 0;  
    memset(head,-1,sizeof(head));  
}  
void add(int u, int v, int c) {  
    edge[ecnt].u = u;  
    edge[ecnt].v = v;  
    edge[ecnt].cap = c;  
    edge[ecnt].next = head[u];  
    head[u] = ecnt++;  
  
    edge[ecnt].u = v;  
    edge[ecnt].v = u;  
    edge[ecnt].cap = 0;  
    edge[ecnt].next = head[v];  
    head[v] = ecnt++;  
}  
  
bool BFS(int begin, int end) {  
    int i, l, h, k, y;  
    for (i = 0; i <= end; i++) layer[i] = -1;  
    layer[begin] = 0;  
    l = h = 0;  
    Q[l++] = begin;  
    while (h < l) {  
        k = Q[h++];  
        for (i = head[k]; i != -1; i = edge[i].next) {  
            y = edge[i].v;  
            if (edge[i].cap > 0 && layer[y] == -1) {  
                layer[y] = layer[k] + 1;  
                if (y == end)  
                    return true;  
                Q[l++] = y;  
            }  
        }  
    }  
    return false;  
}  
  
int DFS(int x, int exp, int end) {  
    mark[x] = 1;  
    if (x == end)return exp;  
    int y, temp, i;  
    for (i = next[x]; i != -1; i = edge[i].next, next[x] = i) {  
        y = edge[i].v;  
        if (edge[i].cap > 0 && layer[y] == layer[x] + 1 && !mark[y]) {  
            if ((temp = (DFS(y, min(exp, edge[i].cap), end))) > 0) {  
                edge[i].cap -= temp;//流完后正向流表示剩余流量  
                edge[i^1].cap += temp;//流完后反向流表示正向流的流量  
                return temp;  
            }  
        }  
    }  
    return 0;  
}  
  
int Dinic_flow(int begin, int end) {  
    int i, ans = 0, flow;  
    while (BFS(begin, end)) {  
        for (i = 0; i <= end; i++)next[i] = head[i];  
        while (true) {  
            for (i = 0; i <= end; i++) mark[i] = 0;  
            flow = DFS(begin, INT_MAX, end);  
            if (flow == 0)break;  
            ans += flow;  
        }  
    }  
    return ans;  
}  

Dinic非递归 复杂度O(V^2*E)

#define N 20100
#define sta que
//静态邻接表
int level[N];
int p[N],p1[N];
int ecnt;
int que[N];
int n,m;

struct edge{
    int v,next;
    int c;
}e[900000];
void init(){
    ecnt = 0;
    memset(p,-1,sizeof(p));
}
void insert(int u,int v,int c,int w){
    e[ecnt].v = v;
    e[ecnt].c = c;
    e[ecnt].next = p[u];
    p[u] = ecnt++;
    e[ecnt].v = u;
    e[ecnt].c = w;
    e[ecnt].next = p[v];
    p[v] = ecnt++;
}
int Dinic(int st,int ed){
    int ans = 0;
    int i,u,v,c;
    int head,rear,top;
    while(1){//重建层次图
        memset(level,0,sizeof(level));
        head = rear = 0;
        level[st]=1;
        que[rear++]=st;
        while(head<rear){
            u = que[head++];
            for(i=p[u];i!=-1;i=e[i].next){
                v = e[i].v;
                c = e[i].c;
                if(c && level[v] == 0){
                    level[v] = level[u]+1;
                    que[rear++]=v;
                }
            }
        }
        if(level[ed] == 0){//无增广路
            break;
        }
        memcpy(p1,p,sizeof(p1));
        top = -1;
        while(1){
            if(top<0){
                for(i=p1[st];i!=-1;i=e[i].next){
                    v = e[i].v;
                    c = e[i].c;
                    if(c && p1[v] != -1 && level[v] == 2)break;
                }
                if(i>=0){
                    sta[++top] = i;
                    p1[st] = e[i].next;
                } else break;
            }
            u = e[sta[top]].v;
            if(u == ed){//找到一条增广路
//计算流的可改进量，并记录离源点最远的可能会组成下一条增广路径的边
                int dd = MAX,index = -1;
                for(i=0;i<=top;i++){
                    if(dd>e[sta[i]].c){
                        dd = e[sta[i]].c;
                        index = i;
                    }
                }
                ans += dd;
                //调整残余网络
                for(i=0;i<=top;i++){
                    //直接由上一残余网络计算当前残余网络 见导论P401
                    e[sta[i]].c -= dd;
                    e[sta[i]^1].c += dd;
                }
                //回溯到路径上某个可能继续增广的顶点，若该顶点也无法增广，则回溯到前一个顶点(1)
                for(i=0;i<=top;i++){
                    if(e[sta[i]].c==0){
                        top = index-1;
                        break;
                    }
                }
            } else {
                for(i=p1[u];i!=-1;i = e[i].next){
                    v = e[i].v;
                    c = e[i].c;
                    if(c && p1[v]!=-1 && level[u]+1 == level[v])break;
                }
                if(i!=-1){
                    sta[++top] = i;
                    p1[u] = e[i].next;//若沿着边i找到了增广路，则p1会被从新初始化；否则断定从边i出发无法到达汇点，以后搜索增广路将不再考虑此边。估可将其忽略
                } else {
                    p1[u] = -1;
                    top--;
                }
            }
        }
    }
    return ans;
}

SAP非递归  复杂度O(V*V*E)

#define N 440  
#define M N*N  
#define inf 1<<30
int head[N];  
struct Edge  {  
    int v,next,c;  
}edge[M];  
int ecnt;  

void init(){  
    ecnt = 0;  
    memset(head,-1,sizeof(head));  
}  
void add(int u,int v,int w) {  
    edge[ecnt].v=v;  
    edge[ecnt].c=w;  
    edge[ecnt].next=head[u];  
    head[u]=ecnt++;  
    edge[ecnt].v=u;  
    edge[ecnt].c=0;  
    edge[ecnt].next=head[v];  
    head[v]=ecnt++;  
}  
int sap(int s,int t,int nodenum){ //源，汇，汇点编号（非点数）  
    int pre[N],cur[N],dis[N],gap[N];  
    int flow=0,aug=inf;  
    int u;  
    bool flag;  
    int i,j;  
    for(i=0;i<=nodenum;i++){  
            cur[i]=head[i];  
            gap[i]=dis[i]=0;  
    }  
    gap[s]=nodenum;  
    u=pre[s]=s;  
    while(dis[s]<nodenum){  
        flag=0;  
        for(j=cur[u];j!=-1;j=edge[j].next){  
                int v=edge[j].v;  
                if(edge[j].c>0 && dis[u]==dis[v]+1){  
                    flag=1;  
                    cur[u] = j;  
                    aug = min(aug,edge[j].c);  
                    pre[v]=u;  
                    u=v;  
                    if(u==t){  
                        flow+=aug;  
                        while(u!=s){    
                            u=pre[u];  
                            edge[cur[u]].c -= aug;    //边的正流不断减少 
                            edge[cur[u]^1].c += aug;  //反流增加
                        }  
                        aug=inf;  
                    }  
                    break;  
                }  
        }  
        if(flag)continue;  
        if(--gap[dis[u]] == 0)break;  
        for(dis[u] = nodenum, j=head[u]; j!=-1; j=edge[j].next){  
            int v=edge[j].v;  
            if(edge[j].c>0 && dis[v]<dis[u]){  
                dis[u]=dis[v];  
                cur[u]=j;  
            }  
        }  
        dis[u]++;  
        gap[dis[u]]++;  
        u=pre[u];  
    }  
    return flow;  
}  

ISAP + GAP优化 复杂度O(V^2*E)

#define N 20010 
#define M 500010
int n,m;//n为点数 m为边数  
int h[N];  
int gap[N];  
int p[N],ecnt;  
int source,sink;  
struct edge{  
    int v;  
    int next;//下一条边的编号  
    int val;//边权值  
}e[M];  
  
inline void init(){memset(p,-1,sizeof(p));ecnt=0;}  
   
//有向  
inline void add1(int from,int to,int val){  
    e[ecnt].v=to;  
    e[ecnt].val=val;  
    e[ecnt].next=p[from];  
    p[from]=ecnt++;  
   
    swap(from,to);  
   
    e[ecnt].v=to;  
    e[ecnt].val=0;  
    e[ecnt].next=p[from];  
    p[from]=ecnt++;  
}  
   
//无向  
inline void add2(int from,int to,int val){  
    e[ecnt].v=to;  
    e[ecnt].val=val;  
    e[ecnt].next=p[from];  
    p[from]=ecnt++;  
  
    swap(from,to);  
   
    e[ecnt].v=to;  
    e[ecnt].val=val;  
    e[ecnt].next=p[from];  
    p[from]=ecnt++;  
}  
   
  
inline int dfs(int pos,int cost){  
    if (pos==sink){  
        return cost;  
    }  
    int j,minh=n-1,lv=cost,d;  
    for (j=p[pos];j!=-1;j=e[j].next){  
        int v=e[j].v,val=e[j].val;  
        if(val>0){  
            if (h[v]+1==h[pos]){  
                if (lv<e[j].val) d=lv;  
                else d=e[j].val;  
   
                d=dfs(v,d);  
                e[j].val-=d;  
                e[j^1].val+=d;  
                lv-=d;  
                if (h[source]>=n) return cost-lv;  
                if (lv==0) break;  
            }  
   
            if (h[v]<minh)   minh=h[v];  
        }  
    }  
    if (lv==cost){  
        --gap[h[pos]];  
        if (gap[h[pos]]==0) h[source]=n;  
        h[pos]=minh+1;  
        ++gap[h[pos]];  
    }  
    return cost-lv;  
}  
   
int sap(int st,int ed){  
    source=st;  
    sink=ed;  
    int ans=0;  
    memset(gap,0,sizeof(gap));  
    memset(h,0,sizeof(h));  
    gap[st]=n;  
    while (h[st]<n){  
        ans+=dfs(st,INT_MAX);  
    }  
    return ans;  
}