HDU 3081 Marriage Match II （并查集+二分+最大流 | 并查集+二分图匹配）

题意：n 个男生、n个女生玩游戏，每个女生都可以和她不讨厌的男生结婚，此外她的朋友如果也不讨厌这个男生，也可以和他结婚；对于女生，如果A和B是朋友，B和C是朋友，那么A和C也是朋友。每次游戏女生会找一个她不讨厌的男生结婚，如果所有女生匹配成功，则进行下一轮游戏。每个女生只能选择同一个男生一次，问游戏最多能进行几轮。

题解：并查集+二分+最大流 | 并查集+二分图匹配
最大流做法：

对于女生的朋友之间的相互性，我们可以想到并查集，以达到只在女生一列和男生一列之间连线的目的。

男女之间连线的做法，最大流和二分图匹配基本相同，区别在于如何开展新一轮游戏：
①对于最大流，得预先设置开展了几轮，具体做法是将源点与每个女生的连线容量置为轮数（男生与汇点之间同理），由于每个女生只能选择同一个男生一次，轮数不可能超过n，所以我们在0-n上二分答案。

最大流做法：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<fstream>
#include<set>
#include<map>
#include<sstream>
#include<iomanip>
#define ll long long
using namespace std;
/*
 * SAP 邻接矩阵形式
 * 点的编号从 0 开始
 * 增加个 flow 数组，保留原矩阵 maze, 可用于多次使用最大流
 */
const int MAXN = 1100;
int maze[MAXN][MAXN];
int gap[MAXN], dis[MAXN], pre[MAXN], cur[MAXN];
int flow[MAXN][MAXN];//存最大流的流量
int sap(int start, int end, int nodenum) {
    memset(cur, 0, sizeof(cur));
    memset(dis, 0, sizeof(dis));
    memset(gap, 0, sizeof(gap));
    memset(flow, 0, sizeof(flow));
    int u = pre[start] = start, maxflow = 0, aug = -1;
    gap[0] = nodenum;
    while (dis[start] < nodenum) {
    loop:
        for (int v = cur[u]; v < nodenum; v++)
            if (maze[u][v] - flow[u][v] && dis[u] == dis[v] + 1) {
                if (aug == -1 || aug > maze[u][v] - flow[u][v]) aug = maze[u][v] - flow[u][v];
                pre[v] = u;
                u = cur[u] = v;
                if (v == end) {
                    maxflow += aug;
                    for (u = pre[u]; v != start; v = u, u = pre[u]) {
                        flow[u][v] += aug;
                        flow[v][u] -= aug;
                    }
                    aug = -1;
                }
                goto loop;
            }
        int mindis = nodenum - 1;
        for (int v = 0; v < nodenum; v++)
            if (maze[u][v] - flow[u][v] && mindis > dis[v]) {
                cur[u] = v;
                mindis = dis[v];
            }
        if ((--gap[dis[u]]) == 0) break;
        gap[dis[u] = mindis + 1]++;
        u = pre[u];
    }
    return maxflow;
}
const int Max = 1111;
int Parent[Max], Rank[Max];
int Find(int x) {
	return Parent[x] == x ? x : Parent[x] = Find(Parent[x]);
}
void Union(int x, int y) {
	int u, v, root;
	u = Find(x);
	v = Find(y);
	if (u == v) {
		return;
	}
	if (Rank[u] <= Rank[v]) {
		root = Parent[u] = v;
		if (Rank[u] == Rank[v])
			Rank[v]++;
	}
	else
		root = Parent[v] = u;
	//return root;
}
int t, n, m, f, a, b, x[11111], y[11111];
bool check(int x) {
    for (int i = 1; i <= n; i++) maze[0][i] = x;
    for (int i = n + 1; i <= 2 * n; i++) maze[i][2 * n + 1] = x;
    if (sap(0, 2 * n + 1, 2 * n + 2) == x * n) return true;
    else return false;
}
int main() {
	scanf("%d", &t);
	while (t--) {
        memset(maze, 0, sizeof(maze));
        memset(Rank, 0, sizeof(Rank));
		scanf("%d%d%d", &n, &m, &f);
		for (int i = 1; i <= m; i++) {
			scanf("%d%d", &x[i], &y[i]);//girl x    boy y
		}
        for (int i = 1; i <= n; i++) Parent[i] = i;
        for (int i = 1; i <= f; i++) {
            scanf("%d%d", &a, &b);  
            Union(a, b);
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (Find(j) == Find(x[i])) {
                    maze[j][y[i] + n] = 1;
                }
            }
        }
        int l = 0, r = n;
        int ans = 0;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (check(mid)) {
                ans = mid;
                l = mid + 1;
            }
            else r = mid - 1;
        }
        printf("%d\n", ans);
	}
	return 0;
}

二分图匹配做法：

②对于二分图，在每次完全匹配之后，将匹配的边删除，再跑二分图匹配，直到不存在完全匹配。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<fstream>
#include<set>
#include<map>
#include<sstream>
#include<iomanip>
#define ll long long
using namespace std;
//顶点编号从 1 开始的
const int MAXN = 1010;
int uN, vN;//u,v 的数目，使用前面必须赋值
int g[MAXN][MAXN];//邻接矩阵
int linker[MAXN];
bool used[MAXN];
bool dfs(int u) {
    for (int v = 1; v <= vN; v++)
        if (g[u][v] && !used[v]) {
            used[v] = true;
            if (linker[v] == -1 || dfs(linker[v])) {
                linker[v] = u;
                return true;
            }
        }
    return false;
}
int hungary() {
    int res = 0;
    memset(linker, -1, sizeof(linker));
    for (int u = 1; u <= uN; u++) {
        memset(used, false, sizeof(used));
        if (!dfs(u)) return false;
    }
    return true;
}
int Parent[MAXN], Rank[MAXN];
int Find(int x) {
    return Parent[x] == x ? x : Parent[x] = Find(Parent[x]);
}
void Union(int x, int y) {
    int u, v, root;
    u = Find(x);
    v = Find(y);
    if (u == v) {
        return;
    }
    if (Rank[u] <= Rank[v]) {
        root = Parent[u] = v;
        if (Rank[u] == Rank[v])
            Rank[v]++;
    }
    else
        root = Parent[v] = u;
    //return root;
}
int t, n, m, f, a, b, x[11111], y[11111];
int main() {
    scanf("%d", &t);
    while (t--) {
        memset(g, 0, sizeof(g));
        memset(Rank, 0, sizeof(Rank));
        scanf("%d%d%d", &n, &m, &f);
        for (int i = 1; i <= m; i++) {
            scanf("%d%d", &x[i], &y[i]);//girl x    boy y
        }
        for (int i = 1; i <= n; i++) Parent[i] = i;
        for (int i = 1; i <= f; i++) {
            scanf("%d%d", &a, &b);
            Union(a, b);
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (Find(j) == Find(x[i])) {
                    g[j][y[i]] = 1;
                }
            }
        }
        uN = vN = n;
        int ans = 0;
        while (1) {
            if (hungary()) {
                ans++;
                for (int i = 1; i <= n; i++) g[linker[i]][i] = 0;
            }
            else break;
        }
        printf("%d\n", ans);
    }
    return 0;
}