网络流算法笔记

最新推荐文章于 2024-02-01 11:57:58 发布
最新推荐文章于 2024-02-01 11:57:58 发布
阅读量72 收藏
点赞数
原文链接：http://www.cnblogs.com/Roni-i/p/9523110.html
版权

【例题】
1.POJ Drainage Ditches 【最大流EK算法模板】

#include<cstdio>
#include<string>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<cstring>
#include<set>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
#include<cctype>
#include<stack>
#include<sstream>
#include<list>
#include<assert.h>
#include<bitset>
#include<numeric>
#define debug() puts("++++")
#define gcd(a,b) __gcd(a,b)
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define fi first
#define se second
#define pb push_back
#define sqr(x) ((x)*(x))
#define ms(a,b) memset(a,b,sizeof(a))
#define sz size()
#define be begin()
#define pu push_up
#define pd push_down
#define cl clear()
#define lowbit(x) -x&x
#define all 1,n,1
#define mod(x) ((x)%M)
#define pi acos(-1.0)
#define rep(i,x,n) for(int i=(x); i<(n); i++)
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int,int> P;
const int INF = 1<<30;
const int maxn = 1e3;
const double eps = 1e-8;
const int dx[] = {-1,1,0,0,1,1,-1,-1};
const int dy[] = {0,0,1,-1,1,-1,1,-1};
int dir[2]={-1,1};
const int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int monn[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int s,t,n,m;
inline int read()
{
    int x=0;
    char c=getchar();
    while(c>'9'||c<'0')c=getchar();
    while(c>='0'&&c<='9')x=x*10+c-'0',c=getchar();
    return x;
}
int head[maxn],tot=1;
void init()
{
    ms(head,-1);
    tot=1;
}
struct Pre
{
    int v,edge;//该点的前一个点（从起点过来） 与该点相连的边（靠近起点的）
}pre[maxn];
struct node
{
    int v,w,nxt;
}e[maxn];
void add(int u,int v,int w)
{
    e[++tot].v=v;
    e[tot].w=w;
    e[tot].nxt=head[u];
    head[u]=tot;
}
int vis[maxn];
inline bool bfs()
{
    queue<int> q;
    ms(vis,0);ms(pre,-1);
    vis[s]=1; q.push(s);
    while(!q.empty())
    {
        int u=q.front(); q.pop();
        for(int i=head[u]; i!=-1; i=e[i].nxt)
        {
            int v=e[i].v;
            if(!vis[v]&&e[i].w)
            {
                pre[v].v=u;
                pre[v].edge=i;
                if(v==t) return 1;
                vis[v]=1;
                q.push(v);
            }
        }
    }
    return 0;
}
int ek()
{
    int ans=0;
    while(bfs())
    {
        int mi=INF;
        for(int i=t; i!=s; i=pre[i].v)//每次只能增加增广路上最小的边的权值
        {
            mi = min(mi,e[pre[i].edge].w);
        }
        for(int i=t; i!=s; i=pre[i].v)
        {
            e[ pre[i].edge ].w -= mi;
            e[ pre[i].edge^1 ].w += mi;
        }
        ans += mi;
    }
    return ans;
}
int main()
{

    while(~scanf("%d%d",&m,&n))
    {
        init();
        s=1,t=n;
        int u,v,w;
        for(int i=1;i<=m;i++)
            u=read(),v=read(),w=read(),add(u,v,w),add(v,u,0);
        printf("%d\n",ek());
    }
}
/*
【题意】

【类型】最大流EK算法模板

【分析】https://www.luogu.org/blog/ONE-PIECE/wang-lao-liu-di-zong-jie

【时间复杂度&&优化】O(nm^2)(n为点数，m为边数)

【trick】

【数据】

*/

2.洛谷 P3376 【模板】网络最大流

#include<cstdio>
#include<string>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<cstring>
#include<set>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
#include<cctype>
#include<stack>
#include<sstream>
#include<list>
#include<assert.h>
#include<bitset>
#include<numeric>
#define debug() puts("++++")
#define gcd(a,b) __gcd(a,b)
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define fi first
#define se second
#define pb push_back
#define sqr(x) ((x)*(x))
#define ms(a,b) memset(a,b,sizeof(a))
#define sz size()
#define be begin()
#define pu push_up
#define pd push_down
#define cl clear()
#define lowbit(x) -x&x
#define all 1,n,1
#define mod(x) ((x)%M)
#define pi acos(-1.0)
#define rep(i,x,n) for(int i=(x); i<(n); i++)
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int,int> P;
const int INF = 1<<30;
const int maxn = 5e5+10;
const double eps = 1e-8;
const int dx[] = {-1,1,0,0,1,1,-1,-1};
const int dy[] = {0,0,1,-1,1,-1,1,-1};
int dir[2]={-1,1};
const int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int monn[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int s,t,n,m;
inline int read()
{
    int x=0;
    char c=getchar();
    while(c>'9'||c<'0')c=getchar();
    while(c>='0'&&c<='9')x=x*10+c-'0',c=getchar();
    return x;
}
int head[maxn],tot=1;
void init()
{
    ms(head,-1);
    tot=1;
}
struct Pre
{
    int v,edge;//该点的前一个点（从起点过来） 与该点相连的边（靠近起点的）
}pre[maxn];
struct node
{
    int v,w,nxt;
}e[maxn];
void add(int u,int v,int w)
{
    e[++tot].v=v;
    e[tot].w=w;
    e[tot].nxt=head[u];
    head[u]=tot;
}
int inque[maxn];
inline bool bfs()
{
    queue<int> q;
    ms(inque,0);ms(pre,-1);
    inque[s]=1; q.push(s);
    while(!q.empty())
    {
        int u=q.front(); q.pop();
        for(int i=head[u]; i!=-1; i=e[i].nxt)
        {
            int v=e[i].v;
            if(!inque[v]&&e[i].w)
            {
                pre[v].v=u;
                pre[v].edge=i;
                if(v==t) return 1;
                inque[v]=1;
                q.push(v);
            }
        }
    }
    return 0;
}
int ek()
{
    int ans=0;
    while(bfs())
    {
        int mi=INF;
        for(int i=t; i!=s; i=pre[i].v)//每次只能增加增广路上最小的边的权值
        {
            mi = min(mi,e[pre[i].edge].w);
        }
        for(int i=t; i!=s; i=pre[i].v)
        {
            e[ pre[i].edge ].w -= mi;
            e[ pre[i].edge^1 ].w += mi;
        }
        ans += mi;
    }
    return ans;
}
int main()
{
    init();
    n=read(), m=read(), s=read(), t=read();
    int u,v,w;
    for(int i=1;i<=m;i++)
        u=read(),v=read(),w=read(),add(u,v,w),add(v,u,0);
    printf("%d\n",ek());
}
/*
4 5 4 3
4 2 30
4 3 20
2 3 20
2 1 30
1 3 40
【题意】

【类型】

【分析】

【时间复杂度&&优化】

【trick】

【数据】

*/

3.HDU 3549 Flow Problem

#include<cstdio>
#include<string>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<cstring>
#include<set>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
#include<cctype>
#include<stack>
#include<sstream>
#include<list>
#include<assert.h>
#include<bitset>
#include<numeric>
#define debug() puts("++++")
#define gcd(a,b) __gcd(a,b)
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define fi first
#define se second
#define pb push_back
#define sqr(x) ((x)*(x))
#define ms(a,b) memset(a,b,sizeof(a))
#define sz size()
#define be begin()
#define pu push_up
#define pd push_down
#define cl clear()
#define lowbit(x) -x&x
#define all 1,n,1
#define mod(x) ((x)%M)
#define pi acos(-1.0)
#define rep(i,x,n) for(int i=(x); i<(n); i++)
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int,int> P;
const int INF = 1<<30;
const int maxn = 2e3+3;
const double eps = 1e-8;
const int dx[] = {-1,1,0,0,1,1,-1,-1};
const int dy[] = {0,0,1,-1,1,-1,1,-1};
int dir[2]={-1,1};
const int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int monn[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int s,t,n,m;
inline int read()
{
    int x=0;
    char c=getchar();
    while(c>'9'||c<'0')c=getchar();
    while(c>='0'&&c<='9')x=x*10+c-'0',c=getchar();
    return x;
}
int head[maxn],tot=1;
void init()
{
    ms(head,-1);
    tot=1;
}
struct Pre
{
    int v,edge;//该点的前一个点（从起点过来） 与该点相连的边（靠近起点的）
}pre[maxn];
struct node
{
    int v,w,nxt;
}e[maxn];
void add(int u,int v,int w)
{
    e[++tot].v=v;
    e[tot].w=w;
    e[tot].nxt=head[u];
    head[u]=tot;
}
int vis[maxn];
inline bool bfs()
{
    queue<int> q;
    ms(vis,0);ms(pre,-1);
    vis[s]=1; q.push(s);
    while(!q.empty())
    {
        int u=q.front(); q.pop();
        if(u==t) return 1;
        for(int i=head[u]; i!=-1; i=e[i].nxt)
        {
            int v=e[i].v;
            if(!vis[v]&&e[i].w)
            {
                pre[v].v=u;
                pre[v].edge=i;
                vis[v]=1;
                q.push(v);
            }
        }
    }
    return 0;
}
int ek()
{
    int ans=0;
    while(bfs())
    {
        int mi=INF;
        for(int i=t; i!=s; i=pre[i].v)//每次只能增加增广路上最小的边的权值
        {
            mi = min(mi,e[pre[i].edge].w);
        }
        for(int i=t; i!=s; i=pre[i].v)
        {
            e[ pre[i].edge ].w -= mi;
            e[ pre[i].edge^1 ].w += mi;
        }
        ans += mi;
    }
    return ans;
}
int main()
{
    int T,ca=1;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        init();
        s=1,t=n;
        int u,v,w;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
            add(v,u,0);
        }
        printf("Case %d: %d\n",ca++,ek());
    }
}
/*
【题意】

【类型】最大流EK算法模板

【分析】

【时间复杂度&&优化】O(nm^2)(n为点数，m为边数)

【trick】

【数据】

*/

转载于:https://www.cnblogs.com/Roni-i/p/9523110.html

weixin_30853329
关注
网络流算法学习笔记——Dinic有效算法
zhang35的博客
04-27 1153
Dinic有效算法同样用来求最大流，相当于FF算法的改进。 FF算法参考：网络流算法学习笔记——最大流问题基本概念和Ford-Fulkerson方法（标号法C++实现） 改进之处有： FF算法每次只找1条s-t增广链，而Dinic算法每次能找很多条 Dinic算法每次都找最短的（边数最少的）s-t增广链（为啥呢？ ） ...
算法学习笔记：网络流#1——有关内容+算法导航
Plozia 的小窝
03-17 305
算法学习笔记：网络流#1——有关内容+算法导航1. 前言2. 详解3. 算法导航 1. 前言 网络流，属于图论的一种。 网络流看上去是一个新的东西，实际上就是新瓶装旧酒，相信讲完之后你会发现这玩意的一些基础定义什么的跟 有向图 没啥差别。 因为网络流算法有点多，于是本文在讲述基础定义之外同时提供算法导航，将后续的算法学习笔记添加入本博客中。 2. 详解 首先我们需要明白一点：网络流是个啥？ 实际上，网络流就是一张无向图，只不过给图上的东西换了换名字。 比如看看下面这张图。 （绘图工具：Graph Edit
【算法概论】线性规划与规约：网络流
t11383的博客
05-23 1272
最大流和最小割 问题描述： 网络流：一个连通的赋权有向图 G = (V、E、C)，其中 V 是该图的顶点集，E 是有向边(即弧)集，C 是弧上的容量。此外顶点集中包括一个起点和一个终点。网络上的流就是由起点流向终点的可行流，它有两个性质：① 每条边的流量不超过它的容量；② 除 s 和 t 的任意结点，流入 u 的流量等于流出 u 的流量。 最大流问题：找到从 s...
算法学习笔记 网络流之最大流算法
memcpy0的博客
04-23 2051
文章目录26.1 流网络1. 流网络和流2. 流的一个例子3. 使用反平行边来建模问题4. 具有多个源点和多个汇点的网络26.2 *Ford-Fulkerson* 方法1. 残存网络2. 增广路径3. 基本的 *Ford-Fulkerson* 算法 我们可通过模型化道路交通图为一个有向图、找到从一个城市到另一个城市之间的最短路径，我们也可以将一个有向图看作是一个流网络 flow network 、并使用它来回答关于物料流动方面的问题。设想一种物料从产生它的源结点、经过一个系统、流向消耗该物料的汇点这样一个过
计算机网络笔记Part1 概述
热门推荐
weixin_45067603的博客
06-26 17万+
概述 1.速率相关性能指标 速率 定义：连接在计算机网络上的主机在数字信道上传送数据位数的速率 单位:b/s,Kb/s,Mb/s,Tb/s， 如果用字节表示，则是B/s,KB/s,MB/s,TB/s 1Byte=8Bit 带宽 在计算机网络中，指的是网络设备所支持的最高速度，单位同速率，是理想条件下最高速率 吞吐量 指的是单位时间内通过某个网络的数据总量 个人理解 速率就是实际网速，带宽是理论网速（长城宽带警告），吞吐量是一个或多个设备的综合速率，比如说1000m宽带的路由器连着三部手机，每部手机都是10m
【图论】网络流
Texcavator的博客
02-01 2922
网络流目前只整理模板，学习的话这篇博客可能不太适合下文建图方式都基于链式前向星，请注意，cnt。
《计算机网络》复习笔记
hushhw的博客
01-05 14万+
《计算机网络》复习笔记 本复习笔记基于谢希仁的《计算机网络》第五版教材整理。 计算机网络复习笔记 绪论 1 计算机网络 2 因特网概述 3 互联网的组成 P8 4 计算机网络的类别 P17 5 计算机网络的体系结构 P25 物理层 1 物理层下的传输媒体 2 关于信道的几个基本概念 3 信道复用技术 数据链路层 1 使用点对点信道的数据链路层 2点对点协议 PPP P70 3...
计算机网络（超级详细笔记）
qq_64681137的博客
05-25 8382
计算机网络超级详细笔记（第8版）谢希仁
[算法导论·ISAP]网络流学习笔记
TA
02-08 1696
先来学算导。。 26.1流网络 ①与第二版不同，算导第三版修改了关于流的约定，约定所有流均非负；并删除了流的第二条性质（反向对称）。同时放弃了给源点以定义，允许源点入度不为0，相应的，也允许汇点出度不为0. ②一些奇怪的性质包括：流守恒，所有点必在s~>t上，两点之间最多只有一条边。 ③在网络流中遇到了大量加边加点的技巧：多个源汇点的话可以添加一个超级源汇点；为反向平行边添加虚拟节点，将一
算法笔记.胡凡(详细书签)
04-22
《算法笔记.胡凡(详细书签)》是一本深入探讨算法知识的书籍，由作者胡凡精心编著。这本书以其详尽的书签系统为读者提供了方便的导航，使得学习算法的过程更加高效。标签“算法笔记”清晰地表明了本书的核心内容，即...
算法笔记上机训练指南
02-28
4. 图论算法：图论是算法中的一个重要分支，涉及图的遍历算法（如深度优先搜索DFS和广度优先搜索BFS）、最短路径算法（如Dijkstra算法和Floyd算法）以及网络流算法等。 5. 动态规划与贪心策略：这两种算法策略在...
算法笔记1
08-03
本文主要讨论的是算法相关的知识，...以上内容涵盖了算法分析和设计的核心概念，从基础的循环不变量到复杂的图算法和网络流问题，展示了算法在解决问题中的广泛应用。理解和掌握这些知识点对于提升编程能力至关重要。
算法笔记·上机训练实战指南
04-07
《算法笔记·上机训练实战指南》是一本专注于C语言编程和算法实践的教程，特别适合准备考研机试、PAT(编程能力测试)以及CTF(网络安全竞赛)的读者。这本书由胡凡编著，提供了丰富的算法实例和实战训练，旨在帮助读者...
【算法笔记】总结 - 网络流 Edmonds-Karp 算法和 dinic 算法
slowlight93的专栏
07-22 1670
边的表示1) 如果要把边单独存在一个buffer里面，并且每条边有一个唯一的编号。 那么通常将正反边存在一起，比如0，1，这样就可以用 id^1 来方便地访问反边了。 2） 也可以对每个节点，存一个 vector<Edge> 其中 rev 是在 to 节点的邻边列表中的编号。 可以只用 cap 记录剩余容量，这样就省掉 flow 了。struct Edge { int to, c
VB程序实例-图像的打印.zip
11-03
VB程序实例-图像的打印.zip
VB程序实例-字形窗口.zip
最新发布
11-03
VB程序实例-字形窗口.zip
VB程序实例36_动态控制_增减控件.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
技术资料分享CC2530非常好的技术资料.zip
11-03
技术资料分享CC2530非常好的技术资料.zip
图神经网络学习笔记：社区结构探究与Louvain算法
"cs224w 图神经网络 学习笔记（五）Community Structure in Networks1" 在图神经网络的研究中，社区结构（Community Structure）是网络分析的一个重要概念，尤其是在社交网络、信息网络等领域。社区结构指的是网络...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值