HDU 4685 Prince and Princess（最大匹配+强连通分量）

最新推荐文章于 2021-07-28 15:25:10 发布

godspeedkaka

最新推荐文章于 2021-07-28 15:25:10 发布

阅读量602

点赞数

CC 4.0 BY-SA版权

分类专栏：程序设计竞赛文章标签： HDU 最大匹配强连通分量

本文链接：https://blog.youkuaiyun.com/u014664226/article/details/48650169

程序设计竞赛专栏收录该内容

360 篇文章

订阅专栏

本文深入探讨了一种特殊的婚姻配对问题，其中王子和公主的数量不等，且存在虚拟角色来实现完美匹配。通过使用匈牙利算法进行最大匹配，解决了实际婚姻配对中的限制条件。文章详细解释了如何构建图模型，实现完美匹配，并讨论了增加虚拟角色以解决王子和公主数量不匹配的问题。最后，通过实例展示了如何应用此算法解决现实世界中的配对问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：n个王子和m个公主，王子只能和他喜欢的公主结婚，公主可以和所有的王子结婚，输出所有王子可能的结婚对象。

思路：这道题是poj 1904的强化班 POJ1904传送门

之所以说是强化，主要是因为这样几点：首先王子和公主的数目不同，这就导致了有一些王子无法和公主结婚，其次POJ那道题给出了一个完美匹配，而这道题并没有给出。

解决方法，我们可以把这个图先构造出一个完美匹配，具体方法是先求出这个二分图的最大匹配，假设此时有k对可以结婚的组合，那么王子还剩n-k，公主还剩m-k，那么我们增加n-k个虚拟公主和m-k个虚拟王子，每个虚拟王子可以和所有公主结婚，每个虚拟公主可以和所有王子结婚，其实这里的虚拟的意思相当于空位,即一个王子假如和虚拟公主结婚，相当于把这个王子给空出来不让他结婚。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<ctime>
#define eps 1e-6
#define LL long long
#define pii pair<int, int>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int n, m;
//匈牙利算法
/* *********************************************
二分图匹配（Hopcroft-Carp的算法）。
初始化：g[][]邻接矩阵
调用：res=MaxMatch();  Nx,Ny要初始化！！！
时间复杂大为 O(V^0.5 E)
 
适用于数据较大的二分匹配
需要ｑｕｅｕｅ头文件
********************************************** */
const int MAXN=1200;
const int INF=1<<28;
int g[MAXN][MAXN],Mx[MAXN],My[MAXN],Nx,Ny; //nx，ny为左边右边的点的个数，编号从零开始 
int dx[MAXN],dy[MAXN],dis;
bool vst[MAXN];
bool searchP()
{
    queue<int>Q;
    dis=INF;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    for(int i=0;i<Nx;i++)
        if(Mx[i]==-1)
        {
            Q.push(i);
            dx[i]=0;
        }
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        if(dx[u]>dis)  break;
        for(int v=0;v<Ny;v++)
            if(g[u][v]&&dy[v]==-1)
            {
                dy[v]=dx[u]+1;
                if(My[v]==-1)  dis=dy[v];
                else
                {
                    dx[My[v]]=dy[v]+1;
                    Q.push(My[v]);
                }
            }
    }
    return dis!=INF;
}
bool DFS(int u)
{
    for(int v=0;v<Ny;v++)
       if(!vst[v]&&g[u][v]&&dy[v]==dx[u]+1)
       {
           vst[v]=1;
           if(My[v]!=-1&&dy[v]==dis) continue;
           if(My[v]==-1||DFS(My[v]))
           {
               My[v]=u;
               Mx[u]=v;
               return 1;
           }
       }
    return 0;
}
int MaxMatch()
{
    int res=0;
    memset(Mx,-1,sizeof(Mx));
    memset(My,-1,sizeof(My));
    while(searchP())
    {
        memset(vst,0,sizeof(vst));
        for(int i=0;i<Nx;i++)
          if(Mx[i]==-1&&DFS(i))  res++;
    }
    return res;
}
//**************************************************************************/
vector<int> G[MAXN], prince[MAXN];
set<int> ans[MAXN];
int pre[MAXN], lowlink[MAXN], sccno[MAXN], dfs_clock, scc_cnt;
stack<int> S;
void dfs(int u) {
	pre[u] = lowlink[u] = ++dfs_clock;
	S.push(u);
	for(int i = 0; i < G[u].size(); i++) {
		int v = G[u][i];
		if(!pre[v]) {
			dfs(v);
			lowlink[u] = min(lowlink[u], lowlink[v]);
		} else if(!sccno[v]) {
			lowlink[u] = min(lowlink[u], pre[v]);
		}
	}
	if(lowlink[u] == pre[u]) {
		scc_cnt++;
		for(;;) {
			int x = S.top(); S.pop();
			sccno[x] = scc_cnt;
			if(x == u) break;
		}
	}
}
void find_scc(int num) {
	dfs_clock = scc_cnt = 0;
	memset(sccno, 0, sizeof(sccno));
	memset(pre, 0, sizeof(pre));
	for(int i = 0; i < num; i++)
		if(!pre[i]) dfs(i);
}
int main() {
    //freopen("input.txt", "r", stdin);
    int kase = 0;
	int T; cin >> T;
	while(T--) {
		scanf("%d%d", &n, &m);
		for(int i = 0; i < n + m; i++) G[i].clear();
		for(int i = 0; i < n; i++) prince[i].clear();
		for(int i = 0; i < n; i++) ans[i].clear();
		memset(g, 0, sizeof(g));
		Nx = n, Ny = m;
		for(int i = 0; i < n; i++) {
			int k; scanf("%d", &k);
			for(int j = 1; j <= k; j++) {
				int t; scanf("%d", &t);
				t--;
				g[i][t] = 1; prince[i].push_back(t);
			}
		}
		
		int num = n + m - MaxMatch();
		int cnt1 = 0, cnt2 = 0;
		for(int i = 0; i < n; i++) {
			if(Mx[i] == -1) {
				Mx[i] = m + cnt1;
				My[m+cnt1] = i;
				for(int j = 0; j < prince[i].size(); j++) {
					G[Mx[i]].push_back(prince[i][j]);
				}
				for(int j = m; j < num; j++) if(Mx[i] != j) G[Mx[i]].push_back(j);
				cnt1++;
			}
			else {
				for(int j = 0; j < prince[i].size(); j++) {
					if(prince[i][j] != Mx[i]) G[Mx[i]].push_back(prince[i][j]);
				}
				for(int j = m; j < num; j++) G[Mx[i]].push_back(j);
			}
		}
		for(int i = 0; i < m; i++) {
			if(My[i] == -1) {
				My[i] = n + cnt2;
				Mx[n+cnt2] = i;
				for(int j = 0; j < num; j++) {
					if(j != i) G[i].push_back(j);
				}
				cnt2++;
			}
		}
		find_scc(num);
		for(int i = 0; i < num; i++) ans[sccno[i]].insert(i);
		printf("Case #%d:\n", ++kase);
		for(int i = 0; i < n; i++) {
			int id = sccno[Mx[i]];
			vector<int> print;
			for(int j = 0; j < prince[i].size(); j++) {
				int tmp = prince[i][j];
				if(ans[id].count(tmp)) print.push_back(tmp);
			}
			sort(print.begin(), print.end());
			printf("%d", print.size());
			for(int j = 0; j < print.size(); j++) printf(" %d", print[j]+1);
			puts("");
		}
	}
    return 0;
}