最大匹配与网络流的关系

我们知道研究最大匹配的时候，可以用匈牙利算法，但是还可以使用网络流算法如$Dinic$算法来解决问题
我们来看：现在假设已经有了一些点与点之间的匹配关系，如果有一个超级源点$S$连向二部图左侧的所有点，二部图上右侧的点全部连向超级汇点$T$，那么如果所有边限流为$1$，从$S$出发走向$T$是不是就是最大匹配的数量$?$
如果将顶点与顶点之间的连接关系想象成点灯：假设左侧有3个点连接右侧2个点，这3个点能点亮右侧两个点，但是此时的最大匹配只能是2，同样的，如果左侧2个点连接右侧3个点，那么这3个点不都能被左侧点亮，而是最多有2个点被点亮。
所以用流是可以限制住最大匹配的。
最大网络流代码：

#include<bits/stdc++.h>
using namespace std;
#define max(a,b) (a>b)?a:b
#define min(a,b) (a<b)?a:b
const int length = 5e3 + 5;
typedef long long ll;
struct s
{
	int next, to;
	ll w;
};
struct s edge[length << 1];
int head[length];
int rad[length];
int dis[length];
int vis[length];
int cnt = 1;
//第一条边是在1，那么其反向边就是2，1^1=0;
//但是如果第一条边建在2，
//其反向边就是3，2^1就是3（11)然后3再去异或就是2(10)能异或回来 
void build(int u, int v, ll w)
{
	edge[++cnt].to = v;
	edge[cnt].next = head[u];
	edge[cnt].w = w;
	head[u] = cnt;
}//链式前向星
bool bfs(int s, int t)
{
	queue<int> Q;
	Q.push(s);
	memset(vis, 0, sizeof(vis));
	memset(dis, 0, sizeof(dis));
	vis[s] = 1;
	while (!Q.empty())
	{
		int u = Q.front();
		Q.pop();
		rad[u] = head[u];
		for (int i = head[u]; i; i = edge[i].next)
		{
			int v = edge[i].to;
			if (!vis[v] && edge[i].w != 0)
			{
				vis[v] = 1;
				dis[v] = dis[u] + 1;
				Q.push(v);
			}
		}
	}
	return (dis[t] != 0);
}

ll dfs(int u, ll weight, int t)
{
	if (u == t)return weight;
	ll tmp = 0;
	vis[u] = 1;
	for (int i = rad[u]; i; i = edge[i].next)
	{
		int v = edge[i].to;
		rad[u] = i;
		if (!vis[v] && edge[i].w&&dis[v] == dis[u] + 1)
		{
			ll a = dfs(v, min(weight-tmp, edge[i].w), t);
			if (a > 0)
			{
				tmp += a;
				edge[i].w -= a;
				edge[i ^ 1].w += a;//好像知道为啥要用亦或了
				if (tmp >= a)break;
			}
		}
	}
	vis[u] = 0;
	return tmp;
}

ll dinic(int s, int t)
{
	ll yh = 0;
	while (bfs(s, t))//先做bfs再做dfs
	{
		memset(vis, 0, sizeof(vis));
		yh += dfs(s, INT_MAX, t);
	}
	return yh;
}

int main(void)
{
	int n, m, s, t;
	scanf("%d%d%d%d", &n, &m, &s, &t);
	for (int i = 0; i < m; i++)
	{
		int u, v;
		ll w;
		scanf("%d%d%lld", &u, &v, &w);
		build(u, v, w);
		build(v, u, 0);
	}
	ll a = dinic(s, t);
	printf("%lld", a);
}