Prince and Princess HDU

Prince and Princess

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 2336    Accepted Submission(s): 695

Problem Description

There are n princes and m princesses. Princess can marry any prince. But prince can only marry the princess they DO love.
For all princes,give all the princesses that they love. So, there is a maximum number of pairs of prince and princess that can marry.
Now for each prince, your task is to output all the princesses he can marry. Of course if a prince wants to marry one of those princesses,the maximum number of marriage pairs of the rest princes and princesses cannot change.

 

Input

The first line of the input contains an integer T(T<=25) which means the number of test cases.
For each test case, the first line contains two integers n and m (1<=n,m<=500), means the number of prince and princess.
Then n lines for each prince contain the list of the princess he loves. Each line starts with a integer k_i(0<=k_i<=m), and then k_i different integers, ranging from 1 to m denoting the princesses.

 

Output

For each test case, first output "Case #x:" in a line, where x indicates the case number between 1 and T.
Then output n lines. For each prince, first print li, the number of different princess he can marry so that the rest princes and princesses can still get the maximum marriage number.
After that print li different integers denoting those princesses,in ascending order.

 

Sample Input

2 4 4 2 1 2 2 1 2 2 2 3 2 3 4 1 2 2 1 2

 

Sample Output

Case #1: 2 1 2 2 1 2 1 3 1 4 Case #2: 2 1 2

 

Source

2013 Multi-University Training Contest 8

 

Recommend

zhuyuanchen520

 

 

n 个王子， m个公主，王子只能娶他喜欢的，公主可以嫁给任何王子，

对每一个王子求出他能娶的公主的最大集合，使之他娶这个集合内的任何一个，都不影响其他王子的选择

 

首先想到的肯定是匹配，但显然不是多重匹配，

 把每个具有相同公主集合的王子放在一起发现

从任何一个王子出发都能到达所有的公主 那么如果我们从公主向她匹配的王子连一条边

是不是就从任何一个王子出发都能到达其它所有的点

因为是有向图  是不是就是 任何两点之前都至少存在一条可以相互到达的路径

那就是SCC了

 

正确做法是

每个王子向他喜欢的公主连边，进行一次匹配求出最大匹配cnt

然后剩下王子n - cnt个，建立（n - cnt）个虚拟的公主，所有的实体王子都向这些公主连边

剩下公主m - cntge， 建立（m - cnt）个虚拟的王子，这些王子都向所有的实体公主连边

再求一次匹配

最后每个公主向她嫁的王子连边 求强连通就好了

#include <iostream>
#include <cstdio>
#include <sstream>
#include <cstring>
#include <map>
#include <cctype>
#include <set>
#include <vector>
#include <stack>
#include <queue>
#include <algorithm>
#include <cmath>
#include <bitset>
#define rap(i, a, n) for(int i=a; i<=n; i++)
#define rep(i, a, n) for(int i=a; i<n; i++)
#define lap(i, a, n) for(int i=n; i>=a; i--)
#define lep(i, a, n) for(int i=n; i>a; i--)
#define rd(a) scanf("%d", &a)
#define rlld(a) scanf("%lld", &a)
#define rc(a) scanf("%c", &a)
#define rs(a) scanf("%s", a)
#define rb(a) scanf("%lf", &a)
#define rf(a) scanf("%f", &a)
#define pd(a) printf("%d
", a)
#define plld(a) printf("%lld
", a)
#define pc(a) printf("%c
", a)
#define ps(a) printf("%s
", a)
#define MOD 2018
#define LL long long
#define ULL unsigned long long
#define Pair pair<int, int>
#define mem(a, b) memset(a, b, sizeof(a))
#define _  ios_base::sync_with_stdio(0),cin.tie(0)
//freopen("1.txt", "r", stdin);
using namespace std;
const int maxn = 410000, INF = 0x7fffffff, maxm = 410000;
int n, m, s, t;
int head[maxn], cur[maxn], vis[maxn], d[maxn], cnt, nex[maxm << 1], nex2[maxm << 1];
int head2[maxn], cnt2;
int vis1[maxn], vis2[maxn];

struct node
{
    int u, v, c, flag;
}Node[maxm << 1], Edge[maxm << 1];

void add_(int u, int v, int c, int flag)
{
    Node[cnt].u = u;
    Node[cnt].v = v;
    Node[cnt].c = c;
    Node[cnt].flag = flag;
    nex[cnt] = head[u];
    head[u] = cnt++;
}

void add(int u, int v, int c)
{
    add_(u, v, c, 1);
    add_(v, u, 0, 0);
}

void add2(int u, int v)
{
    Edge[cnt2].u = u;
    Edge[cnt2].v = v;
    nex2[cnt2] = head2[u];
    head2[u] = cnt2++;
}


bool bfs()
{
    queue<int> Q;
    mem(d, 0);
    Q.push(s);
    d[s] = 1;
    while(!Q.empty())
    {
        int u = Q.front(); Q.pop();
        for(int i = head[u]; i != -1; i = nex[i])
        {
            int v = Node[i].v;
            if(!d[v] && Node[i].c > 0)
            {
                d[v] = d[u] + 1;
                Q.push(v);
                if(v == t) return 1;
            }
        }
    }
    return d[t] != 0;
}

int dfs(int u, int cap)
{
    int ret = 0;
    if(u == t || cap == 0)
        return cap;
    for(int &i = cur[u]; i != -1; i = nex[i])
    {
        int v = Node[i].v;
        if(d[v] == d[u] + 1 && Node[i].c > 0)
        {
            int V = dfs(v, min(cap, Node[i].c));
            Node[i].c -= V;
            Node[i ^ 1].c += V;
            ret += V;
            cap -= V;
            if(cap == 0) break;
        }
    }
    if(cap > 0) d[u] = -1;
    return ret;
}

int Dinic()
{
    int ans = 0;
    while(bfs())
    {
        memcpy(cur, head, sizeof head);
        ans += dfs(s, INF);
    }
    return ans;
}

int pre[maxn], low[maxn], sccno[maxn], dfs_clock, scc_cnt;
stack<int> S;

void dfs(int u)
{
    pre[u] = low[u] = ++dfs_clock;
    S.push(u);
    for(int i = head2[u]; i != -1; i = nex2[i])
    {
        int v = Edge[i].v;
        if(!pre[v])
        {
            dfs(v);
            low[u] = min(low[u], low[v]);
        }
        else if(!sccno[v])
            low[u] = min(low[u], pre[v]);
    }
    if(low[u] == pre[u])
    {
        scc_cnt++;
        for(;;)
        {
            int x = S.top(); S.pop();
            sccno[x] = scc_cnt;
            if(x == u) break;
        }
    }
}
int G[maxn], ans;
int main()
{
    int T;
    int kase = 0;
    rd(T);
    while(T--)
    {
        mem(head, -1), mem(head2, -1);
        mem(vis1, 0), mem(vis2, 0);
        cnt = cnt2 = 0;
        rd(n), rd(m);
        s = 0, t = maxn - 1;
        bool flag = 0;
        int tmp, u, v;
        int x = max(n, m);
        for(int i = 1; i <= n; i++)
        {
            add(s, i, 1);
            rd(tmp);
            for(int j = 1; j <= tmp; j++)
            {
                rd(v);
                add(i, x + v, 1);
                add2(i, x + v);
            }
        }
        for(int i = 1; i <= m; i++) add(x + i, t, 1);
        int max_cnt = Dinic();

        int mx = x * 2;
        for(int i = 1; i <= m - max_cnt; i++)
        {
            mx++;
            add(s, mx, 1);
            for(int j = 1; j <= m; j++)
                add(mx, x + j, 1), add2(mx, x + j);
        }
        for(int i = 1; i <= n - max_cnt; i++)
        {
            mx++;
            add(mx, t, 1);
            for(int j = 1; j <= n; j++)
                add(j, mx, 1), add2(j, mx);
        }
        Dinic();
        for(int i = 0; i < cnt; i++)
        {
            if(!Node[i].flag || Node[i].u == s || Node[i].v == t || Node[i].c != 0) continue;
            add2(Node[i].v, Node[i].u);
        }
        dfs_clock = scc_cnt = 0;
        mem(sccno, 0);
        mem(pre, 0);
        for(int i = 1; i <= mx; i++)
            if(!pre[i]) dfs(i);
        printf("Case #%d:
", ++kase);
        for(int i = 1; i <= n; i++)
        {
            ans = 0;
            for(int j = head2[i]; j != -1; j = nex2[j])
            {
                int v = Edge[j].v;
                if(sccno[i] == sccno[v] && v - x <= m)
                    G[ans++] = v;
            }
            sort(G, G + ans);
            printf("%d", ans);
            for(int j = 0; j < ans; j++)
            {
                printf(" ");
                printf("%d", G[j] - x);
            }

           printf("
");

        }

    }

    return 0;
}