sdut 2604 Thrall’s Dream 判断一个图是否单侧连通

题意：

给你一个有向图，问这个有向图中任何一对结点间，至少有一个结点到另一个结点是可达的。

实际上就是判断一个图是否单侧连通。做法很简单，先强连通分解，然后在新建的图中找一条

最长的链，如果这条链包含所有点，那原图就是单侧联通的，否则就不是。

那如何找最长链呢，很简单因为新建的图是DAG，所以最长链的长度=最长路。而对DAG求最短路

最长路都是可以用dp高效求解的。时间复杂度o（n+m）

数据很水，暴力都能过 QAQ ，还有 poj 2762 有原题。

补：在简单有向图中，任何一对结点间，至少有一个结点到另一个结点是可达的，则称这个图是

单侧连通的。如果图G中任何一对结点两者是相互可达的，则称这个图是强连通的。如果在图G中

略去边的方向，将它看成无向图后，图是连通的，则称该图是弱连通的。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<cmath>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<cstring>
#include<queue>
#include<stack>
#include<list>

using namespace std;


const int maxn=1e5+4;

int dfn[maxn], low[maxn] ,instack[maxn], belong[maxn] ;
int stap[maxn],Stop,Bcnt,Dindex;
int n,m;

struct edge{
	int to;
};

vector<edge> E[maxn];
vector<edge> E2[maxn];


void tarjan(int i){
	int j;
	dfn[i]=low[i]=++Dindex;
	instack[i]=1;
	stap[++Stop]=i;
	for( int k=0;k<E[i].size();k++ ){
		j=E[i][k].to;
		if( !dfn[j] ){
			tarjan(j);
			if( low[j]<low[i] )
				low[i]=low[j];
		}
		else if( instack[j] &&dfn[j]< low[i]  )
			low[i]=dfn[j];
	}
	if( dfn[i]==low[i] ){
		Bcnt++;
		do{
			j=stap[Stop--];
			instack[j]=0;
			belong[j]=Bcnt;
		}
		while( j!=i );
	}


}

void solve(){
	int i;
	Stop=Bcnt=Dindex=0;
	memset(dfn,0,sizeof(dfn));
	memset(instack,0,sizeof(instack));
	memset(belong,0,sizeof(belong));
	memset(low,0,sizeof(low));
	for(int i=1;i<=n;i++){
		if(!dfn [i] ) tarjan(i);
	}

}

void init(){
	for(int i=0;i<maxn;i++){
		E[i].clear();
		E2[i].clear();
	}

}

int dfs(int now){
	if( E2[now].size()==0 ){
        return 1;
	}
	int ans=0;
	for(int i=0;i< E2[now].size();i++ )ans=max( ans,dfs(E2[now][i].to)+1 );
    return ans;
}

int main(){
	int t;
	cin>>t;
	for(int cas=1;cas<=t;cas++){
		scanf("%d%d",&n,&m);
		init();
		for(int i=0;i<m;i++){
			int x,y;
			scanf("%d%d",&x,&y);
			E[x].push_back( edge{y} );
			//E[y].push_back( edge{x} );
		}
		solve();
		for(int i=1;i<=n;i++){
			for(int j=0;j< E[i].size();j++ ){
				if( belong[i]!=belong[ E[i][j].to ] )
					E2[belong[i] ].push_back( edge{ belong[ E[i][j].to ]  } );
			}
		}
		int head=0;
		int flag=0;
		int cnt[maxn];
		memset(cnt,0,sizeof(cnt));
		for(int i=1;i<=Bcnt;i++){
            for(int j=0;j<E2[i].size();j++)
            cnt[ E2[i][j].to ]++;
		}
		for(int i=1;i<=Bcnt;i++){
            if( cnt[i]==0 ){flag++;head=i;}
		}

		if( flag==0||flag>=2 ){
            printf("Case %d: The Burning Shadow consume us all\n",cas);
            continue;
		}
		if( dfs( head )==Bcnt ){
            printf("Case %d: Kalimdor is just ahead\n",cas);
		}
		else{
            printf("Case %d: The Burning Shadow consume us all\n",cas);
		}

	}
	return 0;
}