网络流
算法进阶课（试听课）—— 网络流的基本概念_哔哩哔哩_bilibili
概念：
源点：只有流出去的点
汇点：只有流进来的点
流量：一条边上流过的流量
容量：一条边上可供流过的最大流量
残量：一条边上的容量-流量
流：指满足网络流的一种方案。
1，在一个有向图中，有n个点和m条边。有一个源点，和一个汇点，每条边有一个容量限制。
2，每条边的流量<=容量。
3，源点流出量=汇点流入量，其余各点流入量和流出量相等
当不存在增广路时，当前流为最大流。
P3376 【模板】网络最大流 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)
EK算法：
采用连事前向星的方式存储。
struct EDGE
{
int v, power, nxt;
};
EDGE edge[10004];
int tot = 0, head[202];
int n, m, s, t, book[202], pre[202];
int d[202], M = 2147483647;
int bfs();
void add(int u, int v, int w);
void EK();
int main()
{
cin >> n >> m >> s >> t;
int x, y, z;
for (int i = 1; i <= n; i++)
head[i] = -1;
for (int i = 1; i <= m; i++)
{
cin >> x >> y >> z;
add(x, y, z);
add(x,y,0);
}
EK();
return 0;
}
void add(int u, int v, int w)
{
edge[tot].v = v, edge[tot].power = w, edge[tot].nxt = head[u], head[u] = tot, tot++;
}
void EK()
{
long long ans = 0;
while (bfs())
{
ans = ans + d[t];
for (int i = t; i != s; i = edge[pre[i] ^ 1].v)
{
edge[pre[i]].power -= d[t];
edge[pre[i] ^ 1].power += d[t];
}
}
cout << ans;
}
int bfs()//bfs寻找增广路
{
queue<int> q;
memset(book, 0, sizeof(book));
memset(pre, 0, sizeof(pre));
memset(d, 0, sizeof(d));
q.push(s); book[s] = 1;
d[s] = M;
while (!q.empty())
{
int now = q.front(); q.pop();
for (int i = head[now]; i != -1; i = edge[i].nxt)
{
int v = edge[i].v, w = edge[i].power;
if (book[v] == 0 && w > 0)
{
q.push(v);
book[v] = 1;
d[v] = min(d[now], w);
pre[v] = i;
if (v == t)
return 1;
}
}
}
return 0;
}
dinic算法:
对EK算法进行一些优化。
EK算法每次bfs只能找到一条增广路，
dinic算法利用分层图的原理，使用bfs将n个点分层，在使用dfs一次可以找到多条增广路。
#include<iostream>
#include<cmath>
#include<string>
#include<deque>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
struct EDGE
{
int v, power, nxt;
};
EDGE edge[10004];
int tot = 0, head[202], n, m, s, t, dep[202], M = 2147483647;
long long ans;
void add(int x, int y, int z);
void dinic();
int bfs();
int dfs(int x, int mi);
int main()
{
cin >> n >> m >> s >> t;
int x, y, z;
memset(head, -1, sizeof(head));
for (int i = 1; i <= m; i++)
{
cin >> x >> y >> z;
add(x, y, z);
add(y,x,0);
}
dinic();
return 0;
}
void add(int x, int y, int z)
{
edge[tot].v = y; edge[tot].power = z; edge[tot].nxt = head[x]; head[x] = tot; tot++;
}
void dinic()
{
long long ans = 0;
while (bfs())
{
ans = ans + dfs(s, M);
}
cout << ans;
}
int bfs()
{
memset(dep, 0, sizeof(dep));
dep[s] = 1;
queue<int> q;
q.push(s);
while (!q.empty())
{
int now = q.front(); q.pop();
for (int i = head[now]; i != -1; i = edge[i].nxt)
{
if (edge[i].power > 0 && dep[edge[i].v] == 0)
{
dep[edge[i].v] = dep[now] + 1;
q.push(edge[i].v);
}
}
}
if (dep[t] == 0)
return 0;
return 1;
}
int dfs(int x, int mi)//x表示当前节点，mi表示节点s到节点x的所有路径的最小容量
{
if (x == t)
return mi;
int out = 0;
for (int i = head[x]; i != -1; i = edge[i].nxt)
{
if (dep[edge[i].v] == dep[x] + 1 && edge[i].power > 0)
{
int d = dfs(edge[i].v, min(mi, edge[i].power));
mi -= d;
out += d;
edge[i].power -= d;
edge[i ^ 1].power += d;
}
}
if (out == 0)
dep[x] = 0;
return out;
}
最小费用最大流
P3381 【模板】最小费用最大流 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)
和网络流类似。每条边再增加一个量：费用。
求网络流最大时的最小费用。
使用EK算法+SPFA优化可以解决。
EK算法求网络流时，求的是一条增广路，而不是花费最小的路。
使用SPFA代替bfs可以得到花费最小的增广路。
#include<iostream>
#include<cmath>
#include<string>
#include<deque>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int Maxm = 5e4 + 4;
const int Maxn = 5e3 + 3;
struct EDGE
{
int v, power, nxt, cost;
};
EDGE edge[Maxm * 2];
int tot, n, m, s, t, head[Maxn], Max = 2147483647, dis[Maxn], book[Maxn], flow[Maxn];
int pre[Maxn];
void add(int x, int y, int w, int c);
void MCMF();
int SPFA();
int main()
{
cin >> n >> m >> s >> t;
int x, y, w, c;
memset(head, -1, sizeof(head));
for (int i = 1; i <= m; i++)
{
cin >> x >> y >> w >> c;
add(x, y, w, c);
}
//n表示有n个点,从1-n
MCMF();
return 0;
}
void add(int x, int y, int w, int c)
{
edge[tot].v = y; edge[tot].power = w; edge[tot].cost = c; edge[tot].nxt = head[x]; head[x] = tot; tot++;
edge[tot].v = x; edge[tot].power = 0; edge[tot].cost = -c; edge[tot].nxt = head[y]; head[y] = tot; tot++;
}
void MCMF()
{
int ansflow = 0, anscost = 0;
while (SPFA())
{
ansflow += flow[t];
anscost += flow[t] * dis[t];
for (int i = t; i != s; i = edge[pre[i] ^ 1].v)
{
edge[pre[i]].power -= flow[t];
edge[pre[i] ^ 1].power += flow[t];
}
}
cout << ansflow << " " << anscost;
}
int SPFA()
{
queue<int> q;
memset(book, 0, sizeof(book));
memset(flow, 0, sizeof(flow));
for (int i = 1; i <= n; i++)
dis[i] = Max;
q.push(s);
book[s] = 1;
flow[s] = Max;
dis[s] = 0;
//dis[i]表示s到i的最短路径，（费用之和最小）
while (!q.empty())
{
int now = q.front(); q.pop();
book[now] = 0;
for (int i = head[now]; i != -1; i = edge[i].nxt)
{
int v = edge[i].v;
if (edge[i].power > 0 && dis[v] > dis[now] + edge[i].cost)
{
dis[v] = dis[now] + edge[i].cost;
flow[v] = min(flow[now], edge[i].power);
pre[v] = i;
if (book[v] == 0)
book[v] = 1, q.push(v);
}
}
}
if (dis[t] == Max)
return 0;
return 1;
}
