POJ 2186 Popular Cows

最新推荐文章于 2017-10-02 11:24:42 发布

码代码的猿猿的AC之路

最新推荐文章于 2017-10-02 11:24:42 发布

阅读量1.2k

点赞数 1

CC 4.0 BY-SA版权

分类专栏：图论文章标签： algorithm 强连通分量

本文链接：https://blog.youkuaiyun.com/ck_boss/article/details/18676373

图论专栏收录该内容

133 篇文章

订阅专栏

本文介绍了一种算法，用于确定一群牛中被所有其他牛认为是流行的牛的数量。通过构建有向图并使用Tarjan算法寻找强连通分量来解决这个问题。

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

抽象成：在一个有向图中，找所有的点都可以到达的点的个数

根据题意结果必在一个强连通分量里（所有的答案之间肯定互相能到达）。用tarjan找出所有的连通分量，如果某个连通分量里有连到外面的边，则这个分量肯定不会是答案（分量图是有向的无环图，从分量1里连线到分量2中的边，分量2肯定没有变连回分量1，也就是1到达了2但是2不能到达1）。如果没有向外连边的连通分量不是1个就没有答案。

Popular Cows

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 21376		Accepted: 8732

Description

Every cow's dream is to become the most popular cow in the herd. In a herd of N (1 <= N <= 10,000) cows, you are given up to M (1 <= M <= 50,000) ordered pairs of the form (A, B) that tell you that cow A thinks that cow B is popular. Since popularity is transitive, if A thinks B is popular and B thinks C is popular, then A will also think that C is
popular, even if this is not explicitly specified by an ordered pair in the input. Your task is to compute the number of cows that are considered popular by every other cow.

Input

* Line 1: Two space-separated integers, N and M

* Lines 2..1+M: Two space-separated numbers A and B, meaning that A thinks B is popular.

Output

* Line 1: A single integer that is the number of cows who are considered popular by every other cow.

Sample Input

Sample Output

Hint

Cow 3 is the only cow of high popularity.

Source

USACO 2003 Fall

[Submit] [Go Back] [Status] [Discuss]

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int maxV=11000,maxE=55000;

struct Edge
{
    int to,next;
}edge[maxE];

int Adj[maxV],Size;

void init()
{
    Size=0;
    memset(Adj,-1,sizeof(Adj));
}

void Add_Edge(int u,int v)
{
    edge[Size].to=v;
    edge[Size].next=Adj[u];
    Adj[u]=Size++;
}

int Low[maxV],DFN[maxV],Stack[maxV],Belong[maxV],num[maxV];
int Index,top,scc,n;

bool Instack[maxV];

void tarjan(int u)
{
    int v;
    Low[u]=DFN[u]=++Index;
    Stack[top++]=u;
    Instack[u]=true;

    for(int i=Adj[u];~i;i=edge[i].next)
    {
        v=edge[i].to;
        if(!DFN[v])
        {
            tarjan(v);
            Low[u]=min(Low[u],Low[v]);
        }
        else if(Instack[v])
        {
            Low[u]=min(Low[u],DFN[v]);
        }
    }

    if(Low[u]==DFN[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            Instack[v]=false;
            num[scc]++;
            Belong[v]=scc;
        }while(v!=u);
    }
}

int solve(int n)
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    memset(num,0,sizeof(num));

    Index=scc=top=0;

    for(int i=1;i<=n;i++)
    {
        if(!DFN[i]) tarjan(i);
    }

    return scc;
}

bool yes[maxV];

int main()
{
  int m;
while(scanf("%d%d",&n,&m)!=EOF&&n)
{
    init();
    memset(yes,true,sizeof(yes));
    int a,b;
    for(int i=0;i<m;i++)
    {
        scanf("%d%d",&a,&b);
        Add_Edge(a,b);
    }
    int scc=solve(n);

    for(int i=1;i<=n;i++)
    {
        for(int j=Adj[i];~j;j=edge[j].next)
        {
            int v=edge[j].to,u=i;
            if(Belong[v]!=Belong[u])
            {
                yes[Belong[u]]=false;
            }
        }
    }

    int ans=0,tot=0;

    for(int i=1;i<=scc;i++)
    {
        if(yes[i])
        {
            tot++;
            ans+=num[i];
        }
    }

    if(tot!=1) ans=0;
    printf("%d\n",ans);
}
    return 0;
}