网络流(三) 多源汇最大流，最大流之关键边

网络流(三) 多源汇最大流，最大流之关键边

多源汇最大流

建图方法，这种多起点题型很容易就能想到，建立一个超级源点，从超级源点向所有源点连一条容量是无穷大的边，再建立一个超级汇点， 所有汇点向超级汇点连一条容量为无穷大的边。在新图跑最大流即可得出原图的最大流。

建图如下：

参考代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#define int long long
using namespace std;
const int N = 1e4 + 10, M = 4e5 + 10, inf = 1e18;
int n, m, num_s, num_t, S, T;
int h[N], e[M], ne[M], f[M], idx;
int q[N], d[N], cur[N];

void add(int a, int b, int c){
    e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx ++;
    e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx ++;
}

bool bfs(){
    int hh = 0, tt = 0;
    memset(d, -1, sizeof(d));
    q[0] = S;
    d[S] = 0;
    cur[S] = h[S];
    while(hh <= tt){
        int t = q[hh ++];
        for(int i = h[t]; i != -1; i = ne[i]){
            int ver = e[i];
            if(d[ver] == -1 && f[i]){
                d[ver] = d[t] + 1;
                cur[ver] = h[ver];
                if(ver == T){
                    return true;
                }
                q[++ tt] = ver;
            }
        }
    }
    return false;
}
int find(int u, int limit){
    if(u == T){
        return limit; 
    }
    int flow = 0;
    for(int i = cur[u]; i != -1 && flow < limit; i = ne[i]){
        int ver = e[i];
        cur[u] = i;
        if(d[ver] == d[u] + 1 && f[i]){
            int t = find(ver, min(limit - flow, f[i]));
            if(!t){
                d[ver] = -1;
            }
            f[i] -= t;
            f[i ^ 1] += t;
            flow += t;
        }
    }
    return flow;
}
int dinic(){
    int r = 0, flow;
    while(bfs()){
        while(flow = find(S, inf - 10)){
            r += flow;
        }
    }
    return r;
}
signed main(){
    scanf("%lld%lld%lld%lld",&n, &m, &num_s, &num_t);
    memset(h, -1, sizeof(h));
    S = 0;
    T = n + 1;
    for(int i = 1; i <= num_s ; i ++ ){
        int a;
        scanf("%lld",&a);
        add(S, a, inf);
    }
    for(int i = 1; i <= num_t; i ++){
        int a;
        scanf("%lld", &a);
        add(a, T, inf);
    }
    for(int i = 1; i <= m ; i ++){
        int a, b, c;
        scanf("%lld%lld%lld",&a, &b, &c);
        add(a, b, c);
    }
    printf("%lld", dinic());
}

伊基的故事 I - 道路重建

关键边：只给其扩大容量之后整个流网络的最大流能够变大，对于这样的边我们称之为关键边。

思路：

​ 1、我们先对原图做一遍dinic；

​ 2、在当前最大流的残留网络上进行搜索，搜索在其残留网络上沿着容量大于0的边走，所有从源点能够到达的点和所有汇点能够到达的点，并打上标记。

​ 3、当一条边满足：满流($f[i]==0$)，并且他的起始点能从s点出发搜索到，终止点能够冲t点出发搜索到，则为关键边。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define int long long
using namespace std;
const int N = 1e3 + 10, M = 2e4 + 10, inf = 1e18;
int n, m, S, T;
int h[N], e[M], ne[M], f[M], idx;
int q[N], d[N], cur[N];
bool vis_s[N], vis_t[N];
void add(int a, int b, int c){
    e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx ++;
    e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx ++;
}

bool bfs(){
    int hh = 0, tt = 0;
    memset(d, -1, sizeof(d));
    q[0] = S;
    d[S] = 0;
    cur[S] = h[S];
    while(hh <= tt){
        int t = q[hh ++];
        for(int i = h[t]; i != -1; i = ne[i]){
            int ver = e[i];
            if(d[ver] == -1 && f[i]){
                d[ver] = d[t] + 1;
                cur[ver] = h[ver];
                if(ver == T){
                    return true;
                }
                q[ ++ tt ] = ver;
            }
        }
    }
    return false;
}

int find(int u, int limit){
    if(u == T){
        return limit;
    }
    int flow = 0;
    for(int i = cur[u]; i != -1 && flow < limit; i = ne[i]){
        cur[u] = i;
        int ver = e[i];
        if(d[ver] == d[u] + 1 && f[i]){
            int t = find(ver, min(f[i], limit - flow));
            if(!t){
                d[ver] = -1;
            }
            f[i] -= t;
            f[i ^ 1] += t;
            flow += t;
        }
    }
    return flow;
}

int dinic(){
    int r = 0, flow;
    while(bfs()){
        while(flow = find(S, inf)){
            r += flow;
        }
    }
    return flow;
}
void dfs(int u, bool st[], int flag){
    st[u] = true;
    for(int i = h[u]; i != -1; i = ne[i]){
        // 当flag == 1 时
        int j = i ^ flag;
        int ver = e[i];
        if(f[j] && !st[ver]){
            dfs(ver, st, flag);
        }
    }
}
signed main(){
    scanf("%lld%lld",&n, &m);
    memset(h, -1, sizeof(h));
    S = 0;
    T = n - 1;
    for(int i = 0; i < m ; i ++){
        int a, b, c;
        scanf("%lld%lld%lld",&a, &b, &c);
        add(a, b, c);
    }
    dinic();
    dfs(S, vis_s, 0);
    dfs(T, vis_t, 1);
    int res = 0;
    for(int i = 0; i < 2 * m; i += 2){
        if(!f[i] && vis_s[e[i ^ 1]] && vis_t[e[i]]){
            res ++;
        }
    }
    printf("%lld", res);
}