网络流
作者：互联网
网络流
前言
该 \(blog\) 无基本概念,配合网络流基本介绍共同食用为佳,也无复杂度及其证明,毕竟网络流是基本跑不到复杂度上限的
最大流
一种常见的网络流模型,
通常是求源点到汇点的最大流量,
在算法竞赛中通常使用 \(dinic\) 算法或者 \(ISAP\) 算法.
\(dinic\)
\(dinic\) 算法是基于 \(EK\) 算法的,
这里不多赘述(毕竟 \(EK\) 还是比较简单的而且又不用bushi).
(其实会在下面费用流的时候介绍)
我们每次从 \(s\) (源点)开始 \(BFS\) 寻找增广路(学过二分图最大匹配的童鞋应该都知道),
如果到了 \(t\) (汇点)就结束,
也就是说我们的 \(s\) 和 \(t\) 是连通的,
也就是存在增广路,
完了?
完了.WTF?
这就是 \(dinic\) 算法的基础——增广路算法(也就是 \(EK\) ).
我们可以发现这样每次只能增广一条路,
所以会很慢.
而 \(dinic\) 算法则是多路增广,
我们每次跑一遍 \(BFS\) 来构建一个叫做"分层图"的东西,
这里我们定义一个数组 \(d\)
\(d_i\) 代表到 \(i\) 节点的最短距离,
如果有一条边连接了节点 \(x\) 和节点 \(y\) ,
并且 \(d_x + 1 == d_y\) ,
这是不是意味着我们在 \(BFS\) 的时候是从 \(x\) 走到的 \(y\) ?
也就是说这条边(指连接 \(x\) 和 \(y\) 的这条边)可能存在于某一条增广路,
基于分层图的概念,
我们可以对上面的增广路算法进行一波优化,
于是乎便有了下面的代码⬇️(按照代码运行顺序阅读为佳哟)
#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn = 1205, maxm = 120005, inf = 1 << 30;
int n, m, s, t, d[maxn], now[maxm];
//d数组上面提到了,now数组为当前弧优化
int tot = 1, to[maxm << 1], head[maxn], nxt[maxm << 1], cap[maxm << 1];
//链式前向星存图(好用)
ll maxflow;//不开ll见祖宗
queue <int> q;
void add(int u, int v, int w){
to[++tot] = v, cap[tot] = w, nxt[tot] = head[u], head[u] = tot;
}
bool BFS(){//BFS寻找增广路
memset(d, 0, sizeof(d));
while (q.size()) q.pop();
q.push(s); d[s] = 1; now[s] = head[s];
while (q.size()){
int x = q.front(); q.pop();
for (int i = head[x]; i; i = nxt[i]){
int y = to[i];
if (!d[y] && cap[i]){
q.push(y);
d[y] = d[x] + 1;
now[y] = head[y];//初始化当前弧
if (y == t) return true;
}
}
}
return false;
}
int dinic(int x, int flow){
if (x == t || flow == 0) return flow;//到汇点或者流量无了
int rest = flow, k;//rest为当前的可行流
for (int i = now[x]; i && rest; i = nxt[i]){
//这里千万不要用"&",这里如果取址的话,会慢很多,这就是为什么有的人加了当前弧就慢的要死(比如我)
now[x] = i;
int y = to[i];
if (d[y] == d[x] + 1 && cap[i]){//分层图阿巴阿巴
k = dinic(y, min(rest, cap[i]));//显然
if (!k) d[y] = 0;
cap[i] -= k;
cap[i ^ 1] += k;
rest -= k;//增广后可行流减少
}
}
return flow - rest;//返回已经增广的流量
}
int main(){
scanf("%d%d%d%d", &n, &m, &s, &t);
for (int i = 1; i <= m; i++){
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
add(u, v, w);
add(v, u, 0);
//这边我们把每条边建一条反边,其实就是反悔机制(还是很好理解的吧)
}
ll flow = 0;
while (BFS())
while (flow = dinic(s, inf)) maxflow += flow;
printf("%lld", maxflow);
return 0;
}
这里我们主要有两个优化,
一个是多路增广,
一个是当前弧.
\(ISAP\)
如果你嫌 \(dinic\) 不够快的话(其实大部分情况下都够的),
那就学一下 \(ISAP\) 吧( \(HLPP\) 的话...毕竟法律规定,不卡 \(dinic/ISAP\)).
基于我们上面的介绍,
我们可以发现,
\(dinic\) 需要多次 \(BFS\) 来构建多次分层图,
虽然每次都可以增广多路,
但是还是要多次构造(废话).
那么我们可不可以只跑一次分层图呢?
当然可以,
这就是我们的 \(ISAP\) 算法.
这里我们定义一个 \(d\) 数组,
\(d_i\) 代表 \(i\) 节点到 \(t\) 的最短距离,
注意,
这里与 \(dinic\) 中的 \(d\) 相反,
我们很容易就可以发现,
当 \(d_s \geq n\) 时,
就莫得增广路了,
我们就可以终止算法了.
我们再定义一个 \(gap\) 数组(这就是传说中的 \(gap\) 优化),
\(gap_i\) 代表距离 \(t\) 为 \(i\) 的节点数.
这里我们很容易可以看出,
当任意不为 \(0\) 的 \(gap\) 变为 \(0\) 时,
这个图就出现了断层,
然后直接终止算法就可了.
这里的终止指的是至少把图 \(DFS\) 一遍,
把所有的增广路跑完(防止有增广路没增广).
代码大部分与 \(dinic\) 相似.
代码如下⬇️
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
typedef long long ll;
const int maxn = 1e4 + 5, inf = 1 << 30;
int n, m, now[maxn], d[maxn], gap[maxn], s, t;
int tot = 1, to[maxn], nxt[maxn], head[maxn], cap[maxn];
ll maxflow;
queue <int> q;
int read(){
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9'){
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x;
}
void add(int x, int y, int z){
to[++tot] = y, cap[tot] = z, nxt[tot] = head[x], head[x] = tot;
}
void BFS(){
q.push(t); now[t] = head[t]; d[t] = 1; gap[1]++;
while (q.size()){
int x = q.front(); q.pop();
for (int i = head[x]; i; i = nxt[i]){
int y = to[i];
if (!d[y]){
q.push(y);
d[y] = d[x] + 1;
gap[d[y]]++;
}
}
}
}
inline int ISAP(int x, int flow){
if (x == t || flow == 0){
maxflow += flow;
return flow;
}
int rest = flow, k;
for (int i = now[x]; i;i = nxt[i]){
now[x] = i;
int y = to[i];
if (d[y] == d[x] - 1 && cap[i]){
k = ISAP(y, min(rest, cap[i]));
if (k){
cap[i] -= k;
cap[i ^ 1] += k;
rest -= k;
}
if (rest == 0) return flow;
}
}
gap[d[x]]--;
if (!gap[d[x]]) d[s] = n + 1;//出现断层,结束程序,但是至少会遍历一遍.
d[x]++;
gap[d[x]]++;
return flow - rest;
}
int main(){
n = read(); m = read(); s = read(); t = read();
for (int i = 1; i <= m; i++){
int u, v, w;
u = read(); v = read(); w = read();
add(u, v, w); add(v, u, 0);
}
BFS();
while (d[s] <= n){
for (int i = 1; i <= n; i++) now[i] = head[i];
ISAP(s, inf);
}
printf("%lld", maxflow);
return 0;
}
最大流完结撒花~
费用流
费用流问题,
也就是最大流最小费用流(最大费用流也一样),
这里其实很简单,
每条边多了一个单位流量,
我们就只需要把 \(dinic/EK\) 中的 \(BFS\) 换成 \(SPFA\) 就可以了.
如果你嫌 \(SPFA\) 慢的话,
可以学一下消圏算法,
这样就可以用 \(dijkstra\) 了.
代码如下⬇️
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 5, inf = 1 << 30;
int n, m, s, t, d[maxn], flow[maxn], pre[maxn], last[maxn];
//d为当前点所连边的费用,flow为当前点所连边的流量,pre为当前点的前驱,last为当前点所连边的编号
int tot = 1, to[maxn], cap[maxn], cost[maxn], head[maxn], nxt[maxn];
ll maxflow, mincost;
bool vis[maxn];
queue <int> q;
int read(){
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9'){
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9'){
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
void add(int u, int v, int w, int c){
to[++tot] = v, cap[tot] = w, cost[tot] = c, nxt[tot] = head[u], head[u] = tot;
}
bool SPFA(){
memset(d, 0x3f, sizeof(d));
memset(flow, 0x3f, sizeof(flow));
memset(vis, 0, sizeof(vis));
q.push(s);
d[s] = 0; pre[t] = -1;
while (q.size()){
int x = q.front(); q.pop();
vis[x] = 0;
for (int i = head[x]; i; i = nxt[i]){
int y = to[i], z = cost[i];
if (d[y] > d[x] + z && cap[i]){
d[y] = d[x] + z;
pre[y] = x;
last[y] = i;
flow[y] = min(flow[x], cap[i]);
if (vis[y] == 0){
q.push(y);
vis[y] = 1;
}
}
}
}
return pre[t] != -1;
}
void MCMF(){//这里用的是基于EK的MCMF
while (SPFA()){
int now = t;
maxflow += flow[t];
mincost += 1ll * flow[t] * d[t];
while (now != s){
cap[last[now]] -= flow[t];
cap[last[now] ^ 1] += flow[t];
now = pre[now];
}
}
}
int main(){
n = read(), m = read(), s = read(), t = read();
for (int i = 1; i <= m; i++){
int u = read(), v = read(), w = read(), c = read();
add(u, v, w, c);
add(v, u, 0, -c);
}
MCMF();
printf("%lld %lld", maxflow, mincost);
return 0;
}
\(dinic\) 版的
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
typedef long long ll;
const int N = 5e4 + 5, M = 1e5 + 5, inf = 1 << 30;
int n, m, s, t, d[N], now[N];
int tot = 1, to[M], cap[M], cost[M], nxt[M], head[N];
bool vis[N];
ll maxflow, mincost;
int read(){
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)){
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)){
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
void add(int u, int v, int w, int c){
to[++tot] = v, cap[tot] = w, cost[tot] = c, nxt[tot] = head[u], head[u] = tot;
}
bool SPFA(){
memset(d, 0x3f, sizeof(int) * (n + 1));
memset(vis, 0, sizeof(int) * (n + 1));
std::queue <int> q;
q.push(s); d[s] = 0; now[s] = head[s]; d[t] = inf;
while (q.size()){
int x = q.front(); q.pop();
vis[x] = 0;
for (int i = head[x]; i; i = nxt[i]){
int y = to[i], z = cost[i];
if (d[y] > d[x] + z && cap[i]){
d[y] = d[x] + z;
now[y] = head[y];
if (!vis[y]){
vis[y] = 1;
q.push(y);
}
}
}
}
return d[t] != inf;
}
int dinic(int x, int flow){
if (x == t || flow == 0){
maxflow += flow;
return flow;
}
vis[x] = 1;
int rest = flow, k, i = now[x];
for (; i && rest; i = nxt[i]){
int y = to[i], z = cost[i];
if (!vis[y] && cap[i] && d[y] == d[x] + z){
k = dinic(y, std::min(rest, cap[i]));
if (!k) d[y] = 0;
cap[i] -= k;
cap[i ^ 1] += k;
rest -= k;
mincost += k * cost[i];
}
}
now[x] = i;
vis[x] = 0;
return flow - rest;
}
int main(){
n = read(), m = read(); s = read(), t = read();
for (int i = 1; i <= m; i++){
int u = read(), v = read(), w = read(), c = read();
add(u, v, w, c); add(v, u, 0, -c);
}
while (SPFA())
while (dinic(s, inf));
printf("%lld %lld", maxflow, mincost);
return 0;
}
恭喜你已经学会网络流啦!
不过还是得多刷题,
网络流模型太多了.
标签：增广,int,cap,flow,网络,dinic,include 来源： https://www.cnblogs.com/sshadows/p/15172645.html