poj 1904(强连通分量+完美匹配)

传送门:Problem 1904

https://www.cnblogs.com/violet-acmer/p/9739990.html

参考资料：

　　[1]:http://www.cnblogs.com/frog112111/p/3384261.html

　　[2]:https://blog.csdn.net/a709743744/article/details/52133778

　　[3]:http://www.cppblog.com/Uriel/articles/121169.html

题意：

　　有n个王子，每个王子都有k个喜欢的妹子，每个王子只能和喜欢的妹子结婚，大臣给出一个匹配表，每个王子都和一个妹子结婚，但是国王不满意，他要求大臣给他另一个表，每个王子可以和几个妹子结婚，按序号升序输出妹子的编号，这个表应满足所有的王子最终都有妹子和他结婚。

分析：

　　很好的图论题，把强连通分量和完美匹配结合起来了。

　　2*N 个顶点的2 分图，并且给了一个完美匹配(Perfect Matching)以及每个顶点可以连接的其他的顶点。

　　题目要求是否可以确定某 2 个顶点连边后，其他 2*(N - 1) 个顶点的 2 分图是否可以构成完美匹配。

建图：

　　如果王子u喜欢妹子v，则建一条边u指向v(u,v)，对于大臣给出的初始完美匹配，如果王子u和妹子v结婚，则建一条边v指向u(v,u)，然后求强连通分量。

　　对于每个王子和妹子，如果他们都在同一个强连通分量内，则他们可以结婚。

　　为什么呢？因为每个王子只能和喜欢的妹子结婚，初始完美匹配中的丈夫和妻子之间有两条方向不同的边可以互达，则同一个强连通分量中的王子数和妹子数一定是相等的，若王子 x 可以和另外的一个妹子 a 结婚，妹子 a 的原配王子 y 肯定能找到另外一个妹子 b 结婚，因为如果找不到的话，则 x 和 a 必不在同一个强连通分量中。

所以一个王子可以和所有与他同一强连通分量的妹子结婚，而这不会导致同一强连通分量中的其他王子找不到妹子结婚。

　　（证明：王子为什么不能选择不同强连通分量的妹子：

　　反证法：如果强连通分量 1 中的王子选择了强连通分量 2 中的妹子,那么势必强连通分量 2 中的一个王子无法在自己的强连通分量中找到妹子,那么他就会去别的强连通分量找妹子,这样一直循环下去，我们知道最终一定是经过了强连通分量 1,2,x1,x2,xn,……,1，王子们才能都找到自己的妹子，这样这些强连通分量1,2,x1,x2,xn,……,1会构成一个强连通分量,与题设在不同强连通分量中找妹子不符）

此题难点：建图

AC代码：

这一题的数据量挺大的，光是输入输出就会消耗很多时间了，可以用输入输出外挂来加速读入和输出。

Kosaraju算法：

#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;
#define mem(a,b) memset(a,b,sizeof a)
#define pb push_back
const int maxV=4e3+50;

int scc[maxV];
bool vis[maxV];
vector<int >vs;
vector<int >edge[maxV],redge[maxV];

void addEdge(int u,int v)
{
    edge[u].pb(v);
    redge[v].pb(u);
}
void Dfs(int u)
{
    vis[u]=true;
    for(int i=0;i < edge[u].size();++i)
    {
        int to=edge[u][i];
        if(!vis[to])
            Dfs(to);
    }
    vs.pb(u);
}
void rDfs(int u,int sccId)
{
    scc[u]=sccId;
    vis[u]=true;
    for(int i=0;i < redge[u].size();++i)
    {
        int to=redge[u][i];
        if(!vis[to])
            rDfs(to,sccId);
    }
}
void Scc(int maxV)
{
    mem(vis,false);
    vs.clear();
    for(int i=1;i <= maxV;++i)
        if(!vis[i])
            Dfs(i);
    mem(vis,false);
    int sccId=0;
    for(int i=vs.size()-1;i >= 0;--i)
    {
        int v=vs[i];
        if(!vis[v])
        {
            sccId++;
            rDfs(v,sccId);
        }
    }
}
int main()
{
    int N;
    scanf("%d",&N);
    for(int i=1;i <= N;++i)
    {
        int k,v;
        scanf("%d",&k);
        while(k--)
        {
            scanf("%d",&v);
            addEdge(i,v+N);//王子i喜欢妹子v
        }
    }
    for(int i=1;i <= N;++i)
    {
        int v;
        scanf("%d",&v);
        addEdge(v+N,i);//王子i可以和妹子v结婚
    }
    Scc(N);
    for(int i=1;i <= N;++i)
    {
        int res=0;
        int ans[maxV];
        for(int j=0;j < edge[i].size();++j)
        {
            int to=edge[i][j];
            if(scc[i] == scc[to])//同一个强连通分量
                ans[res++]=to;
        }
        sort(ans,ans+res);
        printf("%d",res);
        for(int j=0;j < res;++j)
            printf(" %d",ans[j]-N);
        printf("
");
    }
}

#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;
#define mem(a,b) memset(a,b,sizeof a)
#define pb push_back
const int maxV=4e3+50;

int scc[maxV];
bool vis[maxV];
vector<int >vs;
vector<int >edge[maxV],redge[maxV];

void addEdge(int u,int v)
{
    edge[u].pb(v);
    redge[v].pb(u);
}
void Dfs(int u)
{
    vis[u]=true;
    for(int i=0;i < edge[u].size();++i)
    {
        int to=edge[u][i];
        if(!vis[to])
            Dfs(to);
    }
    vs.pb(u);
}
void rDfs(int u,int sccId)
{
    scc[u]=sccId;
    vis[u]=true;
    for(int i=0;i < redge[u].size();++i)
    {
        int to=redge[u][i];
        if(!vis[to])
            rDfs(to,sccId);
    }
}
void Scc(int maxV)
{
    mem(vis,false);
    vs.clear();
    for(int i=1;i <= maxV;++i)
        if(!vis[i])
            Dfs(i);
    mem(vis,false);
    int sccId=0;
    for(int i=vs.size()-1;i >= 0;--i)
    {
        int v=vs[i];
        if(!vis[v])
        {
            sccId++;
            rDfs(v,sccId);
        }
    }
}
//===============输入输出挂===============
int Scan()     //输入外挂
{
    int res=0,ch,flag=0;
    if((ch=getchar())=='-')
        flag=1;
    else if(ch>='0'&&ch<='9')
        res=ch-'0';
    while((ch=getchar())>='0'&&ch<='9')
        res=res*10+ch-'0';

    return flag?-res:res;
}
void Out(int a)    //输出外挂
{
    if(a>9)
        Out(a/10);
    putchar(a%10+'0');
}
//========================================
int main()
{
    int N;
    scanf("%d",&N);
    for(int i=1;i <= N;++i)
    {
        int k,v;
        //scanf("%d",&k);
        k=Scan();
        while(k--)
        {
            //scanf("%d",&v);
            v=Scan();
            addEdge(i,v+N);//王子i喜欢妹子v
        }
    }
    for(int i=1;i <= N;++i)
    {
        int v;
        //scanf("%d",&v);
        v=Scan();
        addEdge(v+N,i);//王子i可以和妹子v结婚
    }
    Scc(N);
    for(int i=1;i <= N;++i)
    {
        int res=0;
        int ans[maxV];
        for(int j=0;j < edge[i].size();++j)
        {
            int to=edge[i][j];
            if(scc[i] == scc[to])//同一个强连通分量
                ans[res++]=to;
        }
        sort(ans,ans+res);
        //printf("%d",res);
        Out(res);
        for(int j=0;j < res;++j)
        {
            printf(" ");
            Out(ans[j]-N);
            //printf(" %d",ans[j]-N);
        }
        printf("
");
    }
}

好晚了，身心疲惫，明天在补Tarjan算法...............