网络流-最大流问题

ゞ浴缸里的玫瑰 2022-05-28 08:17 175阅读 0赞

上一篇博客介绍了Ford-Fulkerson算法[点击打开链接][Link 1]

之前介绍的Ford-Fulkerson算法时间复杂度为O(F\*E)，在一般情况下是可以接受的，但是一旦点,边都变的多的时候就不行了，接下来的Dinic算法也比较简单，在Ford-Fulkerson算法基础上改进的。

Ford-Fulkerson算法是通过dfs来寻找增广路的，并沿着它增广。而Dinic算法是寻找最短的增广路的，并沿着增广，长度在增广途中是不会变短的（注意这里的距离并不是边上的权值（那是最大流量），而是简单的边的条数（可以看成边长为1））。

我们首先通过bfs处理图，把点按照与源点的距离划分（形成分层图）,在上面进行dfs寻找最短增广路，，如果找不到了，那么证明最短增长路变长了，或者不存在了。

每一步构造分层图的复杂度为O(E),而每一步完成后最短增长路至少+1，但是不会超过|v|-1,因此最多重复|V|次

算法复杂度O(E\*V\*V)

[HDU 3549][]

耗时是Ford-Fulkerson算法的一半

代码如下:

#include<bits/stdc++.h>
    using namespace std;
    
    const int inf=0x3f3f3f3f;
    const int maxn=20;
    struct ege//终点，最大流量，确定反向边的位置
    {
        int to,cap,rev;
    };
    vector<ege> G[maxn];
    int level[maxn];
    int n,m;
    
    
    void bfs(int s)
    {
        level[s]=0;
        queue<int>que;
        que.push(s);
        while (que.size()) {
            int cur=que.front();
            que.pop();
            for (int i=0;i<G[cur].size();i++) {
                ege& e=G[cur][i];
                if (e.cap>0&&level[e.to]==-1) {
                    level[e.to]=level[cur]+1;
                    que.push(e.to);
                }
            }
        }
    }
    
    int dfs(int S,int E,int f)
    {
        if (S==E) return f;
        for (int i=0;i<G[S].size();i++) {
            ege& e=G[S][i];
            if (level[e.to]>level[S]&&e.cap>0) {
                int d=dfs(e.to,E,min(f,e.cap));
                if (d>0) {
                    e.cap-=d;
                    G[e.to][e.rev].cap+=d;//反向边来加流量，保证可以反悔
                    return d;
                }
            }
        }
        return 0;
    }
    int max_flow(int s,int e)
    {
        int flow=0;
        while (true) {
            memset(level,-1,sizeof (level));
            bfs(s);
            if (level[e]<0) return flow;//已经到不了了
            int f;
            while ((f=dfs(s,e,inf))>0) flow+=f;//一直在当前分层图上面找
        }
        return 0;
    }
    int main()
    {
        int t;
        scanf("%d",&t);
        for (int icase=1;icase<=t;icase++) {
            scanf("%d%d",&n,&m);
            for (int i=1;i<=n;i++) G[i].clear();
            for (int i=1;i<=m;i++) {
                int s,e, val;
                scanf("%d%d%d",&s,&e,&val);
                G[s].push_back(ege{e,val,G[e].size()});
                G[e].push_back(ege{s,0,G[s].size()-1});
            }
            printf("Case %d: %d\n",icase,max_flow(1,n));
        }
        return 0;
    }

[Link 1]: https://blog.csdn.net/wust_cyl/article/details/79783287
[HDU 3549]: http://acm.hdu.edu.cn/showproblem.php?pid=3549