【HDOJ 1532】 Drainage Ditches(最大流模板)

最新推荐文章于 2019-03-02 18:29:34 发布
最新推荐文章于 2019-03-02 18:29:34 发布
阅读量1.8k 收藏 3
点赞数 1
分类专栏： 模板 ------------各种OJ------------ HDOJ --------------图--------------- -----------杂七杂八------------ 网络流 ACM道路之图论 文章标签： 最大流 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChallengerRumble/article/details/47261087
版权

【HDOJ 1532】 Drainage Ditches(最大流模板)

最大流模板题 邻接矩阵建图的话注意重边就好 那来存最大流模板吧

顺记几篇好文:http://blog.sina.com.cn/s/blog_92fcae85010135mm.html
http://blog.csdn.net/u010787640/article/details/12218719
http://www.cnblogs.com/wally/archive/2013/05/03/3054778.html
http://www.cnblogs.com/georgechen-ena/archive/2011/11/07/2240185.html
http://www.cnblogs.com/wally/p/3274438.html
http://www.cnblogs.com/longdouhzt/archive/2012/05/20/2510753.html

朴素dfs:

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <vector>
#define INF 0x3f3f3f3f

using namespace std;

typedef struct Edge
{
    int t,cap,rev;
}Edge;

vector <Edge> head[233];
bool vis[233];
int n;

void Add(int fm,int to,int cap)
{
    head[fm].push_back(Edge {to,cap,head[to].size()});
    head[to].push_back(Edge {fm,0,head[fm].size()-1});
}

int dfs(int s,int t,int f)
{
    int i;
    if(s == t)
        return f;
    vis[s] = true;
    for(i = 0; i < head[s].size(); ++i)
    {
        Edge &tmp = head[s][i];
        if(!vis[tmp.t] && tmp.cap > 0)
        {
            int d = dfs(tmp.t,t,min(f,tmp.cap));
            if(d > 0)
            {
                tmp.cap -= d;
                head[tmp.t][tmp.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow()
{
    int f,flow = 0;
    while(1)
    {
        memset(vis,0,sizeof(vis));
        f = dfs(1,n,INF);
        if(f) flow += f;
        else return flow;
    }
}

int main()
{
    int m,u,v,w;
    while(~scanf("%d %d",&m,&n))
    {
        memset(head,0,sizeof(head));
        while(m--)
        {
            scanf("%d %d %d",&u,&v,&w);
            Add(u,v,w);
        }
        printf("%d\n",max_flow());
    }
    return 0;
}

朴素bfs:

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
#define INF 0x3f3f3f3f

using namespace std;

int mp[233][233];
int flow[233],pre[233];
int n;

int bfs()
{
    queue <int> q;
    memset(pre,-1,sizeof(pre));
    q.push(1);
    flow[1] = INF;
    pre[1] = 0;
    int u,v,i;
    while(!q.empty())
    {
        u = q.front();
        q.pop();
        if(u == n) return flow[u];
        for(i = 1; i <= n; ++i)
        {
            if(pre[i] == -1 && mp[u][i] > 0)
            {
                flow[i] = min(mp[u][i],flow[u]);
                pre[i] = u;
                q.push(i);
            }
        }
    }
    if(pre[n] = -1) return 0;
    return flow[n];
}

int max_flow()
{
    int f,sumflow = 0;
    while((f = bfs()) != 0)
    {
        int k = n;
        while(k != 1)
        {
            int last = pre[k];
            mp[last][k] -= f;
            mp[k][last] += f;
            k = last;
        }
        sumflow += f;
    }
    return sumflow;
}

int main()
{
    int m,u,v,w;
    while(~scanf("%d %d",&m,&n))
    {
        memset(mp,0,sizeof(mp));
        while(m--)
        {
            scanf("%d %d %d",&u,&v,&w);
            if(u == v) continue;
            mp[u][v] += w;
        }
        printf("%d\n",max_flow());
    }
    return 0;
}

朴素 dinic:

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#define INF 0x3f3f3f3f

using namespace std;

typedef struct Edge
{
    int to,cap,rev;
}Edge;

int dis[233];
vector <Edge> head[233];
int n,m;

void Add(int u,int v,int w)
{
    head[u].push_back(Edge{v,w,head[v].size()});
    head[v].push_back(Edge{u,0,head[u].size()-1});
}

bool bfs()
{
    memset(dis,-1,sizeof(dis));
    queue <int> q;
    q.push(1);
    dis[1] = 0;
    int u,v,w,i;
    while(!q.empty())
    {
        u = q.front();
        q.pop();
        for(i = 0; i < head[u].size(); ++i)
        {
            v = head[u][i].to;
            if(head[u][i].cap >0 && dis[v] == -1)
            {
                dis[v] = dis[u]+1;
                q.push(v);
            }
        }
    }
    return (dis[n] != -1);
}

int Maxflow(int u,int flow)
{
    if(u == n) return flow;
    int i,v,w,id,x;
    for(i = 0; i < head[u].size(); ++i)
    {
        v = head[u][i].to;
        w = head[u][i].cap;
        id = head[u][i].rev;
        if(dis[v] == dis[u]+1 && (x = Maxflow(v,min(flow,w))))
        {
            head[u][i].cap -= x;
            head[v][id].cap += x;
            return x;
        }
    }
    return 0;
}

int main()
{
    int u,v,w,flow,sumflow;
    while(~scanf("%d %d",&m,&n))
    {
        memset(head,0,sizeof(head));
        while(m--)
        {
            scanf("%d %d %d",&u,&v,&w);
            Add(u,v,w);
        }
        sumflow = 0;
        while(bfs())
        {
            while(flow = Maxflow(1,INF)) sumflow += flow;
        }
        printf("%d\n",sumflow);
    }
    return 0;
}

dinic+当前弧优化:

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#define INF 0x3f3f3f3f

using namespace std;

int dis[233],dq[233],mp[233][233];
int n,m;

bool bfs()
{
    memset(dis,-1,sizeof(dis));
    queue <int> q;
    q.push(1);
    dis[1] = 0;
    int u,v,w,i;
    while(!q.empty())
    {
        u = q.front();
        q.pop();
        for(i = 1; i <= n; ++i)
        {
            if(mp[u][i] > 0 && dis[i] == -1)
            {
                dis[i] = dis[u]+1;
                q.push(i);
            }
        }
    }
    return (dis[n] != -1);
}

int Maxflow(int u,int flow)
{
    if(u == n) return flow;
    int i,x;
    for(i = dq[u];i < n; ++i)
    {
        dq[u] = i;
        if(dis[i+1] == dis[u]+1 && mp[u][i+1] && (x = Maxflow(i+1,min(flow,mp[u][i+1]))))
        {
            mp[u][i+1] -= x;
            mp[i+1][u] += x;
            return x;
        }
    }
    return 0;
}

int main()
{
    int u,v,w,flow,sumflow;
    while(~scanf("%d %d",&m,&n))
    {
        memset(mp,0,sizeof(mp));
        while(m--)
        {
            scanf("%d %d %d",&u,&v,&w);
            mp[u][v] += w;
        }
        sumflow = 0;
        while(bfs())
        {
            memset(dq,0,sizeof(dq));
            while(flow = Maxflow(1,INF)) sumflow += flow;
        }
        printf("%d\n",sumflow);
    }
    return 0;
}

dinic多路增广

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#define INF 0x3f3f3f3f

using namespace std;

int dis[233],mp[233][233];
int n,m;

bool bfs()
{
    memset(dis,-1,sizeof(dis));
    queue <int> q;
    q.push(1);
    dis[1] = 0;
    int u,v,w,i;
    while(!q.empty())
    {
        u = q.front();
        q.pop();
        for(i = 1; i <= n; ++i)
        {
            if(mp[u][i] > 0 && dis[i] == -1)
            {
                dis[i] = dis[u]+1;
                q.push(i);
            }
        }
    }
    return (dis[n] != -1);
}

int Maxflow(int u,int flow)
{
    if(u == n) return flow;
    int i,x,sum;
    for(i = 1; sum < flow && i <= n; ++i)
    {
        if(dis[i] == dis[u]+1 && mp[u][i] && (x = Maxflow(i,min(flow-sum,mp[u][i]))))
        {
            mp[u][i] -= x;
            mp[i][u] += x;
            sum += x;
        }
    }
    if(!sum) dis[i] = -2;
    return sum;
}

int main()
{
    int u,v,w,flow,sumflow;
    while(~scanf("%d %d",&m,&n))
    {
        memset(mp,0,sizeof(mp));
        while(m--)
        {
            scanf("%d %d %d",&u,&v,&w);
            mp[u][v] += w;
        }
        sumflow = 0;
        while(bfs())
        {
            sumflow += Maxflow(1,INF);
        }
        printf("%d\n",sumflow);
    }
    return 0;
}

邻接矩阵sap+gap+当前弧优化

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#define INF 0x3f3f3f3f

using namespace std;

int mp[233][233],gap[233],level[233],pre[233],cur[233];
int n,m;

int sap()
{
    memset(gap,0,sizeof(gap));//层次找断点
    memset(level,0,sizeof(level));//高度
    memset(cur,0,sizeof(cur));//当前弧
    int u,v,sumflow = 0,flow = INF,f;
    gap[0] = n;
    u = pre[1] = 1;

    while(level[1] < n)
    {
        for(v = cur[u]; v <= n; ++v)//找当前点的前一级
        {
            cur[u] = v;
            if(mp[u][v] && level[u] == level[v] +1) break;
        }
        if(v <= n)
        {
            flow = min(flow,mp[u][v]);
            pre[v] = u;
            u = v;
            if(v == n)
            {
                sumflow += flow;
                for(u = pre[v]; v != 1; v = u, u = pre[u])
                {
                    mp[u][v] -= flow;
                    mp[v][u] += flow;
                }
                flow = INF;
            }
        }
        else
        {
            f = n;
            for(v = 1; v <= n; ++v)//找离当前点最近的点
            {
                if(mp[u][v] && f > level[v])
                {
                    cur[u] = v;
                    f = level[v];
                }
            }
            if(!(--gap[level[u]])) break;//断点跳出
            level[u] = f+1;
            gap[level[u]]++;
            u = pre[u];
        }
    }
    return sumflow;
}

int main()
{
    int u,v,w;
    while(~scanf("%d %d",&m,&n))
    {
        memset(mp,0,sizeof(mp));
        while(m--)
        {
            scanf("%d %d %d",&u,&v,&w);
            mp[u][v] += w;
        }
        printf("%d\n",sap());
    }
    return 0;
}

邻接表sap+gap+当前弧优化

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#define INF 0x3f3f3f3f

using namespace std;

typedef struct Edge
{
    int to,cap,next;
}Edge;

Edge eg[233];
int head[444],level[233],gap[233],cur[233],pre[233];
int n,m,tp;

void Add(int u,int v,int w)
{
    eg[tp].to = v;
    eg[tp].cap = w;
    eg[tp].next = head[u];
    head[u] = tp++;
}

int sap()
{
    memset(gap,0,sizeof(gap));
    memset(level,0,sizeof(level));
    int u,v,sumflow = 0,flow = INF,f;
    gap[0] = n;
    u = pre[1] = 1;

    while(level[1] < n)
    {
        for(int &i = cur[u]; i != -1; i = eg[i].next)
        {
            v = eg[i].to;
            if(eg[i].cap && level[u] == level[v] + 1) break;
        }

        if(cur[u] != -1)
        {
            v = cur[u];
            flow = min(flow,eg[v].cap);
            pre[eg[v].to] = u;
            u = eg[v].to;
            if(u == n)
            {
                sumflow += flow;
                v = eg[v].to;
                for(; u != 1;u = pre[u])
                {
                    eg[cur[pre[u]]].cap -= flow;
                    eg[cur[pre[u]]^1].cap += flow;
                }
                flow = INF;
            }
        }
        else
        {
            f = n;
            for(int i = head[u]; i != -1; i = eg[i].next)
            {
                if(eg[i].cap && f > level[eg[i].to])
                {
                    cur[u] = i;
                    f = level[eg[i].to];
                }
            }
            if(!(--gap[level[u]])) break;
            level[u] = f + 1;
            gap[level[u]]++;
            u = pre[u];
        }
    }
    return sumflow;
}


int main()
{
    int u,v,w;
    while(~scanf("%d %d",&m,&n))
    {
        memset(head,-1,sizeof(head));
        tp = 0;
        while(m--)
        {
            scanf("%d %d %d",&u,&v,&w);
            Add(u,v,w);
            Add(v,u,0);
        }
        printf("%d\n",sap());
    }
    return 0;
}
小胡子Haso
关注
专栏目录
HDOJ1224 floyed裸题 + 模板程序
勇敢前进的ACMer
08-19 318
Free DIY TourTime Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 7142 Accepted Submission(s): 2341Problem Description Weiwei is a software engi
hdoj 1569 方格取数 【最大点权独立集->最大流】
大神养成中.....
08-24 1774
题目：hdoj 1569 方格取数 题意：中文题目，就不说题意了。 分类：最大流 |  dp 分析：dp的话应该是个数塔模型，不难做，这里讲转化为图的做法。 这个题目的关键在于转化为一个二分图，来求一个二分图的最大点权独立集，而最大点权独立集 = 点权和 - 最小点权覆盖 最小点权覆盖： 从x或者y集合中选取一些点，使这些点覆盖所有的边，并且选出来的点的权值尽可能
hdoj 1532 Drainage Ditches
lizhb5的博客
05-04 312
题目：Every time it rains on Farmer John's fields, a pond forms over Bessie's favorite clover patch. This means that the clover is covered by water for awhile and takes quite a long time to regrow. Thus,
hdoj 1532 Drainage Ditches 题解（最大流）
大神养成中.....
03-27 7030
Drainage Ditches Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 7845    Accepted Submission(s): 3659 Problem Description Every tim
最大网络流dinic算法—【hdoj1532】Drainage Ditches
struct_liao的博客
07-14 279
题目hdoj1532传送门 落谷传送门 题意：给出n个河流，m个点，以及每个河流的流量，求从1到m点的最大流量。 Sample Input： 5 4 1 2 40 1 4 20 2 4 20 2 3 30 3 4 10Sample Output： 50dinic算法每次都先bfs一遍，处理出一个层次图，然后dfs就可以多次用到这个图，相比EK每次都建一个图要快。并且层次图是最短路
HDOJ 1532 网络流(FF + EK + Dinic)
TheWaySoFar
04-19 350
题意:由于下大雨的时候约翰的农场就会被雨水给淹没，无奈下约翰不得不修建水沟，而且是网络水沟，并且聪明的约翰还控制了水的流速，本题就是让你求出最大流速 思路:套用网络流模板,这篇博文写的质量肯定不好,因为对于这种纯知识点的网络流题目,发表博文更应该注重的是知识点的讲解.这里只是把代码贴上而已. FF代码:#include #include #include #include #inclu
HDOJ 1532 Drainage Ditches 初探网络流之最大流（入门）
siberiaHLY的博客
03-02 289
HDOJ 1532 Drainage Ditches 网络流对于刚入门算法学习的同学来说是稍有困难的（比如我），于是我打算从一道最基本的最大流例题让自己好好的学习一下网络流。这一篇文章是完完全全的新手入门文章，对于有些许基础的人可能不会有什么帮助，而对于小白来说，可能是叩开网络流的一个起点吧 题目大意 给出n与m，n为有向边数，m为顶点数，求s到t的最大流。 什么是最大流呢？不妨先来看一下题目的i...
hdoj.rar_Dividing HDOJ_OJ 1082_hdoj 10_杭电oj_杭电oj1000
09-24
【标题】"hdoj.rar_Dividing HDOJ_OJ 1082_hdoj 10_杭电oj_杭电oj1000" 涉及的知识点主要围绕着“杭电在线判题系统（HDOJ）”以及其中的题目1082和10系列题目。HDOJ是杭州电子科技大学主办的一个在线编程竞赛平台，...
HDOJ.rar_HD_HDOJ
09-22
【标题】"HDOJ.rar_HD_HDOJ" 是一个与HDU（杭州电子科技大学）在线判题系统HDOJ相关的压缩包文件，其中包含了大量编程题目的源代码。 【描述】提到，这个压缩包包含了几百道HDOJ题目的源代码，这意味着它是一个宝贵...
OJ.tar.gz_HDOJ _OJ源码_oj
09-19
【OJ.tar.gz_HDOJ _OJ源码_oj】是一个包含编程竞赛平台HDOJ（Happy Ding Octopus Judge）部分源代码的压缩文件。这个压缩包的主要目的是供学习和研究使用，尤其是针对50至60题目的解题算法和系统实现。通过分析这些...
最大流-hdoj-1532
yichudu
04-08 1411
大意：为防止三叶草被淹，挖沟散水。求最大流。以示例输入进行说明。5为边数，4为顶点数。顶点编号从1开始。1为源点，4为汇点。 接下来的5行，Si Ei Ci:水从Si流向Ei，最大流量为Ci。
最大流(Dinic模版)——HDOJ 1532
Kay's space
03-05 1135
HDOJ 1532 Drainage Ditches 这道题目是用来做Dinic算法的模版题目，而上一篇博客 最大流——HDOJ 3549 是用来作为EK算法的模版题目。 关于Dinic算法的讲解，网上有很多，我这里也不多讲什么。推荐一篇讲得比较容易懂的 http://comzyh.tk/blog/archives/568/#Dinic-Code /* HDOJ 1532 最大流经典入门题目
hdoj 1532 Drainage Ditches 题解（网络流 >最大流详解）
qq_41668093的博客
09-13 177
Drainage Ditches Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 22614    Accepted Submission(s): 10830   Problem Description Every time it ...
HDOJ 1532 Drainage Ditches
luminous11的专栏
04-04 478
题意：有一个n个点和m条边的网络，每条边都有流量上限，求从点1到点n的最大流量 链接：http://acm.hdu.edu.cn/showproblem.php?pid=1532 思路：网络流dinic模板 注意点：无 以下为AC代码： Run ID Submit Time Judge Status Pro.ID Exe.Time Exe.Memory
hdoj--1532 Drainage Ditches(网络流/最大流)
许少y
05-27 430
hdoj 1532题解#include <iostream> #include <cstdio> #include <algorithm> #include <queue> #include <vector> #include <cstring> using namespace std;const int maxn = 200 + 10; const int inf = 0x7fffffff;st
hdoj-1532-edmondsKarp最大流算法模板
acblacktea的博客
01-14 753
#include<cstdio> #include<queue> #include<cstring> using namespace std; int m,n,mp[205][205],a,b,c,path[205],flow[205]; int bfs() { queue<int>qu; qu.push(1); memset(path,-1,sizeof(path));
HDU1532(最大流EK算法模板题)
creatorx的博客
05-22 1418
Drainage DitchesTime Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 17484 Accepted Submission(s): 8238Problem Description Every time it rains o
HDOJ1532 最大流 BFS + EK 算法 模板
勇敢前进的ACMer
08-19 228
Drainage Ditches Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 18788    Accepted Submission(s): 8935 Problem Description Every ti
【POJ 3592】 Instantaneous Transference（强连通缩点+最长路）
ACMer'
02-18 4748
【POJ 3592】 Instantaneous Transference（强连通缩点+最长路） Instantaneous Transference Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 6265   Accepted: 1411 Descrip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值