多源汇最大流 & 关键边

多源汇最大流

很简单，建一个超级源点连接所有的源点，建一个超级汇点连接所有的汇点。

/*
 * @Author: zhl
 * @Date: 2020-10-20 11:09:59
 */
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i = a;i <= b;i++)
#define repE(i,u) for(int i = head[u];i;i = E[i].next)
//#define int long long
using namespace std;

const int N = 2e6 + 10, M = 2e6 + 10, inf = 1e9;
int n, m, s, t, tot, head[N];
int ans, dis[N], cur[N];

struct Edge {
	int to, next, flow;
}E[M<<1];

void addEdge(int from, int to, int w) {
	E[tot] = Edge{ to,head[from],w };
	head[from] = tot++;
	E[tot] = Edge{ from,head[to],0 };
	head[to] = tot++;
}

int bfs() {
	for (int i = 0; i <= n + 1; i++) dis[i] = -1;
	queue<int>Q;
	Q.push(s);
	dis[s] = 0;
	cur[s] = head[s];

	while (!Q.empty()) {
		int u = Q.front();
		Q.pop();
		for (int i = head[u]; ~i; i = E[i].next) {
			int v = E[i].to;
			if (E[i].flow && dis[v] == -1) {
				Q.push(v);
				dis[v] = dis[u] + 1;
				cur[v] = head[v];
				if (v == t)return 1; //分层成功
			}
		}
	}
	return 0;
}

int dfs(int x, int sum) {
	if (x == t)return sum;
	int k, res = 0;
	for (int i = cur[x]; ~i && res < sum; i = E[i].next) {
		cur[x] = i;
		int v = E[i].to;
		if (E[i].flow > 0 && (dis[v] == dis[x] + 1)) {
			k = dfs(v, min(sum, E[i].flow));
			if (k == 0) dis[v] = -1; //不可用
			E[i].flow -= k;E[i ^ 1].flow += k;
			res += k;sum -= k;
		}
	}
	return res;
}

int Dinic() {
	int ans = 0;
	while (bfs()) {
        ans += dfs(s,inf);
	}
	return ans;
}

signed main() {
	scanf("%d%d%d%d",&n,&m,&s,&t);
	memset(head, -1, sizeof(int) * (n + 10));
	rep(i,1,s){
        int x;scanf("%d",&x);
        addEdge(0,x,inf);
    }
    rep(i,1,t){
        int x;scanf("%d",&x);
        addEdge(x,n+1,inf);
    }
    rep(i,1,m){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        addEdge(a,b,c);
    }
    s = 0,t = n + 1;
    printf("%d\n",Dinic());
}

关键边

如果增加某一条边的容量可以增加最大流，则为关键边

跑一个最大流后，从源点bfs，从汇点bfs。交接处的边就是关键边

for (int i = 0; i < tot; i+=2) {
	if (!E[i].flow and vis_t[E[i].to] and vis_s[E[i ^ 1].to]) 			ans++;
}

这里要 i+=2

/*
 * @Author: zhl
 * @Date: 2020-10-21 09:45:30
 */


#include<bits/stdc++.h>
#define rep(i,a,b) for(int i = a;i <= b;i++)
#define repE(i,u) for(int i = head[u];~i;i = E[i].next)
using namespace std;

const int N = 5e2 + 10, M = 5e3 + 10, inf = 1e9;
struct Edge {
	int to, flow, next;
}E[M << 1];
int head[N], tot;
void addEdge(int from, int to, int w) {
	E[tot] = Edge{ to,w,head[from] };
	head[from] = tot++;
	E[tot] = Edge{ from,0,head[to] };
	head[to] = tot++;
}

int n, m, s, t;
int dis[N], cur[N];
bool bfs() {
	rep(i, 0, n)dis[i] = -1;
	queue<int>Q;
	Q.push(s); dis[s] = 0; cur[s] = head[s];
	while (!Q.empty()) {
		int u = Q.front(); Q.pop();
		repE(i, u) {
			int v = E[i].to;
			if (dis[v] == -1 and E[i].flow) {
				cur[v] = head[v];
				dis[v] = dis[u] + 1;
				Q.push(v);
				if (v == t)return true;
			}
		}
	}
	return false;
}

int dfs(int u, int limit) {
	if (u == t)return limit;
	int k, res = 0;
	for (int i = cur[u]; ~i and res < limit; i = E[i].next) {
		int v = E[i].to;
		cur[u] = i;
		if (dis[v] == dis[u] + 1 and E[i].flow) {
			k = dfs(v, min(limit, E[i].flow));
			if (k == 0)dis[v] = -1;
			E[i].flow -= k; E[i ^ 1].flow += k;
			limit -= k; res += k;
		}
	}
	return res;
}

int Dinic() {
	int res = 0;
	while (bfs())res += dfs(s, inf);
	return res;
}

int vis_s[N], vis_t[N];
void Dfs(int u, int* vis, int p) {
	vis[u] = 1;
	repE(i, u) {
		int v = E[i].to;
		if (!vis[v] and E[i ^ p].flow) {
			Dfs(v, vis, p);
		}
	}
}
int main() {
	scanf("%d%d", &n, &m);
	memset(head, -1, sizeof head);
	rep(i, 1, m) {
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		addEdge(a + 1, b + 1, c);
	}
	s = 1, t = n;
	Dinic();

	Dfs(s, vis_s, 0); Dfs(t, vis_t, 1);
	int ans = 0;
	for (int i = 0; i < tot; i+=2) {
		if (!E[i].flow and vis_t[E[i].to] and vis_s[E[i ^ 1].to]) 		  {
			ans++;
		}
	}
	printf("%d\n", ans);
}