FLOw

Download Speed	Police Chase
School Dance	Distinct Routes
Parcel Delivery	Task Assignment
Distinct Routes II	Distance Queries
Grid Puzzle I	Grid Puzzle II

CSES

LOJ

101. 最大流

115、116、117 今天不會講

定義

FLOW?

FLOW?

FLOW?

$$|f|=2$$

嚴謹定義

一個流網路(Flow Network)是一張有向圖 $G=(V,E)$

每條邊有一個非負權重 $C(u,v)$ 代表邊的流量上限
如果 $(u,v) \notin E$，則 $C(u,v)=0$
有源點 $s$ (source) 跟匯點 $t$ (sink)

嚴謹定義

一個流網路上的 s-t 可行流是一個函數 $f:V \times V \mapsto \mathbb{R} $ 滿足：

$f(u,v)\leq c(u,v), \forall (u,v) \in V \times V$ （流量限制）
$f(u,v)=-f(v,u), \forall (u,v) \in V \times V$（流量對稱）
對於所有$v \in V \backslash \{s,t\}$，有$\sum_{u \in V} f(v,u)=0$（流量守恆）

嚴謹定義

一個流網路上的 s-t 可行流是一個函數 $f:V \times V \mapsto \mathbb{R} $ 滿足：

$f(u,v)\leq c(u,v), \forall (u,v) \in V \times V$ （流量限制）
$f(u,v)=-f(v,u), \forall (u,v) \in V \times V$（流量對稱）
對於所有$v \in V \backslash \{s,t\}$，有$\sum\limits_{u \in V} f(v,u)=0$（流量守恆）

這個 s-t 流的流量為

$|f|=\sum\limits_{v \in V} f(s,v)=\sum\limits_{u \in t} f(u,t)$

一個流網路上，$|f|$最大的 s-t 流是一個最大流

例子

亂解最大流

無獎徵答

這個網路的最大流是什麼？

無獎徵答

這個網路的最大流是什麼？

$|f|=4+3+3+1=11$

亂解最大流

剛剛怎麼找最大流的？

亂解最大流

剛剛怎麼找最大流的？

Greedy 亂做？

每次找一條 s-t 的路流

亂解最大流

剛剛怎麼找最大流的？

Greedy 亂做？

每次找一條 s-t 的路流

亂解最大流

剛剛怎麼找最大流的？

Greedy 亂做？

每次找一條 s-t 的路流

$|f|=1$

Greedy vs. 最大流

Greedy

最大流

差了什麼？

Greedy vs. 最大流

Greedy

最大流

差了什麼？

流回去

可以：

從1號點流2流量給2號點
從2號點倒流3流量給1號點

流回去

可以：

從1號點流2流量給2號點
從2號點倒流3流量給1號點

Recall: $f(2,1)=-f(1,2)=-3$、$c(2,1)=0$

剩餘網路

定義：兩點間的剩餘流量 (residual capacity) 為：

$r(u,v)=c(u,v)-f(u,v)$

也就是這條邊還可以再(倒)流的量

剩餘網路

定義：兩點間的剩餘流量 (residual capacity) 為：

$r(u,v)=c(u,v)-f(u,v)$

也就是這條邊還可以再(倒)流的量

所有 $r(u,v)>0$ 的邊構成的圖稱為剩餘網路 (residual network)

圖 $G$ 上的一組流 $f$ 的剩餘網路記作 $G_f$

剩餘網路

定義：兩點間的剩餘流量 (residual capacity) 為：

$r(u,v)=c(u,v)-f(u,v)$

也就是這條邊還可以再(倒)流的量

所有 $r(u,v)>0$ 的邊構成的圖稱為剩餘網路 (residual network)

圖 $G$ 上的一組流 $f$ 的剩餘網路記作 $G_f$

剩餘網路上一組 s-t 路徑稱為擴充路徑(Augmenting Path)

修好的greedy

在剩餘網路找一條擴充路徑
往他塞滿流
找不到擴充路徑的話就是最大流了

修好的greedy

在剩餘網路找一條擴充路徑
往他塞滿流
找不到擴充路徑的話就是最大流了

屁啦

證明呢

最大流最小割定理 (MFMC)

割？

圖的「割」：把圖分成兩群

中間的邊把他🈹掉

割？

圖的「割」：把圖分成兩群

中間的邊把他🈹掉

定義：一個 s-t 割 (cut) $C$ 是一個滿足 $s \in S, t \in T$ 的割

$S+T=V$、$S\cap T = \{\} $
在流網路中，一個 s-t 割的大小為 $|C|=\sum\limits_{u \in S} \sum\limits_{v \in T} c(u,v)$
也就是所有從 $S$ 到 $T$ 的邊的流量上限和
$T$ 到 $S$ 的不算！
最小割是大小最小的 s-t 割

一些lemma

$f(S,T)=\sum\limits_{u \in S} \sum\limits_{v \in T} f(u,v)$
則$|f|=f(S,T)\leq c(S,T)$

一些lemma

$f(S,T)=\sum\limits_{u \in S} \sum\limits_{v \in T} c(u,v)$
則$|f|=f(S,T)\leq c(S,T)$

任意一組 s-t 流 $\leq$ 任意一組 s-t 割

一些lemma

$f(S,T)=\sum\limits_{u \in S} \sum\limits_{v \in T} c(u,v)$
則$|f|=f(S,T)\leq c(S,T)$

任意一組 s-t 流 $\leq$ 任意一組 s-t 割

最大流 $\leq$ 最小割！

到底找不找得到呢？

一些lemma

$f(S,T)=\sum\limits_{u \in S} \sum\limits_{v \in T} c(u,v)$
則$|f|=f(S,T)\leq c(S,T)$

任意一組 s-t 流 $\leq$ 任意一組 s-t 割

最大流 $\leq$ 最小割！

到底找不找得到呢？可以！

最大流最小割定理

(Max Flow Min Cut Theorem)

對一個流量網路 $G$ ，以下三者等價：

$f$ 是一個 s-t 最大流
$G_f$ 沒有從 $s$ 到 $t$ 的擴充路徑
$|f| = |C|$，其中 $C$ 是 s-t 最小割

最大流最小割定理

(Max Flow Min Cut Theorem)

對一個流量網路 $G$ ，以下三者等價：

$f$ 是一個 s-t 最大流
$G_f$ 沒有從 $s$ 到 $t$ 的擴充路徑
$|f| = |C|$，其中 $C$ 是 s-t 最小割

也就是最大流 = 最小割，而且greedy亂做是對的

最大流最小割定理

(Max Flow Min Cut Theorem)

證明：(1) -> (2)

假設 $G_f$ 有擴充路徑，那走完這條之後 $|f|$ 會更大，矛盾

最大流最小割定理

(Max Flow Min Cut Theorem)

證明：(2) -> (3)

令 $S$ 為 $s$ 在 $G_f$ 上所有能走到的點，$T=V \backslash S$

最大流最小割定理

(Max Flow Min Cut Theorem)

證明：(2) -> (3)

令 $S$ 為 $s$ 在 $G_f$ 上所有能走到的點，$T=V \backslash S$

$S,T$ 是一個🈹
$|f|=|f(S,T)|$ (Lemma)
$S$ 到 $T$ 的邊都流滿（不然會在 $G_f$ 上）
$T$ 到 $S$ 的邊都沒流（不然會在 $G_f$ 上）
$|f|=|f(S,T)|=|C|$

最大流最小割定理

(Max Flow Min Cut Theorem)

證明：(3) -> (1)

$|f| \leq |C|$
剛剛構造了一個 $(S,T)$ 使 $|C|=|f|$

最大流最小割定理

(Max Flow Min Cut Theorem)

證明：(3) -> (1)

$|f| \leq |C|$
剛剛構造了一個 $(S,T)$ 使 $|C|=|f|$

構解：$S$ 為 $s$ 在 $G_f$ 上所有能走到的點，$T=V \backslash S$

最大流演算法

Ford-Fulkerson & Capacity Scaling

Ford-fulkerson

MFMC 說 greedy 是對的

Ford-fulkerson

MFMC 說 greedy 是對的

演算法：

while $G_f$ 上有擴充路徑
找一條擴充

好簡單

Ford-fulkerson

MFMC 說 greedy 是對的

演算法：

while $G_f$ 上有擴充路徑
找一條擴充

好簡單

找路徑？DFS

流多少？擴充路徑上剩餘流量的最小值

Code

#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
using namespace std;
typedef long long ll;
const ll inf = INT32_MAX;
struct edge{
    int v, c, r, rid;
    edge(int _v, int _c, int _r, int _rid){
        v = _v, c = _c, r = _r, rid = _rid;
    }
    // rid: 存反向邊編號
};
struct ff{
    vector<vector<edge>> graph;
    vector<bool> vis;
    ff(int n){
        graph.resize(n + 1);
        vis.resize(n + 1);
    }
    void add(int a, int b, int c, int rc = 0){
        // rc: 無向圖時用
        graph[a].emplace_back(b, c, c, (int)graph[b].size());
        graph[b].emplace_back(a, rc, rc, (int)graph[a].size() - 1);
    }
    int dfs(int u, int t, int cap){
        // cap: 瓶頸大小
        if(cap == 0) return 0; // 涼了
        if(u == t) return cap; // 到t了
        vis[u] = 1;
        for(auto &[v, c, r, rid]: graph[u]){
            if(!vis[v]){
                int flow_val = dfs(v, t, min(cap, r));
                if(flow_val != 0){
                    r -= flow_val;
                    graph[v][rid].r += flow_val;
                    return flow_val;
                }
            }
        }
        return 0;
    }
    ll flow(int s, int t){
        // 記得開long long
        ll ans = 0, flow_val;
        while((flow_val = dfs(s, t, inf)) > 0){
            ans += flow_val;
            fill(vis.begin(), vis.end(), 0);
        }
        return ans;
    }
};
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m, s, t;
    cin >> n >> m >> s >> t;
    ff flow(n);
    int a, b, c;
    for(int i = 0; i < m; i++){
        cin >> a >> b >> c;
        flow.add(a, b, c);
    }
    cout << flow.flow(s, t) << "\n";
}

複雜度分析

複雜度分析

根本超爛

一次擴充 $O(|E|)$

最多擴充 $O(|f|)$ 次

總複雜度 $O(|E|\cdot |f|)$

複雜度是無理數

誰在搞事

誰在搞事

唬爛2：

假設最大邊權為 $U$

先只看 $G_f$ 中剩餘流量 $\geq$ $U$ 的邊

再看 $\geq \frac{U}{2}$ 的邊

再看 $\geq \frac{U}{4}$ 的邊

...

CODE

#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
using namespace std;
typedef long long ll;
const ll inf = INT32_MAX;
struct edge{
    int v, c, r, rid;
    edge(int _v, int _c, int _r, int _rid){
        v = _v, c = _c, r = _r, rid = _rid;
    }
    // rid: 存反向邊編號
};
struct ff{
    vector<vector<edge>> graph;
    vector<bool> vis;
    int maxi = 0;
    ff(int n){
        graph.resize(n + 1);
        vis.resize(n + 1);
    }
    void add(int a, int b, int c, int rc = 0){
        // rc: 無向圖時用
        graph[a].emplace_back(b, c, c, (int)graph[b].size());
        graph[b].emplace_back(a, rc, rc, (int)graph[a].size() - 1);
        maxi = max(maxi, c);
        maxi = max(maxi, rc);
    }
    int dfs(int u, int t, int cap, int delta){
        // cap: 瓶頸大小
        if(cap < delta) return 0; // 涼了
        if(u == t) return cap; // 到t了
        vis[u] = 1;
        for(auto &[v, c, r, rid]: graph[u]){
            if(!vis[v]){
                int flow_val = dfs(v, t, min(cap, r), delta);
                if(flow_val != 0){
                    r -= flow_val;
                    graph[v][rid].r += flow_val;
                    return flow_val;
                }
            }
        }
        return 0;
    }
    ll flow(int s, int t, int delta){
        // 記得開long long
        ll ans = 0, flow_val;
        while((flow_val = dfs(s, t, inf, delta)) > 0){
            ans += flow_val;
            fill(vis.begin(), vis.end(), 0);
        }
        return ans;
    }
    ll scale(int s, int t){
        ll ans = 0;
        while(maxi > 0){
            fill(vis.begin(), vis.end(), 0);
            ans += flow(s, t, maxi);
            maxi /= 2;
        }
        return ans;
    }
};
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m, s, t;
    cin >> n >> m >> s >> t;
    ff flow(n);
    int a, b, c;
    for(int i = 0; i < m; i++){
        cin >> a >> b >> c;
        flow.add(a, b, c);
    }
    cout << flow.scale(s, t) << "\n";
}

正確性證明

假設現在只看剩餘流量 $\geq D$ 的邊
- $G_f(D)$ 為這樣子的剩餘網路
$D=1$時，$G_f(D)=G_f$
所以是對的，只是前面多跑了幾次 FF 而已

複雜度分析

複雜度突然變 $|E|^2 logU$ 了！

複雜度分析

複雜度突然變 $|E|^2 logU$ 了！

證明：

假設現在只看 $\geq D$ 的邊，叫做一個 D-scaling phase
- $D$ 每次被砍半，所以只會有 $O(log(U))$ 次 phases

複雜度分析

複雜度突然變 $|E|^2 logU$ 了！

證明：

假設現在只看 $\geq D$ 的邊，叫做一個 D-scaling phase
- $D$ 每次被砍半，所以只會有 $O(log(U))$ 次 phases
Lemma 1：在 D-scaling phase 結束後，目前找到的 $|f|$ 最多只比最大流大小 $|f_{max}|$ 小 $D\cdot |E|$
- 證明：設 $S$ 是 $G_f(U)$ 中從 $s$ 走得到的點，其他為 $T$
  - 跟證 MFMC 一模一樣
- S-T 割中的邊每條剩餘流量都小於 $D$
- $|f|+D\cdot |E| \geq |C(S,T)| \geq |f_{max}|$

複雜度分析

複雜度突然變 $|E|^2 logU$ 了！

證明：

假設現在只看 $\geq D$ 的邊，叫做一個 D-scaling phase
- $D$ 每次被砍半，所以只會有 $O(log(U))$ 次 phases
Lemma 2：一個 D-scaling phase 最多擴充 $2 \cdot |E|$ 次
- 2D-scaling phase 結束後，$|f|+2D\cdot |E| \geq |f_{max}|$
- 一次擴充最少擴充 $D$
- 最多擴充 $2|E|$ 次就滿了

複雜度分析

複雜度突然變 $|E|^2 logU$ 了！

證明：

假設現在只看 $\geq D$ 的邊，叫做一個 D-scaling phase
- $D$ 每次被砍半，所以只會有 $O(log(U))$ 次 phases
$O(log(U))$ 次 phase
一次 phase 擴充 $O(|E|)$次
一次擴充花 $O(|E|)$
總複雜度 $O(|E|^2logU)$

複雜度分析

複雜度突然變 $|E|^2 logU$ 了！

其實這樣已經可以過所有CSES題了 (flow很難跑到 worst-case)

更快的Flow

Edmonds-Karp, Dinic (Dinitz)

Ford-fulkerson

演算法：

while $G_f$ 上有擴充路徑
找一條擴充

EDmonds-karp

演算法：

while $G_f$ 上有擴充路徑
找一條 $G_f$上的最短路 擴充

EDmonds-karp

演算法：

while $G_f$ 上有擴充路徑
找一條 $G_f$上的最短路 擴充

$O(|E|\cdot |f|)$ -> $O(|V|\cdot|E|^2)$！

證明

兩個 lemma：

令 $d_f(u)$ 為 $G_f$ 上 $s$ 到 $u$ 的最短路長
- Lemma 1：在 Edmonds-Karp 中，$d_f(u)$ 不會減少
令一條邊 $(u,v)$ 為緊邊代表它是目前擴充路徑上剩餘流量最小的一條邊
- Lemma 2：每條邊最多成為 $O(V)$ 次緊邊

證明

兩個 lemma：

令 $d_f(u)$ 為 $G_f$ 上 $s$ 到 $u$ 的最短路長
- Lemma 1：在 Edmonds-Karp 中，$d_f(u)$ 不會減少
令一條邊 $(u,v)$ 為緊邊代表它是目前擴充路徑上剩餘流量最小的一條邊
- Lemma 2：每條邊最多成為 $O(V)$ 次緊邊

一次擴充一條緊邊 -> 最多擴充 $O(VE)$ 次 -> 總複雜度 $O(VE^2)$

證明

Lemma 1 證明：

假設一次擴充完，流從 $f$ 變成 $f'$
某個點 $u$ 的距離從 $d_f(u)$ 變成 $d_{f'}(u)$
假設這個 $u$ 是所有距離減少的點中 $d_{f'}(u)$ 最小的
- 令 $G_{f'}$ 中最短路為 s -> v -> u
  - $d_{f'}(v)$ 沒減少
$(v,u) \notin E(G_f)$
- 不然 $d_f(u) \leq d_f(v)+1 \leq d_{f'}(v)+1=d_{f'}(u)<d_f(u)$
$(v,u) \in E(G_{f'})$，所以 $f$ 到 $f'$ 有走過 $(u,v)$
- 但 $d_f(u)=d_f(v)-1\leq d_{f'}(v)-1=d_{f'}(u)-2<d_f(u)-2$
所以 $d_f(u)$ 永遠不會減少

證明

Lemma 2 證明：

假設一次擴充完，$u,v$ 是緊邊
擴充前 $d_f(v)=d_f(u)+1$
擴充完 $(u,v) \notin E(G_{f'})$
$(u,v)$ 要變成緊邊一定要從 $(v,u)$ 擴充過
$(v,u)$ 擴充完，$d_{f'}(u)=d_{f'}(v)+1\geq d_f(v)+1=d_f(u)+2$
$d(u)$ 至少增加 2
最多增加 $|V|$，所以最多成為緊邊 $O(|V|)$ 次

CODE

#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
#include<queue>
using namespace std;
typedef long long ll;
const ll inf = INT32_MAX;
struct edge{
    int v, c, r, rid;
    edge(int _v, int _c, int _r, int _rid){
        v = _v, c = _c, r = _r, rid = _rid;
    }
    // rid: 存反向邊編號
};
struct ek{
    vector<vector<edge>> graph;
    vector<bool> vis;
    vector<int> dist;
    ek(int n){
        graph.resize(n + 1);
        vis.resize(n + 1);
        dist.resize(n + 1);
    }
    void add(int a, int b, int c, int rc = 0){
        // rc: 無向圖時用
        graph[a].emplace_back(b, c, c, (int)graph[b].size());
        graph[b].emplace_back(a, rc, rc, (int)graph[a].size() - 1);
    }
    bool bfs(int s, int t){
        fill(dist.begin(), dist.end(), inf);
        queue<int> q;
        q.push(s);
        dist[s] = 0;
        while(!q.empty()){
            auto node = q.front();
            q.pop();
            for(auto &[v, c, r, rid]: graph[node]){
                if(r > 0 && dist[v] == inf){
                    dist[v] = dist[node] + 1;
                    q.push(v);
                }
            }
        }
        return dist[t] < inf;
    }
    int dfs(int u, int t, int cap){
        // cap: 瓶頸大小
        if(cap == 0) return 0; // 涼了
        if(u == t) return cap; // 到t了
        vis[u] = 1;
        for(auto &[v, c, r, rid]: graph[u]){
            if(!vis[v] && dist[v] == dist[u] + 1){
                int flow_val = dfs(v, t, min(cap, r));
                if(flow_val != 0){
                    r -= flow_val;
                    graph[v][rid].r += flow_val;
                    return flow_val;
                }
            }
        }
        return 0;
    }
    ll flow(int s, int t){
        // 記得開long long
        ll ans = 0, flow_val;
        while(bfs(s, t)){
            fill(vis.begin(), vis.end(), 0);
            while((flow_val = dfs(s, t, inf)) > 0){
                ans += flow_val;
                fill(vis.begin(), vis.end(), 0);
            }
        }
        return ans;
    }
};
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m, s, t;
    cin >> n >> m >> s >> t;
    ek flow(n);
    int a, b, c;
    for(int i = 0; i < m; i++){
        cin >> a >> b >> c;
        flow.add(a, b, c);
    }
    cout << flow.flow(s, t) << "\n";
}

CODE

#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
#include<queue>
using namespace std;
typedef long long ll;
const ll inf = INT32_MAX;
struct edge{
    int v, c, r, rid;
    edge(int _v, int _c, int _r, int _rid){
        v = _v, c = _c, r = _r, rid = _rid;
    }
    // rid: 存反向邊編號
};
struct ek{
    vector<vector<edge>> graph;
    vector<bool> vis;
    vector<int> dist;
    int maxi = 0;
    ek(int n){
        graph.resize(n + 1);
        vis.resize(n + 1);
        dist.resize(n + 1);
    }
    void add(int a, int b, int c, int rc = 0){
        // rc: 無向圖時用
        graph[a].emplace_back(b, c, c, (int)graph[b].size());
        graph[b].emplace_back(a, rc, rc, (int)graph[a].size() - 1);
        maxi = max(maxi, c);
        maxi = max(maxi, rc);
    }
    bool bfs(int s, int t, int delta){
        fill(dist.begin(), dist.end(), inf);
        queue<int> q;
        q.push(s);
        dist[s] = 0;
        while(!q.empty()){
            auto node = q.front();
            q.pop();
            for(auto &[v, c, r, rid]: graph[node]){
                if(r >= delta && dist[v] == inf){
                    dist[v] = dist[node] + 1;
                    q.push(v);
                }
            }
        }
        return dist[t] < inf;
    }
    int dfs(int u, int t, int cap, int delta){
        // cap: 瓶頸大小
        if(cap < delta) return 0; // 涼了
        if(u == t) return cap; // 到t了
        vis[u] = 1;
        for(auto &[v, c, r, rid]: graph[u]){
            if(!vis[v] && dist[v] == dist[u] + 1){
                int flow_val = dfs(v, t, min(cap, r), delta);
                if(flow_val != 0){
                    r -= flow_val;
                    graph[v][rid].r += flow_val;
                    return flow_val;
                }
            }
        }
        return 0;
    }
    ll flow(int s, int t, int delta){
        // 記得開long long
        ll ans = 0, flow_val;
        while(bfs(s, t, delta)){
            fill(vis.begin(), vis.end(), 0);
            while((flow_val = dfs(s, t, inf, delta)) > 0){
                ans += flow_val;
                fill(vis.begin(), vis.end(), 0);
            }
        }
        return ans;
    }
    ll scale(int s, int t){
        ll ans = 0;
        while(maxi > 0){
            fill(vis.begin(), vis.end(), 0);
            ans += flow(s, t, maxi);
            maxi /= 2;
        }
        return ans;
    }
};
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m, s, t;
    cin >> n >> m >> s >> t;
    ek flow(n);
    int a, b, c;
    for(int i = 0; i < m; i++){
        cin >> a >> b >> c;
        flow.add(a, b, c);
    }
    cout << flow.scale(s, t) << "\n";
}

當然也可以 scaling

還要更快

Edmonds-Karp 浪費時間在哪？

每次最短路都要重跑一次

還要更快

Edmonds-Karp 浪費時間在哪？

每次最短路都要重跑一次

先把最短路 DAG 找出來

還要更快

假設現在有條邊沒有用了..

還要更快

假設現在有條邊沒有用了..

下次直接從下一條邊開始找擴充路徑！

還要更快

假設現在有條邊沒有用了..

下次直接從下一條邊開始找擴充路徑！

對於每個點 $u$ ，紀錄這個點目前跑到的邊 $it(u)$

下次直接從 $it(u)$ 開始跑

還要更快

深入講解&範例

CODE

#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
#include<queue>
using namespace std;
typedef long long ll;
const ll inf = INT32_MAX;
struct edge{
    int v, c, r, rid;
    edge(int _v, int _c, int _r, int _rid){
        v = _v, c = _c, r = _r, rid = _rid;
    }
    // rid: 存反向邊編號
};
struct dinic{
    vector<vector<edge>> graph;
    vector<bool> vis;
    vector<int> dist, it;
    dinic(int n){
        graph.resize(n + 1);
        vis.resize(n + 1);
        dist.resize(n + 1);
        it.resize(n + 1);
    }
    void add(int a, int b, int c, int rc = 0){
        // rc: 無向圖時用
        graph[a].emplace_back(b, c, c, (int)graph[b].size());
        graph[b].emplace_back(a, rc, rc, (int)graph[a].size() - 1);
    }
    bool bfs(int s, int t){
        fill(dist.begin(), dist.end(), inf);
        queue<int> q;
        q.push(s);
        dist[s] = 0;
        while(!q.empty()){
            auto node = q.front();
            q.pop();
            for(auto &[v, c, r, rid]: graph[node]){
                if(r > 0 && dist[v] == inf){
                    dist[v] = dist[node] + 1;
                    q.push(v);
                }
            }
        }
        return dist[t] < inf;
    }
    int dfs(int u, int t, int cap){
        // cap: 瓶頸大小
        if(cap == 0) return 0; // 涼了
        if(u == t) return cap; // 到t了
        vis[u] = 1;
        for(int &i = it[u]; i < (int)graph[u].size(); i++){
            auto &[v, c, r, rid] = graph[u][i];
            if(!vis[v] && dist[v] == dist[u] + 1){
                int flow_val = dfs(v, t, min(cap, r));
                if(flow_val != 0){
                    r -= flow_val;
                    graph[v][rid].r += flow_val;
                    return flow_val;
                }
            }
        }
        return 0;
    }
    ll flow(int s, int t){
        // 記得開long long
        ll ans = 0, flow_val;
        while(bfs(s, t)){
            fill(vis.begin(), vis.end(), 0);
            fill(it.begin(), it.end(), 0);
            while((flow_val = dfs(s, t, inf)) > 0){
                ans += flow_val;
                fill(vis.begin(), vis.end(), 0);
            }
        }
        return ans;
    }
};
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m, s, t;
    cin >> n >> m >> s >> t;
    dinic flow(n);
    int a, b, c;
    for(int i = 0; i < m; i++){
        cin >> a >> b >> c;
        flow.add(a, b, c);
    }
    cout << flow.flow(s, t) << "\n";
}

CODE

#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
#include<queue>
using namespace std;
typedef long long ll;
const ll inf = INT32_MAX;
struct edge{
    int v, c, r, rid;
    edge(int _v, int _c, int _r, int _rid){
        v = _v, c = _c, r = _r, rid = _rid;
    }
    // rid: 存反向邊編號
};
struct dinic{
    vector<vector<edge>> graph;
    vector<bool> vis;
    vector<int> dist, it;
    int maxi = 0;
    dinic(int n){
        graph.resize(n + 1);
        vis.resize(n + 1);
        dist.resize(n + 1);
        it.resize(n + 1);
    }
    void add(int a, int b, int c, int rc = 0){
        // rc: 無向圖時用
        graph[a].emplace_back(b, c, c, (int)graph[b].size());
        graph[b].emplace_back(a, rc, rc, (int)graph[a].size() - 1);
        maxi = max(maxi, c);
        maxi = max(maxi, rc);
    }
    bool bfs(int s, int t, int delta){
        fill(dist.begin(), dist.end(), inf);
        queue<int> q;
        q.push(s);
        dist[s] = 0;
        while(!q.empty()){
            auto node = q.front();
            q.pop();
            for(auto &[v, c, r, rid]: graph[node]){
                if(r > 0 && dist[v] == inf && r >= delta){
                    dist[v] = dist[node] + 1;
                    q.push(v);
                }
            }
        }
        return dist[t] < inf;
    }
    int dfs(int u, int t, int cap, int delta){
        // cap: 瓶頸大小
        if(cap < delta) return 0; // 涼了
        if(u == t) return cap; // 到t了
        vis[u] = 1;
        for(int &i = it[u]; i < (int)graph[u].size(); i++){
            auto &[v, c, r, rid] = graph[u][i];
            if(!vis[v] && dist[v] == dist[u] + 1){
                int flow_val = dfs(v, t, min(cap, r), delta);
                if(flow_val != 0){
                    r -= flow_val;
                    graph[v][rid].r += flow_val;
                    return flow_val;
                }
            }
        }
        return 0;
    }
    ll flow(int s, int t, int delta){
        // 記得開long long
        ll ans = 0, flow_val;
        while(bfs(s, t, delta)){
            fill(vis.begin(), vis.end(), 0);
            fill(it.begin(), it.end(), 0);
            while((flow_val = dfs(s, t, inf, delta)) > 0){
                ans += flow_val;
                fill(vis.begin(), vis.end(), 0);
            }
        }
        return ans;
    }
    ll scale(int s, int t){
        ll ans = 0;
        while(maxi > 0){
            ans += flow(s, t, maxi);
            maxi /= 2;
        }
        return ans;
    }
};
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m, s, t;
    cin >> n >> m >> s >> t;
    dinic flow(n);
    int a, b, c;
    for(int i = 0; i < m; i++){
        cin >> a >> b >> c;
        flow.add(a, b, c);
    }
    cout << flow.scale(s, t) << "\n";
}

又可以 scaling 了

複雜度分析

$O(V^2E)$

可以想像成把Edmonds-Karp的一個 $E$ 壓成 $V$

證明：

每個點要試的點數不超過 $deg(u)$
- 全部人要試的點數不超過 $O(|E|)$
每次擴充會有一條邊變緊邊
- 有人的 $it(u)$ 會增加
- 最多擴充 $O(|E|)$ 次
每次擴充路徑長為 $O(k)$
擴充所有同樣長度的路徑要 $O(k|E|)$
總複雜度 $\sum\limits_{k=1}^{|V|-1} O(k|E|)=O(|V|^2|E|)$

複雜度分析

更爽的特例：

單位流網路中是 $O(min(V^{2/3},E^{1/2}))$
二分圖匹配網路中是 $O(\sqrt{V} E)$

二分圖匹配是 $O(\sqrt{V} E)$ 的證明：

擴充完 $1$ ~ $\sqrt{|V|}$ 的路徑後，剩下的每條擴充路徑長度都 $\geq \sqrt{|V|}$
- 這部分是 $O(\sqrt{V} E)$
每個點都只會有最多一條擴充路徑經過他
所以剩下的擴充路徑數 $\leq \sqrt {|V|}$
- 擴充一條路徑花 $O(|E|)$ 的時間，所以這部分也是 $O(\sqrt{V} E)$
所以加起來就是 $O(\sqrt{V} E)$

例題

小聲明

講師不會備課所以聽不懂很正常

可以先把 Dinic 想像成一個會輸出最大流的黑盒子

CSES 1694

有 $n$ 台機器跟 $m$ 條電纜，每條電纜連接 $u,v)$，有一個頻寬上限 $c$

請問從機器 1 傳訊到機器 $n$ 的最大頻寬為多少？

$n \leq 500$
$m \leq 1000$
$c \leq 10^9$

CSES 1694

其實就是最大流裸題

LOJ 127 有更強的測資

(Dinic w/ Scaling 可以拿88分剩下的是給更快的)

(但是洛谷說網路流題不能卡Dinic)

CSES 1695

最小割裸題

還記得怎麼構解嗎？

CSES 1696

有 $n$ 個男生跟 $m$ 個女生，有 $k$ 對男生跟女生想一起跳舞

一個人只能跟另一個人跳舞，請問最多可以湊成幾對舞伴？

P. S. Happy Pride Month

$1 \leq n,m \leq 500$
$1 \leq k \leq 1000$

CSES 1696

二分圖匹配

$s$ 跟 $t$ 怎麼辦？

CSES 1696

二分圖匹配

$s$ 跟 $t$ 怎麼辦？

把所有源點連到超源點、所有匯點連到超匯點

我真的沒時間了燒雞

這些是上課可能會講得例題

最小費用(最大)流

Min Cost Max Flow

定義

一個費用流網路(Flow Network)是一張有向圖 $G=(V,E)$

每條邊有一個非負權重 $C(u,v)$ 代表邊的流量上限
- 和一個實數權重 $W(u,v)$ 代表邊的費用
如果 $(u,v) \notin E$，則 $C(u,v)=0$
有源點 $s$ (source) 跟匯點 $t$ (sink)

定義

一個費用流網路上的 s-t 可行流是一個函數 $f:V \times V \mapsto \mathbb{R} $ 滿足：

$f(u,v)\leq c(u,v), \forall (u,v) \in V \times V$ （流量限制）
$f(u,v)=-f(v,u), \forall (u,v) \in V \times V$（流量對稱）
對於所有$v \in V \backslash \{s,t\}$，有$\sum\limits_{u \in V} f(v,u)=0$（流量守恆）

這個 s-t 流的流量為

$|f|=\sum\limits_{v \in V} f(s,v)=\sum\limits_{u \in t} f(u,t)$

這個 s-t 流的費用為

$W(f)=\sum\limits_{(u,v) \in E} f(u,v)W(u,v)$

定義

最小費用最大流：流量是最大的情況下，費用最少的流

這個 s-t 流的流量為

$|f|=\sum\limits_{v \in V} f(s,v)=\sum\limits_{u \in t} f(u,t)$

這個 s-t 流的費用為

$W(f)=\sum\limits_{(u,v) \in E} f(u,v)W(u,v)$

mCMF

Min Cost Max Flow

跟 Ford-Fulkerson 一模一樣！

演算法：

while $G_f$ 上有擴充路徑
找一條花費最小的路徑擴充

mCMF

Min Cost Max Flow

跟 Ford-Fulkerson 一模一樣！

演算法：

while $G_f$ 上有擴充路徑
找一條花費最小的路徑擴充

小問題：剩餘流量的花費？

mCMF

Min Cost Max Flow

跟 Ford-Fulkerson 一模一樣！

演算法：

while $G_f$ 上有擴充路徑
找一條花費最小的路徑擴充

小問題：剩餘流量的花費？

取消花 $W(u,v)$ 的錢 -> 花 $-W(u,v)$ 的錢

mCMF

Min Cost Max Flow

不會證明正確性 QQ

注意到最小花費的路不一定是最短路

所以複雜度退化到 Ford-Fulkerson 的$O(SP\cdot |f|)$

其中 SP 為一次最短路要花的時間

mCMF

Min Cost Max Flow

不會證明正確性 QQ

注意到最小花費的路不一定是最短路

所以複雜度退化到 Ford-Fulkerson 的$O(SP\cdot |f|)$

其中 SP 為一次最短路要花的時間

因為負邊會憑空跑出來所以要用 SPFA (很重要)

但是可以證明如果一開始的圖沒有負環，那之後都不會有

CODE

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const ll inf = INT64_MAX;
struct edge{
    int v, c, r, rid;
    ll w;
    edge(int _v, int _c, int _r, int _rid, int _w){
        v = _v, c = _c, r = _r, rid = _rid, w = _w;
    }
};
struct mcmf{
    vector<vector<edge>> graph;
    vector<int> par, par_eid;
    vector<ll> dist;
    vector<bool> inq;
    mcmf(int n){
        graph.resize(n + 1);
        dist.resize(n + 1);
        par.resize(n + 1);
        inq.resize(n + 1);
        par_eid.resize(n + 1);
    }
    void add(int a, int b, int c, ll w){
        graph[a].emplace_back(b, c, c, (int)graph[b].size(), w);
        graph[b].emplace_back(a, 0, 0, (int)graph[a].size() - 1, -w);
    }
    bool spfa(int s, int t){
        fill(inq.begin(), inq.end(), 0);
        fill(dist.begin(), dist.end(), inf);
        queue<int> q;
        q.emplace(s);
        inq[s] = 1;
        dist[s] = 0;
        while(!q.empty()){
            int u = q.front();
            q.pop();
            inq[u] = 0;
            for(int i = 0; i < (int)graph[u].size(); i++){
                auto &[v, c, r, rid, w] = graph[u][i];
                if(dist[u] + w < dist[v] && r > 0){
                    dist[v] = dist[u] + w;
                    par[v] = u;
                    par_eid[v] = i;
                    if(!inq[v]) q.push(v), inq[v] = 1;
                }
            }
        }
        return dist[t] < inf;
    }
    pair<ll, ll> flow(int s, int t){
        ll ans = 0, mf = 0;
        while(spfa(s, t)){
            ll cap = inf;
            int cur = t;
            while(cur != s){
                cap = min(cap, (ll)graph[par[cur]][par_eid[cur]].r);
                cur = par[cur];
            }
            cur = t;
            while(cur != s){
                ans += cap * graph[par[cur]][par_eid[cur]].w;
                graph[par[cur]][par_eid[cur]].r -= cap;
                graph[cur][graph[par[cur]][par_eid[cur]].rid].r += cap;
                cur = par[cur];
            }
            mf += cap;
        }
        return make_pair(mf, ans);
    }
};
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    cin >> n >> m;
    mcmf flow(n);
    int a, b, c, w;
    for(int i = 0; i < m; i++){
        cin >> a >> b >> c >> w;
        flow.add(a, b, c, w);
    }
    auto res = flow.flow(1, n);
    cout << res.first << " " << res.second << "\n";
}