网络流

概念

参考博客

可视化

最大流

EK 算法

理论上限复杂度 \(O(nm^{2})\)

const int N = 205;
const int M = 5005;


struct Edge{
    ll v, c; // v 代表有向边指向的点
    int ne; // ne 代表邻接表中下一条边的编号
}e[M<<1];
int head[N], idx=1; // 边从(2,3)开始编号
ll minf[N]; // minf[u]：当前增广路到达 u 经过的实际流量（取前面经过所有边剩余容量的最小值）
int pre[N]; // pre[u]：在增广路中 u 的回溯边编号，用于构建残量网络
int n, m, S, T;

void addedge(int u, int v, int c){ // (u, v) 间添加容量为 c 的有向边
    e[++idx] = {v, c, head[u]};
    head[u] = idx;
}
bool bfs(){ // 返回值表示是否找到一条增广路
    memset(minf, 0, sizeof minf);
    queue<int> q;
    q.push(S);
    minf[S] = INF;
    while(q.size()){
        int u = q.front();
        q.pop();
        for(int i = head[u]; i; i = e[i].ne){
            int v = e[i].v;
            if(minf[v] == 0 && e[i].c > 0){ // 当前未访问过，且剩余容量 > 0
                minf[v] = min(minf[u], e[i].c);
                pre[v] = i;
                q.push(v);
                if(v == T) return true;
            }
        }
    }
    return false;
}

ll EK(){
    ll flow = 0;
    while(bfs()){ // 不断地 
        int v = T;
        while(v != S){
            int i = pre[v];
            e[i].c -= minf[T];
            e[i^1].c += minf[T];
            v = e[i^1].v;
        }
        flow += minf[T];
    }
    return flow;
}

void solve()
{
    cin >> n >> m >> S >> T;
    for(int i = 1; i <= m; i ++){
        int u, v, c;
        cin >> u >> v >> c;
        addedge(u, v, c);
        addedge(v, u, 0);
    }
    cout << EK() << "\n";
}

Dinic 算法

struct Edge{
    ll v, c; // v 代表有向边指向的点
    int ne; // ne 代表邻接表中下一条边的编号
}e[M<<1];
int head[N], idx=1; // 边从(2,3)开始编号
int d[N], cur[N];
int S, T;

void addedge(int u, int v, int c){ // (u, v) 间添加容量为 c 的有向边
    e[++idx] = {v, c, head[u]};
    head[u] = idx;
}
bool bfs(){ // 对所有点分层，找增广路
    memset(d, 0, sizeof d);
    queue<int> q;
    q.push(S);
    d[S] = 1;
    while(q.size()){
        int u = q.front();
        q.pop();
        for(int i = head[u]; i; i = e[i].ne){
            int v = e[i].v;
            if(d[v] == 0 && e[i].c > 0){ // 当前未访问过，且剩余容量 > 0
                d[v] = d[u] + 1;
                q.push(v);
                if(v == T) return true;
            }
        }
    }
    return false;
}

ll dfs(int u, ll minf){ // 多路增广
    if(u == T) return minf;
    ll sum = 0;
    for(int i = cur[u]; i; i = e[i].ne){
        cur[u] = i; // 当前弧优化
        int v = e[i].v;
        if(d[v] == d[u] + 1 && e[i].c > 0){
            ll f = dfs(v, min(minf, e[i].c));
            e[i].c -= f;
            e[i^1].c += f;
            sum += f;
            minf -= f;
            if(minf == 0) break; // 剩余流量优化
        }
    }
    if(sum == 0) d[u] = 0; // 残枝优化
    return sum;
}

ll dinic(){
    ll flow = 0;
    while(bfs()){
        memcpy(cur, head, sizeof head);
        flow += dfs(S, INF);
    }
    return flow;
}

void solve()
{
    cin >> n >> m >> S >> T;
    for(int i = 1; i <= m; i ++){
        int u, v, c;
        cin >> u >> v >> c;
        addedge(u, v, c);
        addedge(v, u, 0); // ！别忘了加反向边
    }
    cout << dinic() << "\n";
}

最小割

// 执行 dinic 算法后调用
bool vis[N];
void mincut(int u){ // 最终根据 vis 值将点集划分成两类，即最小割
    vis[u] = 1;
    for(int i = head[u]; i; i = e[i].ne){
        int v = e[i].v;
        if(!vis[v] && e[i].c > 0) mincut(v);
    }
}

费用流

const int N = 5005;
const int M = 50005;

struct Edge{
    int v;
    int c; // 单位容量
    int w; // 单位流量费用
    int ne;
}e[M<<1];
int head[N], idx=1;
int d[N]; // 记录 spfa 最短路
int minf[N];
int pre[N];
bool st[N]; // spfa 标记数组
int flow, cost;

int n, m, S, T;

void addedge(int u, int v, int c, int w){
    e[++idx] = {v, c, w, head[u]};
    head[u] = idx;
}

bool spfa(){ // 每次从源点出发，找到达汇点 T 单位费用最小的增广路
    memset(d, 0x3f, sizeof d);
    memset(minf, 0, sizeof minf);
    queue<int> q;
    q.push(S);
    d[S] = 0;
    minf[S] = inf;
    st[S] = true;
    while(q.size()){
        int u = q.front();
        q.pop();
        st[u] = false;
        for(int i = head[u]; i; i = e[i].ne){
            int v = e[i].v, w = e[i].w;
            if(d[v] > d[u] + w && e[i].c > 0){
                d[v] = d[u] + w;
                minf[v] = min(minf[u], e[i].c);
                pre[v] = i;
                if(!st[v]){
                    st[v] = true;
                    q.push(v);
                }
            }
        }
    }
    return minf[T] > 0;
}
void EK(){
    while(spfa()){
        int v = T;
        while(v != S){
            int i = pre[v];
            e[i].c -= minf[T];
            e[i^1].c += minf[T];
            v = e[i^1].v;
        }
        flow += minf[T];
        cost += minf[T] * d[T];
    }
}