题意:
有N个女孩要与N个男孩玩配对游戏.每个女孩有一个可选男孩的集合(即该女孩可以选自己集合中的任意一个男孩作为该轮的搭档).然后从第一轮开始,每个女孩都要和一个不同的男孩配对.如果第一轮N个女孩都配对成功,那么就开始第二轮配对,女孩依然从自己的备选男孩集合中选择,但是不能选那些已经被该女孩在前几轮选择中选过的男孩了(比如i女孩在第一轮选了j男孩,那么i在第二轮就不能选j男孩了). 问你游戏最多能进行多少轮?
思路:
一开始怎么也想不起来运用最大流,唉,,,自己还是水啊!这个题目主要是运用的最大流和并查集和二分,其中二分的作用
是断最多能循环几次,二分注意一些细节,否则TLE;并查集是用来判断女孩之间的朋友关系;最大流就是跑一边,然后更新结
果,如果最大流*n==二分寻找的结果的话,那么就OK了。具体参考(点击打开链接):
(1)最大流. 源点s为0,汇点t为2*n+1.女孩编号1到n,男孩编号n+1到2*n. 假设我们当前二分尝试的轮数为K(即能够进行K轮匹配):
首先如果女孩i可能选择男孩j,那么就有边(i, j+n, 1).且源点到每个女孩i有边(s,i,K),每个男孩j到汇点t有边(j+n,t,K).如果最大流==K*n,那么就表示可以进行最少K轮匹配.
我们下面用最大流的方法做,首先为什么上面的解法是正确的呢?
证:如果满流,那么每个女生肯定选择了K个不同的男孩,每个男孩肯定被K个不同的女孩选择了(因为一个女孩到一个男孩边容量只为1,所以该女孩最多只能选该男孩一次).
那么上面这样就能保证这个游戏可以进行K轮吗?可以的,假设当前图的流量为0,说明任何女孩都没选男孩. 你可以想象假如此时
从S到所有女孩有流量1(虽然容量是K,但是目前我们只放出1流量)流出,那么这些流量肯定会汇集到t(因为最大流为K*n,而我们此时只不过n流量).这个汇集的过程就是第一轮女孩选择了各自不同男孩的结果. 现在从S到所有女孩又有流量1流出(即第二轮开始了),这些流量肯定又经过了n个男孩汇集到t点了 且 如果上一轮i女孩的流量走到j男孩,这一轮i女孩的流量肯定不走j男孩了(因为i女孩到j男孩的边只有1容量).
大问题解决了,现在还有一个小问题: 即如果女孩{1,2,3,4,5,6,7,8,9}是朋友的话,且2号女孩能选择男孩3,我们如果标记来使得其他
所有女孩都能选择男孩3呢?
上面这个问题可以用两个方法来解:1是并查集,2是floyd传递闭包.(其实这两个方法的思想都一样)
下面说说并查集的做法:如果女孩i与女孩j是朋友,那么就把他们所属的并查集合并,最终所有女孩都必定属于一个并查集. 对于女孩u与女孩v如果她们同属于一个并查集(如果用floyd传递闭包,这里就是可达关系,即u与v互相可达),那么遍历n个男孩,合并u与v女孩与各个男孩的关系.
(注意:不要把男孩也算进并查集,比如女孩1与男孩2能选,女孩3与男孩2能选,但是女孩1与女孩3可不是朋友,她们不属于同一个并查集)
代码:
#include<map>
#include<vector>
#include<queue>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#define maxn 4000
#define PI acos(-1.0)
#define INF 1e9
using namespace std;
typedef long long ll;
struct Edge{
int from,to,cap,flow;
Edge(){}
Edge(int f,int t,int c,int fl):from(f),to(t),cap(c),flow(fl){}
};
struct Dinic{
int n,m,s,t;
vector<Edge>edges;
vector<int>G[maxn];
bool vis[maxn];
int d[maxn];
int cur[maxn];
void init(int n,int s,int t){
this->n=n;
this->s=s;
this->t=t;
for(int i=0;i<n;i++){
G[i].clear();
}
edges.clear();
}
void AddEdge(int from,int to,int cap){
edges.push_back((Edge){from,to,cap,0});
edges.push_back((Edge){to,from,0,0}) ;
m=edges.size();
G[from].push_back(m-2);
G[to].push_back(m-1);
}
bool BFS(){
memset(vis,0,sizeof(vis));
queue<int>Q;
Q.push(s);
d[s] = 0;
vis[s]=1;
while(!Q.empty()){
int x=Q.front();
Q.pop();
for(int i=0;i<(int)G[x].size();i++){
Edge &e=edges[G[x][i]];
if(!vis[e.to]&&e.cap>e.flow){
vis[e.to]=1;
d[e.to]=d[x]+1;
Q.push(e.to);
}
}
}
return vis[t] ;
}
int DFS(int x,int a) {
if(x==t||a==0) return a;
int flow=0,f;
for(int& i=cur[x];i<(int)G[x].size();i++){
Edge& e =edges[G[x][i]];
if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
e.flow+=f;
edges[G[x][i]^1].flow-=f;
flow+=f;
a-=f;
if(a==0) break;
}
}
return flow;
}
int Maxflow(){
int flow=0;
while(BFS()){
memset(cur,0,sizeof(cur));
flow+=DFS(s,INF);
}
return flow;
}
}DC;
int fa[maxn];
int findset(int x){
if(fa[x]==-1) return x;
return fa[x]=findset(fa[x]);
}
bool dist[maxn][maxn];
bool solve(int n,int k){
int src=0,dst=2*n+1;
DC.init(n*2+2,src,dst);
for(int i=1;i<=n;i++)
for(int j=n+1;j<=2*n;++j) if(dist[i][j])
DC.AddEdge(i,j,1);
for(int i=1;i<=n;i++) DC.AddEdge(src,i,k);
for(int j=n+1;j<=2*n;j++) DC.AddEdge(j,dst,k);
return DC.Maxflow()==n*k;
}
int main()
{
int t;
scanf("%d",&t);
while(t--){
int n,m,f;
scanf("%d%d%d",&n,&m,&f);
memset(fa,-1,sizeof(fa));
memset(dist,0,sizeof(dist));
for(int i=1;i<=m;i++){
int u,v;
scanf("%d%d",&u,&v);
dist[u][v+n]=1;
}
for(int i=1;i<=f;i++){
int u,v;
scanf("%d%d",&u,&v);
int x=findset(u);
int y=findset(v);
if(x!=y) fa[x]=y;
}
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++)
if(findset(i)==findset(j))
for(int k=n+1;k<=2*n;k++){
dist[i][k]=dist[j][k]=(dist[i][k]||dist[j][k]);
}
int low=0;
int high=100;
while(high>low){
int mid=low+(high-low+1)/2;//注意此处不能同 (high+low)/2
if(solve(n,mid)) low=mid;
else high=mid-1;
}
printf("%d\n",low);
}
return 0;
}