生和男生配對，有些女生相互是朋友，每個女生也可以跟她朋友所配對的男生配對
每次配對，每個女生都要跟不同的男生配對。問最多能配對幾輪。
思路：這邊需要用到並查集的思想，由於太久沒有碰並查集了，所以看到並查集就只記得父親節點這個東西了。
看了題解，如何實現同一個朋友共享關係。
他的一個想法是：當遇到X女孩的時候，枚舉女孩，假如兩個女孩的祖先相同，則意味着這兩個女孩是朋友，則另外一個女孩就可以和這個女的boy就有關係。
接下來就是網絡流的事情了。
一個女孩只能和一個男的配對一次，所以有關係的男孩和女孩之間的邊的容量爲1
假設可以連k輪。
則意味着這個女孩流入和流出的流量應該爲k，所以女孩和超級源點的容量爲k，男孩和超級匯點的容量爲k，交換也是可以的。
至於k是沒辦法直接求出來的
這裏採用的方法是二分枚舉。每次枚舉一個k，假如實際的K大於k，則這邊的k是會滿足的。利用這個條件進行二分，每次修改與兩個超級點的容量，最後判斷流入超級匯點的容量是否等於mid*k即可。
每一題都是看題解，哎，不知道，能不能學會啊，能不能啊，我要成大神~~~~
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAXN 500
#define MAXM 50000
#define INF 0x7ffffff
int head[MAXN], dep[MAXN], gap[MAXN], cur[MAXN];
int f[MAXN];
int h[MAXN][MAXN];
int cnt;
int bit[11];
int n, m,ff;
struct edge
{
int v;
int cap;
int flow;
int next;
}edg[MAXM];
struct node
{
int x, y;
}no[MAXM];
void init()
{
cnt = 0;
memset(head, -1, sizeof(head));
}
int find(int x)
{
int r = x;
while (f[r] != r)
r = f[r];
f[x] = r;
return f[x];
}
void Union(int x, int y)
{
int fx, fy;
fx =find(x);
fy =find(y);
if (fx != fy)
f[fx] = fy;
}
void addedge(int u, int v, int w, int rw = 0)
{
edg[cnt].v = v;
edg[cnt].cap = w;
edg[cnt].flow = 0;
edg[cnt].next = head[u];
head[u] = cnt++;
edg[cnt].v = u;
edg[cnt].cap = rw;
edg[cnt].flow = 0;
edg[cnt].next = head[v];
head[v] = cnt++;
}
void build(int val)
{
init();
int E = 2 * n + 1;
for (int i = 1; i <= n; i++)
{
addedge(0, i, val);
addedge(n + i, E, val);
}
memset(h, 0, sizeof(h));
for (int i = 0; i < m; i++)
{
int x = no[i].x;
int y = no[i].y;
//枚舉和x女孩是朋友的女孩，則可以和他的男朋友連一條邊
for (int j = 1; j <= n; j++)
if (f[x] == f[j] && !h[j][y])
{
//hash來避免建重邊
addedge(j, n + y, 1);
h[j][y] = 1;
}
}
}
int Q[MAXN];
void BFS(int start, int end)
{
memset(dep, -1, sizeof(dep));
memset(gap, 0, sizeof(gap));
gap[0] = 1;
int front = 0, rear = 0;
dep[end] = 0;
Q[rear++] = end;
while (front != rear)
{
int u = Q[front++];
for (int i = head[u]; i != -1; i = edg[i].next)
{
int v = edg[i].v;
if (dep[v] != -1)continue;
Q[rear++] = v;
dep[v] = dep[u] + 1;
gap[dep[v]]++;
}
}
}
int S[MAXN];
int sap(int start, int end, int n)
{
BFS(start, end);
memcpy(cur, head, sizeof(head));
int top = 0;
int u = start;
int ans = 0;
while (dep[start] < n)
{
if (u == end)
{
int Min = INF;
int inser;
for (int i = 0; i < top; i++)
if (Min>edg[S[i]].cap - edg[S[i]].flow)
{
Min = edg[S[i]].cap - edg[S[i]].flow;
inser = i;
}
for (int i = 0; i < top; i++)
{
edg[S[i]].flow += Min;
edg[S[i] ^ 1].flow -= Min;
}
ans += Min;
top = inser;
u = edg[S[top] ^ 1].v;
continue;
}
bool flag = false;
int v;
for (int i = cur[u]; i != -1; i = edg[i].next)
{
v = edg[i].v;
if (edg[i].cap - edg[i].flow&&dep[v] + 1 == dep[u])
{
flag = true;
cur[u] = i;
break;
}
}
if (flag)
{
S[top++] = cur[u];
u = v;
continue;
}
int Min = n;
for (int i = head[u]; i != -1; i = edg[i].next)
if (edg[i].cap - edg[i].flow&&dep[edg[i].v] < Min)
{
Min = dep[edg[i].v];
cur[u] = i;
}
gap[dep[u]]--;
if (!gap[dep[u]])return ans;
dep[u] = Min + 1;
gap[dep[u]]++;
if (u != start)u = edg[S[--top] ^ 1].v;
}
return ans;
}
int Scan()//讀入外掛
{
int res = 0, ch, flag = 0;
if ((ch = getchar()) == '-') //判斷正負
flag = 1;
else if (ch >= '0' && ch <= '9') //得到完整的數
res = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9')
res = res * 10 + ch - '0';
return flag ? -res : res;
}
int main()
{
int t;
cin >> t;
while (t--)
{
n = Scan();
m = Scan();
ff = Scan();
for (int i = 1; i <= n; i++)
f[i] = i;
for (int i = 0; i < m; i++)
{
no[i].x = Scan();
no[i].y = Scan();
}
int x, y;
for (int i = 0; i < ff; i++)
{
x = Scan();
y = Scan();
Union(x, y);
}
int l = 0;
int r = n;
int ans = 0;
for (int i = 1; i <= n; i++)
f[i] = find(i);
while (l <= r)
{
int mid = (l + r) >> 1;
build(mid);
if (sap(0, 2 * n + 1, 2 * n + 1) == mid*n)
{
ans = mid;
l = mid + 1;
}
else
r = mid - 1;
}
printf("%d\n", ans);
}
}