Kosaraju模板题——班长竞选

问题描述

大学班级选班长，N 个同学均可以发表意见 若意见为 A B 则表示 A 认为 B 合适，意见具有传递性，即 A 认为 B 合适，B 认为 C 合适，则 A 也认为 C 合适 勤劳的 TT 收集了M条意见，想要知道最高票数，并给出一份候选人名单，即所有得票最多的同学，你能帮帮他吗？
【输入】
本题有多组数据。第一行 T 表示数据组数。每组数据开始有两个整数 N 和 M (2 <= n <= 5000, 0 【输出】
对于每组数据，第一行输出 “Case x: ”，x 表示数据的编号，从1开始，紧跟着是最高的票数。 接下来一行输出得票最多的同学的编号，用空格隔开，不忽略行末空格！
【样例输入】
2
4 3
3 2
2 0
2 1

3 3
1 0
2 1
0 2
【样例输出】
Case 1: 2
0 1
Case 2: 2
0 1 2

问题分析

关于SCC
SCC是强连通分量，极大的强连通子图，强连通即为有向图G中任意两个结点连通的图

关于DFS序
前序：第一次达到点x的次序，用d【x】表示
后序：x点遍历完成的次序，即回溯时间，用f【x】表示

关于Kosaraju
解决问题：找到有向图中所有的SCC
方法：1、第一遍dfs确定原图的逆后序序列
2、第二遍dfs在反图中按照逆后序序列进行遍历，每次由起点遍历到的点即构成一个SCC

关于本题
1、对于同学投票，考虑求出SCC并缩点，即将互相可达与单向可达分开考虑
2、缩点后，对于第i个SCC的点来说，答案分为两部分，令SCC【i】表示第i个SCC中点的个数，那么第一部分为当前SCC中的点，ans+=SCC【i】-1（去除自己），其他SCC中的点，sum（SCC【j】），其中j可到达i
3、答案一定出现在出度为0的SCC中，因此将边反向，对每个入度为0的点进行dfs，计算其能到达的点SUM（SCC【j】）

#include
#include
#include
#include 
using namespace std;

int c[5010],dfn[5010],vis[5010],dcnt=0,scnt=0,num[5010];
//dcnt dfs序计数，scnt scc序计数
//dfn[i]-dfs后序列中第i个点
//c[i] i号点所在SCC编号
struct edge
{
	int u,v,nxt;
}e1[30010],e2[30010],e[30010];//e表示缩点后的图 

int head1[5010],head2[5010],head[5010],sum[5010],tot1=1,tot2=1,tot=1;
int N,M;
void addEdge(int u,int v)
{
	e1[tot1].u=u;
	e1[tot1].v=v;
	e1[tot1].nxt=head1[u];
	head1[u]=tot1;
	tot1++;
	
	e2[tot2].u=v;
	e2[tot2].v=u;
	e2[tot2].nxt=head2[v];
	head2[v]=tot2;
	tot2++;
}

int out[5010];//每个点的出度 

void adds(int u,int v)//缩点后的图 
{
	e[tot].u=u;
	e[tot].v=v;
	e[tot].nxt=head[u];
	head[u]=tot;
	tot++;
} 

void dfs1(int x)
{
	vis[x]=1;
	for(int i=head1[x];i!=-1;i=e1[i].nxt)
		if(!vis[e1[i].v]) 
			dfs1(e1[i].v);
	dfn[++dcnt]=x;
}

void dfs2(int x)
{
	c[x]=scnt;
	num[scnt]++;
	for(int i=head2[x]; i!=-1; i=e2[i].nxt)
		if(!c[e2[i].v]) //已经被标记过的就不会再走 
			dfs2(e2[i].v);
} 

int xsum;
void dfs(int x)//计算得票数 
{
	vis[x]=1;
	xsum+=num[x];
	for(int i=head[x];i!=-1;i=e[i].nxt)
	{
		if(!vis[e[i].v])
			dfs(e[i].v);
	}
}

void kosaraju()//找到有向图中所有的SCC 
{//初始化 
	dcnt=scnt=0;
	memset(c,0,sizeof(c));
	memset(vis,0,sizeof(vis));
	//第一遍dfs,求得后序序列 
	for(int i=1;i<=N;i++)
		if(!vis[i]) 
			dfs1(i);
	//第二遍dfs在反图中按逆后序序列进行遍历		
	for(int i=N;i>=1;i--)
		if(!c[dfn[i]])
		{
			++scnt;
			dfs2(dfn[i]);
		}	 
}
 
int main()
{
	int T;
	cin>>T;
	for(int i=1;i<=T;i++)
	{
		memset(head1,-1,sizeof(head1));
		memset(head2,-1,sizeof(head2));
		memset(head,-1,sizeof(head));
	    memset(out,0,sizeof(out));
	    memset(num,0,sizeof(num));
	    memset(vis,0,sizeof(vis));
	    memset(sum,0,sizeof(sum));
	    memset(c,0,sizeof(c));
	    tot1=tot2=tot=1;
		scanf("%d %d",&N,&M);
		for(int j=1;j<=M;j++)
		{
			int A,B;
			scanf("%d %d",&A,&B);
			addEdge(A+1,B+1);
		}
		kosaraju();
		for(int k=1;k<=N;k++)
		{
			for(int j=head1[k];j!=-1;j=e1[j].nxt)//j！=-1是报错点！！！！ 
			{
				if(c[k]!=c[e1[j].v])
				{
					adds(c[e1[j].v],c[k]);
					out[c[k]]++;//出度 
				}
			}
		}
		int mmax=0;
		for(int j=1;j<=scnt;j++)
		{
			if(out[j]==0)
			{
				xsum=0;
				memset(vis,0,sizeof(vis));
				dfs(j);
				sum[j]=xsum;
				mmax=max(mmax,sum[j]);
			}
		} 
	    cout<<"Case "<<i<<": "<<mmax-1<<endl;
	    int flag=0; 
	    for(int j=1;j<=N;j++)
		{
			if(sum[c[j]]==mmax)
			{
				if(flag==0)
				{ 
					cout<<j-1; 
				  	flag=1;
				}
				else cout<<" "<<j-1; 
			}
		}
		cout<<endl; 
	}
}