学习笔记_ 上下界网络流 [网络流, 上下界网络流]

随便看看就会的东西

沙茶的 上下界网络流不详解

在做的过程中, 我们常常会遇到一种网络流问题, 不仅每一条边都有一个上界, 而且还有个下界, 即通过这条边的流量是一个区间

你就会被水淹没 不知所措

其实我们平常做的正常向的网络流就是一个上下界网络流的子集(下界为0)…

无源无汇可行流

无源无汇可行流长得大概是下面这样

每一条边有一个绿色的上界, 有一个红色的下界

上下界 - 1.0

这样肯定是没有办法做的…考虑转化成普通的最大流

我们发现, 我们把一条边分成两部分, 一部分是[上界 - 下界] (蓝色), 一部分是[下界] (红色), 我们只要让下界那部分满流, 上界无所谓就行了…

上下界 - 1.1

怎么让指定边满流我们发现也不是很资瓷啊…似乎跑个费用流就行了来着…

我们有更好的办法…直接把这条边在图中去掉, 而加上两条边, 使这个图与原图等价

上下界 - 1.2

  • form点向t连边, 代表这条边必须进入x的流量

  • s点向to连边, 代表这条边要给别的点提供x的流量

然后跑最大流即可 注意最后输出每条边的流量时要加上减去的x大小的流量

e.g.1

沙茶的 代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#define MAXN (100000 + 5)
#define MAXM (500000 + 5)
#define INF (0x7ffffff)
#define rev(a) ((((a) - 1) ^ 1) + 1)
using namespace std;
const int s = 0, t = MAXN - 1;
struct edg
{
int from, to, next, cap, flow, bh;
edg() {}
edg(int fr, int dqt, int ne, int ca, int b): from(fr), to(dqt), next(ne), cap(ca), flow(0), bh(b) {}
} b[MAXM << 1];
int g[MAXN], cntb, n, m, dis[MAXN], least[MAXM], ans[MAXM];
void adn(int from, int to, int cap, int bh)
{
b[++cntb] = edg(from, to, g[from], cap, bh);
g[from] = cntb;
}
int bfs()
{
memset(dis, 0, sizeof(dis));
queue<int> q;
q.push(s);
dis[s] = 1;
while (!q.empty())
{
int dq = q.front();
q.pop();
for (int i = g[dq]; i; i = b[i].next)
if (b[i].cap > b[i].flow && !dis[b[i].to])
dis[b[i].to] = dis[dq] + 1, q.push(b[i].to);
}
return dis[t];
}
int dinic(int dq, int maxf)
{
if (dq == t || !maxf)
return maxf;
int re = 0;
for (int i = g[dq]; i; i = b[i].next)
if (b[i].cap > b[i].flow && dis[b[i].to] == dis[dq] + 1)
{
int zl = dinic(b[i].to, min(maxf, b[i].cap - b[i].flow));
b[i].flow += zl;
b[rev(i)].flow -= zl;
maxf -= zl;
re += zl;
}
return re;
}
void solve()
{
while (bfs())
dinic(s, INF);
bool ok = true;
for (int i = g[s]; i; i = b[i].next)
if (b[i].cap > 0 && b[i].cap != b[i].flow)
{
ok = false;
break;
}
if (!ok)
{
puts("NO");
return ;
}
puts("YES");
for (int i = 1; i <= cntb; i++)
if (b[i].bh && b[i].cap > 0)
ans[b[i].bh] = b[i].flow;
for (int i = 1; i <= m; i++)
printf("%d\n", ans[i] + least[i]);
}
int main()
{
freopen("in.in", "r", stdin);
int tim;
scanf("%d", &tim);
while (tim--)
{
memset(g, 0, sizeof(g));
memset(ans, 0, sizeof(ans));
memset(least, 0, sizeof(least));
cntb = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++)
{
int srx, sry, srz;
scanf("%d%d%d%d", &srx, &sry, &least[i], &srz);
adn(srx, sry, srz - least[i], i);
adn(sry, srx, 0, 0);
adn(s, sry, least[i], 0);
adn(sry, s, 0, 0);
adn(srx, t, least[i], 0);
adn(t, srx, 0, 0);
}
solve();
puts("");
}

return 0;
}

/*
4 6
1 2 1 2
2 3 1 2
3 4 1 2
4 1 1 2
1 3 1 2
4 2 1 2
*/

By Cansult