版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/ZscDst/article/details/84027068
题意
T组测试数据,每组先输入n,m表示有n个王子和m个公主,接下来n行,每行先输入k表示,第i个王子有K个喜欢的公主,然后输入这k个公主的编号。每个王子只能和喜欢的妹子结婚,国王要求给他一个表,每个王子可以和几个公主结婚,按序号升序输出妹子的编号。这个表应满足所有的王子最终都有妹子和他结婚,即必须保证王子与这些对象中的任意一个结婚,都不会影响让剩余的王子中突然有一个人没婚可结了。
思路
其实基本和POJ ~ 1904 ~ King’s Quest (强连通 + 缩点,思维)一样,只不过这个题需要我们求出一种完美匹配。
跑一次n,m个点的二分图匹配以后,此时可能不是完美匹配,即可能会有公子和公主没人结婚,所以我们需要想办法给这些人安排一个对象。
怎么办?那就是虚拟一些公子和公主。
假设第一次二分图匹配的最大匹配数为res,那么左边就有n-res个人没对象,右边m-res个没对象。
那么左边需要添加m-res个虚拟点,右边需要添加n-res个虚拟点。这样左右两边都有N=n+m-res个点。
此时再求一次N,N个点的二分图匹配,即可得到一种完美匹配。
强连通图中共有N*2个点,建边有:
①输入中的王子喜欢公主的边
②虚拟王子和所有公主之间的边,所有王子和虚拟公主之间的边
③根据匹配建边,如果u喜欢v,那么就建v->u的边
强连通缩点,在同一个强连通分量中的点可以随意结婚。
二分图匹配我是拿网络流做法来写的。
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5+5;
const int INF = 0x3f3f3f3f;
struct EDGE
{
int from, to, cap, flow; //起点,终点,容量,流量
EDGE(int u, int v, int c, int f) : from(u), to(v), cap(c), flow(f) {}
};
struct Dinic
{
int n, m, s, t; //结点数,边数(包括反向弧),源点s,汇点t
vector<EDGE> edges; //边表。edges[e]和edges[e^1]互为反向弧
vector<int> G[MAXN]; //邻接表,G[i][j]表示结点i的第j条边在edges数组中的序号
int d[MAXN]; //从起点到i的距离(层数差)
int cur[MAXN]; //当前弧下标
bool vis[MAXN]; //BFS分层使用
void init(int n)
{
this->n = n;
edges.clear();
for (int i = 0; i <= n; i++) G[i].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;
d[s] = 0;
vis[s] = true;
Q.push(s);
while (!Q.empty())
{
int x = Q.front(); Q.pop();
for (int i = 0; i < G[x].size(); i++)
{
EDGE& e = edges[G[x][i]];
if (!vis[e.to] && e.cap > e.flow)
{
vis[e.to] = true;
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 < 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 s, int t)
{
this->s = s; this->t = t;
int flow = 0;
while (BFS())
{
memset(cur, 0, sizeof(cur));
flow += DFS(s, INF);
}
return flow;
}
}solve;
struct Edge
{
int from, to;
Edge (int from, int to): from(from), to(to) {}
};
struct SCC
{
int n, m;
int DFN[MAXN], LOW[MAXN], sccno[MAXN], dfs_clock, scc_cnt;
vector<Edge> edges;
vector<int> G[MAXN];
stack<int> S;
void init(int n)
{
this->n = n, m = 0;
edges.clear();
for (int i = 0; i <= n; i++) G[i].clear();
}
void AddEdge (int from, int to)
{
edges.push_back(Edge(from, to));
m = edges.size();
G[from].push_back(m-1);
}
void dfs(int u)
{
DFN[u] = LOW[u] = ++dfs_clock;
S.push(u);
for (int i = 0; i < G[u].size(); i++)
{
Edge e = edges[G[u][i]];
int v = e.to;
if (!DFN[v])
{
dfs(v);
LOW[u] = min(LOW[u], LOW[v]);
}
else if (!sccno[v])
LOW[u] = min(LOW[u], DFN[v]);
}
if (LOW[u] == DFN[u])
{
scc_cnt++;
while (1)
{
int x = S.top(); S.pop();
sccno[x] = scc_cnt;
if (x == u) break;
}
}
}
void find_scc()
{
dfs_clock = scc_cnt = 0;
memset(DFN, 0, sizeof(DFN)), memset(sccno, 0, sizeof(sccno));
for (int i = 0; i < n; i++)
if (!DFN[i]) dfs(i);
}
}gao;
int n, m, N;
vector<Edge> E;
void build()
{
int s = n+m, t = n+m+1;
solve.init(t);
for (auto i: E) solve.AddEdge(i.from, i.to+n, 1);
for (int i = 0; i < n; i++) solve.AddEdge(s, i, 1);
for (int i = 0; i < m; i++) solve.AddEdge(i+n, t, 1);
int res = solve.MaxFlow(s, t);//第一次二分图匹配
N = n+m-res;
s = N*2, t = N*2+1;
solve.init(t);
gao.init(N*2);//强连通图中有N*2个点
for (auto i: E) solve.AddEdge(i.from, i.to+N, 1);
for (int i = 0; i < N; i++) solve.AddEdge(s, i, 1);
for (int i = 0; i < N; i++) solve.AddEdge(i+N, t, 1);
for (int i = n; i < N; i++)
for (int j = N; j < N*2; j++)
solve.AddEdge(i, j, 1), gao.AddEdge(i, j);//虚拟王子喜欢所有公主
for (int i = 0; i < N; i++)
for (int j = N+m; j < N*2; j++)
solve.AddEdge(i, j, 1), gao.AddEdge(i, j);//所有王子喜欢虚拟公主
res = solve.MaxFlow(s, t);//第二次二分图匹配
for (auto i: E) gao.AddEdge(i.from, i.to+N);//输入中的边加入强连通
for (auto i: solve.edges)
if (i.flow == 1 && i.from != s && i.to != t) gao.AddEdge(i.to, i.from);//匹配边,公主向王子建边
}
int main()
{
int T, CASE = 1; scanf("%d", &T);
while (T--)
{
scanf("%d%d", &n, &m);
E.clear();
for (int u = 0; u < n; u++)
{
int k; scanf("%d", &k);
while (k--)
{
int v; scanf("%d", &v);
v--;
E.push_back(Edge(u, v));
}
}
build();
gao.find_scc();
printf("Case #%d:\n", CASE++);
for (int u = 0; u < n; u++)
{
vector<int> ans;
for (auto i: gao.G[u])
{
int u = gao.edges[i].from, v = gao.edges[i].to;
if (gao.sccno[u] == gao.sccno[v])
if (v-N+1 <= m) ans.push_back(v-N+1);
}
sort(ans.begin(), ans.end());
printf("%d", ans.size());
for (int i = 0; i < ans.size(); i++)
printf(" %d", ans[i]);
printf("\n");
}
}
return 0;
}
/*
2
4 4
2 1 2
2 1 2
2 2 3
2 3 4
1 2
2 1 2
*/