codevs——2822 爱在心中

2822 爱在心中

 

 时间限制: 1 s

 空间限制: 128000 KB

 题目等级 : 钻石 Diamond

题解

 

 

 

题目描述 Description

“每个人都拥有一个梦，即使彼此不相同，能够与你分享，无论失败成功都会感动。爱因为在心中，平凡而不平庸，世界就像迷宫，却又让我们此刻相逢Our Home。”

在爱的国度里有N个人，在他们的心中都有着一个爱的名单，上面记载着他所爱的人（不会出现自爱的情况）。爱是具有传递性的，即如果A爱B，B爱C，则A也爱C。
如果有这样一部分人，他们彼此都相爱，则他们就超越了一切的限制，用集体的爱化身成为一个爱心天使。
现在，我们想知道在这个爱的国度里会出现多少爱心天使。而且，如果某个爱心天使被其他所有人或爱心天使所爱则请输出这个爱心天使是由哪些人构成的，否则输出-1。

输入描述 Input Description

第1行，两个数N、M，代表爱的国度里有N个人，爱的关系有M条。
第2到第M+1行，每行两个数A、B，代表A爱B。

输出描述 Output Description

第1行，一个数，代表爱的国度里有多少爱心天使。
第2行，如果某个爱心天使被其他所有人和爱心天使所爱则请输出这个爱心天使是由哪些人构成的（从小到大排序），否则输出-1。

样例输入 Sample Input

样例输入1：

6 7
1 2
2 3
3 2
4 2
4 5
5 6
6 4

样例输入2：

3 3
1 2
2 1
2 3

样例输出 Sample Output

样例输出1：

2
2 3

样例输出2：

1
-1

数据范围及提示 Data Size & Hint

各个测试点1s

 

题目意思：

给个图，每个环都算作一个爱心天使(一个点不算环)。第一问求多少个爱心天使，第二问求一个特殊爱心天使，其他任何人都可以将爱传递到这个爱心天使，假如没有就输出-1，反之将这个爱心天使内的人按从小到大输出。

想法：

既然求环，不如用强连通分量？哈，不知道强连通分量？不如网上去学一学？

先求出强连通分量，将同一个环内所有元素缩成一个点（包括一个点的），计算出多少个环（这里不包括一个点的）。

缩点示范图(与题目不违和的图)：

第一问Ok了

 

我们可以在脑子里或草稿上画，发现特殊的爱心天使是一个出度为0的缩点。

然后进一步推论：如果特殊的爱心天使A不是一个出度为0的缩点，那么分俩种情况：

Ⅰ：还有人没有爱A，所以A不是特殊的爱心天使

Ⅱ：A出度的对象即所爱的B，也爱A，那么A,B又可以融合成一个天使，在缩完点后就不存在这种情况了。

所以得出发现特殊的爱心天使是一个出度为0的缩点，但并不是出度为0的缩点就是特殊天使下面又有三种情况：

情况①：

出度为0的并不是天使（如3）

情况②：

不只一个出度为0的天使或人(如图中4、1、3)

 

情况③：只有一个出度为0且为天使（如图中4)

我们需要的是情况③。

那么就在缩完点后，判断是否有多个出度为0，是否特殊天使只有一个元素。

于是乎可以写了。

代码：

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 100000
using namespace std;
bool flag,vis[N];
int s,n,m,x,y,tim,tot,top,sum,ans;
int du[N],dfn[N],low[N],size[N],head[N],belong[N],stack[N];
inline int read()
{
    int x=0,f=1;   char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-') f=-1;  ch=getchar(); }
    while(ch<='9'&&ch>='0'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct Edge
{
    int from,next,to;
}edge[N];
inline void add(int x,int y)
{
    tot++;
    edge[tot].to=y;
    edge[tot].next=head[x];
    head[x]=tot;
}
inline void tarjan(int now)
{
    dfn[now]=low[now]=++tim;
    stack[++top]=now;vis[now]=true;
    for(int i=head[now];i;i=edge[i].next)
    {
        int t=edge[i].to;
        if(vis[t])
            low[now]=min(low[now],dfn[t]);
        else if(!dfn[t])tarjan(t),low[now]=min(low[now],low[t]);
    }
    if(low[now]==dfn[now])
    {
        sum++; belong[now]=sum;size[sum]++;
        for(;stack[top]!=now;top--)
        {
            belong[stack[top]]=sum;
            vis[stack[top]]=false;
            size[sum]++;
        }
        vis[now]=false;top--;
    }
}
inline void shrink_point()
{
    for(int i=1;i<=n;i++)
     for(int j=head[i];j;j=edge[j].next)
       if(belong[edge[j].to]!=belong[i]) du[belong[i]]++;
}
int main()
{
    n=read(),m=read();
    for(int i=1;i<=m;i++)
     x=read(),y=read(),add(x,y);
    for(int i=1;i<=n;i++)
     if(!dfn[i]) tarjan(i);
    shrink_point();
    for(int i=1;i<=sum;i++)
    {
        if(size[i]>1) ans++;
        if(!du[i]) s++,x=i;
    }
    printf("%d\n",ans);
    if(s==1&&size[x]!=1)
    {
        for(int i=1;i<=n;i++)
          if(belong[i]==x) printf("%d ",i);
    }  
    else printf("-1");
    return 0;
}

 

 

思路来自：http://herrwerner.lofter.com/post/1dacb250_bb734b3

转载于:https://www.cnblogs.com/z360/p/7078220.html