【2186】Popular Cows（强连通分支及其缩点）

id=2186">【2186】Popular Cows（强联通分支及其缩点）

Popular Cows

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 28323		Accepted: 11459

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

3 3
1 2
2 1
2 3

Sample Output

1

Hint

Cow 3 is the only cow of high popularity.

Source

field=source&key=USACO+2003+Fall">USACO 2003 Fall

题目大意是有n头牛，他们有m对特殊的关系

关系A B表示A敬仰B 恩 是感觉怪怪的= =

然后假设A敬仰B B敬仰C 那么A也敬仰C 也就是关系是可传递的

要求找出被其它牛都敬仰的牛的数目

一開始非常费解。要不是放在强连通里，实在没法往这方向靠……

事实上反过来想的话比較好像，强连通分支的定义——强连通分支中从不论什么一个点都能够訪问到其余各点（有向图）

这样再回到题中 能够得出两个结论

1.假设某个强联通分支中的某仅仅牛被分支外的全部牛都敬仰，也就是说分支外的牛都有一条通向他的路，和他在同一个强连通分支里的全部牛也是满足要求的。

2.假设分支中有某头牛敬仰分支外的牛。那么就不存在被全部牛都敬仰的牛。（能够换种方式来想，假设分支中某头牛敬仰分支外的牛，还被其余牛都敬仰，那么分支外的这头牛也应该被包括在分支内。由于这样就说明分支外的那头牛。会有一条通向分支内的路径，也就是符合强连通分量的定义）

3.经2结论可知，出度为0的强连通分支。就是满足条件的牛群。

但假设有两群。就不存在这样的牛。由于两个分支间是没有关系的。

能够自己画一画看看。

找到方法推断就好办了，首先把全部的强连通分支求出来，缩点后变成一团团的。找出出度为0的缩点。假设存在两个或两个以上，答案就是0。假设之存在一个，那么这个点中的全部牛都是满足题意的牛，统计输出就可以。

代码例如以下:

#include <iostream>
#include <cmath>
#include <vector>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#define LL long long
#define fread() freopen("in.in","r",stdin)
#define fwrite() freopen("out.out","w",stdout)

using namespace std;
const int INF = 0x3f3f3f3f;
const int msz = 10000;
const double eps = 1e-8;

struct Edge
{
	int v,next;
};

Edge eg[50050];
int head[10010];
int vis[10010];
//dfs序
int dfn[10010];
//最早可訪问到的点
int low[10010];
//缩点的出度
int in[10010];
//缩点是否满足出度为0
bool can[10010];
//缩点的根
int pre[10010];
int n,tp,tm;
stack <int> s;

void tarjan(int u)
{
	s.push(u);
	vis[u] = 1;
	low[u] = dfn[u] = tm++;
	int v;

	for(int i = head[u]; i != -1; i = eg[i].next)
	{
		v = eg[i].v;
		//点未被訪问过
		if(vis[v] == 0)
		{
			tarjan(v);
			vis[v] = 1;
			low[u] = min(low[u],low[v]);
		}
		//点在栈中
		else if(vis[v] == 1)
		{
			low[u] = min(low[u],dfn[v]);
		}
	}

	//此点为树根
	if(low[u] == dfn[u])
	{
		int x = s.top();
		while(x != u)
		{
			pre[x] = u;
			s.pop();
			x = s.top();
		}
		//标记该分支中各点树根为u
		pre[x] = u;
		s.pop();
	}
}

int main()
{
	int u,v;
	while(~scanf("%d%d",&n,&tp))
	{
		memset(head,-1,sizeof(head));

		for(int i = 0; i < tp; ++i)
		{
			scanf("%d%d",&u,&v);
			eg[i].v = v;
			eg[i].next = head[u];
			head[u] = i;
		}

		memset(vis,0,sizeof(vis));

		for(int i = 1; i <= n; ++i)
		{
			if(vis[i]) continue;

			tm = 0;
			tarjan(i);
		}

		memset(in,0,sizeof(in));
		memset(can,0,sizeof(can));
		int f = 0;
		for(int i = 1; i <= n; ++i)
		{
			for(int j = head[i]; j != -1; j = eg[j].next)
			{
				v = eg[j].v;
				//两个点不在同一个分支内
				if(pre[v] != pre[i])
				{
					in[i]++;
				}
			}
			//该点出度不为0
			if(in[i])
			{
				//该缩点出度不为0
				can[pre[i]] = 1;
			}
		}

		int cnt = 0;
		for(int i = 1; i <= n; ++i)
		{
			//该点为分支根，同一时候该分支出度为0
			if(pre[i] == i && can[i] == 0)
			{
				f = i;
				cnt++;
			}
			if(cnt > 1) break;
		}

		//出度为0的分支多余1个
		if(cnt != 1)
		{
			puts("0");
		}
		else
		{
			cnt = 0;
			//统计分支中的点数
			for(int i = 1; i <= n; ++i)
			{
				if(pre[i] == f) cnt++;
			}
			printf("%d\n",cnt);
		}
	}

	return 0;
}