P3376 【模板】网络最大流【EK算法+Dinic算法解】

EK算法（O(V*E^2)）

网上很多都讲得挺好的，我是看这一篇的。他的代码简洁(超漂亮的！)，但是优化不够，而且用了map存图。对于这道luogu的模板，不仅MLE还会TLE，但也不是没有参考性。https://www.cnblogs.com/ZJUT-jiangnan/p/3632525.html

需要改动的地方：

1. 链式前向星存图
2. 记录增广路上结点的前驱以及结点与其前驱之前的边的残余容量【这个是为了方便每次找增广路中边的最小残余容量
3. bfs只用来判断源点到汇点是不是还有增广路，不要把残余容量最小值的更新放在bfs里面，会T一个点……找到增广路之后才来找增广路上的最小残余容量，然后才来更新残余网络~

EK算法的核心：

反复寻找源点s到汇点t之间的增广路径，若有，找出增广路径上每一段[容量-流量](残余容量)的最小值，若无，则结束。

• 贴上参考学习笔记。他写的好全……暂时还没看完，日后接着看：https://www.luogu.com.cn/blog/user48036/solution-p3376

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define INF 0x3f3f3f3f

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxN = 10004;
const int maxM = 100005;
inline int read()
{
    int x = 0, f = 1; char c = getchar();
    while(c < '0' || c > '9') { if(c == '-') f = -f; c = getchar(); }
    while(c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}

struct EDGE{
    int adj, to, w;
    EDGE(int a = -1, int b = 0, int c = 0): adj(a), to(b), w(c) {}
}edge[maxM << 1];
int head[maxN], cnt;

void add_edge(int u, int v, int w)
{
    edge[cnt] = EDGE(head[u], v, w);
    head[u] = cnt ++;
}

struct Pre{
    int last, Eid;
}pre[maxN];

bool visited[maxN];

void update_residual_network(int u, int flow)
{
    while(pre[u].last != -1)
    {
        edge[pre[u].Eid].w -= flow;
        edge[pre[u].Eid ^ 1].w += flow;
        u = pre[u].last;
    }
}

bool find_path_bfs(int s, int t) //源点 汇点
{
    memset(visited, false, sizeof(visited));
    memset(pre, -1, sizeof(pre));
    queue<int>q;
    q.push(s); visited[s] = true;
    while(!q.empty())
    {
        int u = q.front(); q.pop();
        for(int i = head[u]; ~i; i = edge[i].adj )
        {
            int v = edge[i].to;
            if(!visited[v] && edge[i].w)
            {
                pre[v] = Pre{u, i};
                if(v == t) return true;
                q.push(v); visited[v] = true;
            }
        }
    }
    return false;
}

int EK_maxFlow(int s, int t)
{
    int max_flow = 0;
    while(find_path_bfs(s, t))
    {
        int new_flow = INF;
        for(int i = t; i != s; i = pre[i].last)
            new_flow = min(new_flow, edge[pre[i].Eid].w);
        update_residual_network(t, new_flow);
        max_flow += new_flow;
    }
    return max_flow;
}

int n, m, s, t;

int main()
{
    memset(head, -1, sizeof(head));
    cnt = 0;

    n = read(); m = read(); s = read(); t = read();
    for(int i = 0; i < m; ++ i )
    {
        int u, v, w;
        u = read(); v = read(); w = read();
        add_edge(u, v, w);
        add_edge(v, u, 0);
    }
    printf("%d\n", EK_maxFlow(s, t));
    return 0;
}

---

Dinic算法（O(V^2*E)）

首先了解层次图

• 层次图，就是把图中的结点按照结点到源点的深度分“层”，只保留不同层之间的边的图。

算法步骤：

1. 对残余网络进行分层【bfs得到】【也用来判断是否还存在增广路！如果汇点t的深度为0(初始化为0的)，说明汇点不可到达
2. 对层次图进行深搜增广
3. 重复上面两步直到不存在增广路

• 相比EK算法，Dinic增加了层次图来优化。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#define INF 0x3f3f3f3f
using namespace std;

inline int read()
{
    int x = 0, f = 1; char c = getchar();
    while(c < '0' || c > '9') { if(c == '-') f = -f; c = getchar(); }
    while(c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}

const int maxN = 10004;
const int maxM = 100005;

int n, m, s, t;

struct EDGE{
    int adj, to, w;
    EDGE(int a = -1, int b = 0, int c = 0): adj(a), to(b), w(c) {}
}edge[maxM << 1];
int head[maxN], cnt;

void add_edge(int u, int v, int w)
{
    edge[cnt] = EDGE(head[u], v, w);
    head[u] = cnt ++ ;
}

int deep[maxN];

bool bfs()
{
    memset(deep, 0, sizeof(deep));
    deep[s] = 1;
    queue<int>q;
    q.push(s);
    while(!q.empty())
    {
        int u = q.front(); q.pop();
        for(int i = head[u]; ~i; i = edge[i].adj)
        {
            int v = edge[i].to;
            if(!deep[v] && edge[i].w)
            {
                deep[v] = deep[u] + 1;
                q.push(v);
            }
        }
    }
    return deep[t];
}

int dfs(int u, int flow)
{
    if(u == t)
        return flow;
    for(int i = head[u]; ~i; i = edge[i].adj)
    {
        int v = edge[i].to;
        if(deep[u] + 1 == deep[v] && edge[i].w)
        {
            if(int newFlow = dfs(v, min(flow, edge[i].w)))
            {
                edge[i].w -= newFlow;
                edge[i ^ 1].w += newFlow;
                return newFlow;
            }
        }
    }
    return 0;
}

int dinic_maxFlow()
{
    int maxFlow = 0;
    while(bfs())
    {
        if(int newFlow = dfs(s, INF))
            maxFlow += newFlow;
    }
    return maxFlow;
}

int main()
{
    memset(head, -1, sizeof(head));

    n = read(); m = read(); s = read(); t = read();
    for(int i = 0; i < m; ++ i )
    {
        int u, v, w;
        u = read(); v = read(); w = read();
        add_edge(u, v, w);
        add_edge(v, u, 0);
    }
    printf("%d\n", dinic_maxFlow());
    return 0;
}