P1682 过家家
题目描述
有2n个小学生来玩过家家游戏,其中有n个男生,编号为1到n,另外n个女生,编号也是1到n.每一个女生可以先选择一个和她不吵嘴的男生来玩,除此之外,如果编号为X的女生的朋友(也是女生,且编号为Y)不和编号为Z的男生吵嘴,那么X也可以选择Z.此外,朋友关系是可以传递的,比如a和b是朋友,b和c是朋友,那么我们可以认为a和c也是朋友.
当每一位女生都选择了玩伴,那么他们会开始新一轮游戏.在每一轮后,每个女生都会开始去找一个新的男生做玩伴(以前没选过).而且每一个女生最多能强制k个男生接受,无论他们以前是否吵嘴.
现在你的任务就是确定这2n个小学生最多能玩几轮游戏.
输入输出格式
输入格式：
第一行有4个整数n,m,k,f(3<=n<=250,0<m<n*n,0<=f<n).
n表示有2n个小学生,其中n个男生n个女生.
接下来m行,每行包含2个数字a,b表示编号为a的女生和编号为b的男生从没吵嘴过.
再接下来f行,每行包含2个数字c,d表示编号为c的女生和编号为d的女生是朋友.
输出格式：
对于每组数据,输出一个整数,表示2n个小学生最多能玩几轮.
这一题和P3153 [CQOI2009]跳舞几乎是一模一样，那篇题解可以看这里，建图 + 最大流 + 二分即可得到答案，这里不在赘述，写这篇题解是要解决题目中连通性的问题
题目中有提到过，朋友关系是可以传递的,比如a和b是朋友,b和c是朋友,那么我们可以认为a和c也是朋友，据此我们有两个思路：
1.并查集
2.Floyd
并查集是否可行
虽然我很擅长并查集，但是很可惜，并查集的做法在这题并不是特别适用：理由如下：
并查集的最大用处是，利用父亲这一概念很方便的判断两元素是否处于同一集合，但通过某一节点，我们不能很快确定其他节点是否与他在一集合内，唯一想到的方法是遍历所有节点，一一判断是否属于同一集合，比较麻烦，故不适用并查集。
Floyd是否可行
Floyd算法可以判断图的联通性，伪代码大概如下：
for(所有节点（作为中间点）){
for(所有节点（作为起点）){
for(所有节点（作为终点）){
if(起点与中间点联通 && 中间点与终点联通)
起点与终点联通
}
}
}
这就是传递闭包，能适用与这题，理由如下：
利用传递闭包，我们在处理完关系之后可以得到一个二维数组，可以很容易的判断两点是否联通
所以我们使用Floyd传递闭包，解决关系问题，不过要对上述伪代码做适当修改：（男孩B和女孩A玩 && 女孩A和女孩C是朋友）---> 男孩和女孩C玩
所以我们得到代码：
void Floyd(){
for(int k = num + 1;k <= 2 * num;k++){//所有女孩
for(int i = 1;i <= num;i++){//所有男孩
for(int j = num + 1;j <= 2 * num;j++){//所有女孩
dance[i][j] |= dance[i][k] && dance[k][j];//男孩选女孩（建图是也是先男孩再连女孩）
}
}
}
}
//主函数部分
for(int i = 1;i <= nr;i++){
u = RD();v = RD();
dance[v][u + num] = 1;//女孩编号 + num
}
for(int i = 1;i <= nf;i++){
u = RD();v = RD();
dance[u + num][v + num] = dance[v + num][u + num] = 1;
}
Floyd();
最后二分多次建图跑最大流验证答案即可
Code
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
int RD(){
int out = 0,flag = 1;char c = getchar();
while(c < '0' || c >'9'){if(c == '-')flag = -1;c = getchar();}
while(c >= '0' && c <= '9'){out = out * 10 + c - '0';c = getchar();}
return flag * out;
}
const int maxn = 100019,INF = 1e9;
int num,k,nr,nf,nume = 1;
int dance[190][190];
int frind[190][190];
int s,t,maxflow;
int head[maxn << 2];
struct Node{
int v,dis,nxt;
}E[maxn << 3];
void add(int u,int v,int dis){
E[++nume].nxt = head[u];
E[nume].v = v;
E[nume].dis = dis;
head[u] = nume;
}
int d[maxn];
bool bfs(){
queue<int>Q;
memset(d,0,sizeof(d));
d[s] = 1;
Q.push(s);
while(!Q.empty()){
int u = Q.front();Q.pop();
for(int i = head[u];i;i = E[i].nxt){
int v = E[i].v;
if(E[i].dis && !d[v]){
d[v] = d[u] + 1;
if(v == t)return 1;
Q.push(v);
}
}
}
return 0;
}
int Dinic(int u,int flow){
if(u == t)return flow;
int rest = flow,k;
for(int i = head[u];i;i = E[i].nxt){
int v = E[i].v;
if(d[v] == d[u] + 1 && rest && E[i].dis){
k = Dinic(v,min(rest,E[i].dis));
if(!k)d[v] = 0;
E[i].dis -= k;
E[i ^ 1].dis += k;
rest -= k;
}
}
return flow - rest;
}
void build(int a){
memset(head,0,sizeof(head));
nume = 1;
for(int i = 1;i <= num;i++){
add(s,i,a);
add(i,s,0);//源点到每个♂
add(i + num,i + 2 * num,k);
add(i + 2 * num,i + num,0);//♀分两部
add(i + 2 * num,t,a);
add(t,i + 2 * num,0);//女到汇点
}
for(int i = 1;i <= num;i++){
for(int j = num + 1;j <= 2 * num;j++){
if(dance[i][j]){
add(i,j + num,1);
add(j + num,i,0);
}
else{
add(i,j,1);
add(j,i,0);
}
}
}
}
bool check(int mid){
build(mid);
maxflow = 0;
int flow = 0;
while(bfs())while(flow = Dinic(s,INF))maxflow += flow;
if(maxflow == mid * num)return 1;
return 0;
}
int search(int l,int r){
int ans;
while(l <= r){
int mid = l + r >> 1;
if(check(mid))l = mid + 1,ans = mid;
else r = mid - 1;
}
return ans;
}
void Floyd(){
for(int k = num + 1;k <= 2 * num;k++){
for(int i = 1;i <= num;i++){
for(int j = num + 1;j <= 2 * num;j++){
dance[i][j] |= dance[i][k] && dance[k][j];
}
}
}
}
int main(){
num = RD();nr = RD();k = RD();nf = RD();
s = num * 4 + 19;t = s + 1;
int u,v;
for(int i = 1;i <= nr;i++){
u = RD();v = RD();
dance[v][u + num] = 1;
}
for(int i = 1;i <= nf;i++){
u = RD();v = RD();
dance[u + num][v + num] = dance[v + num][u + num] = 1;
}
Floyd();
printf("%d\n",search(0,num + k));
return 0;
}