網絡最大流 Dinic算法

前言

看到網上好多都用的鏈式前向星，就我在用 \(vector\) 鄰接表……

定義

先來介紹一些相關的定義。（我的理解）

網絡

一個網絡是一張帶權的有向圖 \(G=(V,E)\) ，其中每任意一條邊 \((u,v)\) 的權值稱爲這條邊的容量 \(c(u,v)\) 。若這條邊不存在，對應的容量就爲 \(0\) 。其中包含兩個特殊的點：源點 \(S\) 與匯點 \(T\) 。

流量

\(f\) 爲網絡的流函數，每一條邊都有對應的流量。對於合法的流函數包含如下性質。

1. 容量限制： \(f(u,v)≤c(u,v)\)
2. 斜對稱： \(f(u,v)=-f(v,u)\)
3. 流量守恆：對於任意知足不爲源點或匯點的節點 \(k\) ，有： \(∑_{u∈E}f(u,k)=∑_{v∈E}f(k,v)\)

最大流

對於一個網絡，不難發現合法的流函數不少。這張圖的流量爲 \(∑_{k∈E}f(S,k)\) ，顧名思義，最大流就是這張網絡的最大流量。

增廣路

存在一條從 \(S\) 到 \(T\) 的路徑，使得路徑上全部的流量都不爲 \(0\) ，則稱該路徑爲增廣路。

殘量網絡

對於任意時刻，當前時刻網絡中，由全部結點與剩餘容量大於 \(0\) 的邊構成的該網絡的子圖被稱爲殘量網絡。

分層圖

在這個算法中，知足層數 \(de[v]=de[u]+1\) 的邊 \((u,v)\) ，所構成的子圖稱爲分層圖。

Dinic算法

建圖

一條邊中須要包含如下信息：終點節點編號，邊的容量，相反的邊的編號。

struct Node {
	int to, value, rev;
	Node() {}
	Node(int T, int V, LL R) {
		to = T;//節點編號
		value = V;//邊的容量
		rev = R;//相反的邊的編號
	}
};

得雙向存邊，給出一條邊 \((A,B)\) ，其長度爲 \(C\) ，建一條從 \(A\) 到 \(B\) 的邊，權值爲 \(C\) ，與之相反的邊權值爲 \(0\)。

for(int i = 1; i <= m; i++) {
	Quick_Read(A);
	Quick_Read(B);
	Quick_Read(C);
	int idA = v[A].size(), idB = v[B].size();
	v[A].push_back(Node(B, C, idB));
	v[B].push_back(Node(A, 0, idA));
}

雙向存邊是爲了給後面 \(dfs\) 時，若存在更優解，可使得程序反悔，從新走另外一條路。這裏暫時不懂能夠繼續看後面的代碼再來理解這樣建圖的意義。

主體部分

• 一遍 \(bfs\) ，將殘量網絡構形成分層圖，並求出當前殘量網絡是否存在增廣路。
• 一遍 \(dfs\) ，在該分層圖中尋找增廣路，將這條讓這條增廣路消失。

重複上述兩個操做，直到當前網絡中不存在增廣路。

先來看 \(bfs\) 。其返回值爲 \(bool\) ，意爲該殘量網絡中是否還存在增廣路。層數 \(de[i]\) 的意義很明白： \(S\) 到達當前的點 \(i\) 的最小步數。而按照這樣的分層，每次只能將當前流量信息傳遞到下一層數節點上，能夠很大程度上避免張冠李戴的狀況。若 \(T\) 的層數爲 \(1\) ，則說明當前 \(S\) 不能通向 \(T\) ，故而不存在增廣路，跳出循環。

bool bfs_Dinic() {//bfs將殘餘網絡分層，返回是否圖中還存有增廣路 
	memset(de, 0, sizeof(de));//清空深度
	while(!q.empty())
		q.pop();
	q.push(s);
	de[s] = 1; be[s] = 0;
	while(!q.empty()) {
		int now = q.front();
		q.pop();
		int SIZ = v[now].size();
		for(int i = 0; i < SIZ; i++) {
			int next = v[now][i].to;
			if(v[now][i].value && !de[next]) {
				q.push(next);
				be[next] = 0;//分層圖改變，必須改變be[next]的值
				de[next] = de[now] + 1;
				if(next == t)
					return true;
			}
		}
	}
	return false;
}

再來看 \(dfs\) ，來判斷每一次的網絡是否能夠傳遞，完成增廣的過程（如下代碼附上註釋）。這樣一次走了不止 \(1\) 條增廣路，節省了很多時間。

int dfs_Dinic(int now, int flow) {
	if(now == t)//找到匯點
		return flow;
	int i, surp = flow;//當前剩餘流量 
	int SIZ = v[now].size();
	for(i = be[now]; i < SIZ && surp; i++) {
		int next = v[now][i].to, valedge = v[now][i].value;
		if(valedge && de[next] == de[now] + 1) {//&&前判斷是否能夠走，便是剩餘流量是否爲0；&&後判斷是否知足當前殘餘網絡分層要求
			int maxnow = dfs_Dinic(next, Min(surp, valedge));
			if(!maxnow)//經驗定增廣完畢，de這個點不須要在遍歷了
				de[next] = 0;
			v[now][i].value -= maxnow;
			v[next][v[now][i].rev].value += maxnow;//反悔，可能找到其餘路徑比當前這個流大 
			surp -= maxnow;
		}
	}
	be[now] = i;//i以前的增廣路已經更新完
	return flow - surp;
}

最後在來講說剪枝， \(be\) 數組，在遍歷 \(i\) 時，\(be[i]\) 以前的路徑已經找完增廣路了，而對於當前這個分層圖，不存在會有更優解的狀況，程序也不須要反悔，並不會影響程序的正確性，因此直接就不須要遍歷以前的點。

時間複雜度

單看這段程序，能夠發現時間複雜度爲 \(O(n^2m)\) 。

int Dinic() {
	int res = 0, flow = 0;
	while(bfs_Dinic())
		while(flow = dfs_Dinic(s, INF))//最大流的定義 
			res += flow;//流量守恆 
	return res;
}

而其實實際上並不須要這麼多時間，參考資料得知能夠處理\(10^4\)~\(10^5\)這樣規模的網絡。

C++代碼

#include <queue>
#include <cstdio>
#include <vector>
#include <cstring>
using namespace std;
#define LL long long
#define INF 0x3f3f3f3f
#define Min(a, b) ((a) < (b) ? (a) : (b))
void Quick_Read(LL &N) {
	N = 0;
	LL op = 1;
	char c = getchar();
	while(c < '0' || c > '9') {
		if(c == '-')
			op = -1;
		c = getchar();
	}
	while(c >= '0' && c <= '9') {
		N = (N << 1) + (N << 3) + (c ^ 48);
		c = getchar();
	}
	N *= op;
}
const LL MAXN = 2e2 + 5;
struct Node {
	LL to, value, rev;
	Node() {}
	Node(LL T, LL V, LL R) {
		to = T;
		value = V;
		rev = R;
	}
};
vector<Node> v[MAXN];
queue<LL> q;
LL de[MAXN], be[MAXN];
LL n, m, s, t;
bool bfs_Dinic() {
	memset(de, 0, sizeof(de));
	while(!q.empty())
		q.pop();
	q.push(s);
	de[s] = 1; be[s] = 0;
	while(!q.empty()) {
		LL now = q.front();
		q.pop();
		LL SIZ = v[now].size();
		for(int i = 0; i < SIZ; i++) {
			LL next = v[now][i].to;
			if(v[now][i].value && !de[next]) {
				q.push(next);
				be[next] = 0;
				de[next] = de[now] + 1;
				if(next == t)
					return true;
			}
		}
	}
	return false;
}
LL dfs_Dinic(LL now, LL flow) {
	if(now == t)
		return flow;
	int i, surp = flow;
	LL SIZ = v[now].size();
	for(i = be[now]; i < SIZ && surp; i++) {
		LL next = v[now][i].to, valedge = v[now][i].value;
		if(valedge && de[next] == de[now] + 1) {
			LL maxnow = dfs_Dinic(next, Min(surp, valedge));
			if(!maxnow)
				de[next] = 0;
			v[now][i].value -= maxnow;
			v[next][v[now][i].rev].value += maxnow;
			surp -= maxnow;
		}
	}
	be[now] = i;
	return flow - surp;
}
LL Dinic() {
	LL res = 0, flow = 0;
	while(bfs_Dinic())
		while(flow = dfs_Dinic(s, INF))
			res += flow;
	return res;
}
void Read() {
	LL A, B, C;
	Quick_Read(n);
	Quick_Read(m);
	Quick_Read(s);
	Quick_Read(t);
	for(int i = 1; i <= m; i++) {
		Quick_Read(A);
		Quick_Read(B);
		Quick_Read(C);
		LL idA = v[A].size(), idB = v[B].size();
		v[A].push_back(Node(B, C, idB));
		v[B].push_back(Node(A, 0, idA));
	}
}
int main() {
	Read();
	printf("%lld", Dinic());
	return 0;
}

看看本身作對沒有吖