ccf认证-201509-4

问题描述

　　某国有n个城市，为了使得城市间的交通更便利，该国国王打算在城市之间修一些高速公路，由于经费限制，国王打算第一阶段先在部分城市之间修一些单向的高速公路。
　　现在，大臣们帮国王拟了一个修高速公路的计划。看了计划后，国王发现，有些城市之间可以通过高速公路直接（不经过其他城市）或间接（经过一个或多个其他城市）到达，而有的却不能。如果城市A可以通过高速公路到达城市B，而且城市B也可以通过高速公路到达城市A，则这两个城市被称为便利城市对。
　　国王想知道，在大臣们给他的计划中，有多少个便利城市对。

输入格式

　　输入的第一行包含两个整数n, m，分别表示城市和单向高速公路的数量。
　　接下来m行，每行两个整数a, b，表示城市a有一条单向的高速公路连向城市b。

输出格式

　　输出一行，包含一个整数，表示便利城市对的数量。

样例输入

5 5
1 2
2 3
3 4
4 2
3 5

样例输出

3

样例说明

　　城市间的连接如图所示。有3个便利城市对，它们分别是(2, 3), (2, 4), (3, 4)，请注意(2, 3)和(3, 2)看成同一个便利城市对。

评测用例规模与约定

　　前30%的评测用例满足1 ≤ n ≤ 100, 1 ≤ m ≤ 1000；
　　前60%的评测用例满足1 ≤ n ≤ 1000, 1 ≤ m ≤ 10000；
　　所有评测用例满足1 ≤ n ≤ 10000, 1 ≤ m ≤ 100000。

我给出的答案，由于时间和空间都溢出导致错误

#include<iostream>
#include<time.h>
#include<string.h>
using namespace std;
struct  graph
{
	int e[10000][10000]; //此处占用了大量的空间，因为不是动态数组，所以不管实际用没用到也要开辟出这么大的空间
	int vNum;
	int eNum;
};
graph* createGraph(graph *g);
int findadj(graph *g);
void dfs(int k,int j,int **adjvis,graph *g,int vnum);


int main()
{   
    clock_t start,finish;
    double totaltime;
   
	int num;
	
	graph *g=new graph();
	start=clock();
	//g=(graph*)malloc(sizeof(graph));  
	g=createGraph(g);
	//cout<<g->vNum;
    finish=clock();
	num=findadj(g);
	cout<<num<<endl;
	
	//totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	//cout<<"\n此程序的运行时间为"<<totaltime<<"秒！"<<endl;  
	return 0;
}

int findadj(graph *g)
{
    
	int num=0;
	int vnum=g->vNum;
	
	int ** adjvis=new int *[vnum]; //动态声明二维数组 ,adjvis用作将每个点作为dfs的起点时的visit数组 
	for(int i=0;i<vnum;i++)
	{
		adjvis[i]=new int[vnum];
	 } 
   
//   int *adjvis=new int[vnum]; 
   
//	for(int i=0;i<vnum;i++)
//	{
//		for(int j=0;j<vnum;j++)
//		{
//			adjvis[i][j]=0;
//		 } 
//	  
//	} 
memset(adjvis,0,sizeof(adjvis));
//	for(int j=0;j<vnum;j++)
//    {
//	  adjvis[j]=0;
//	} 

	for(int i=0;i<vnum;i++)   //将每个点作为dfs的起点，找到该点所能到的所有点 ，
	{
		for(int j=0;j<vnum;j++)
		{
			if(adjvis[i][j]==0 && g->e[i][j]==1)
			{
				adjvis[i][j]=1;
				dfs(i,j,adjvis,g,vnum); 
			}

            
		}
		
	}
	
	for(int i=0;i<vnum;i++)
	{
		for(int j=0;j<vnum;j++)
		{   
		    
			if(adjvis[i][j]==1 && adjvis[j][i]==1 && i!=j)
			{
			   	//cout<<i<<j<<endl;
			    num++;
			}
		}
		
	}
	return num/2;
	
}
void dfs(int k,int j,int **adjvis,graph *g,int vnum)
{
	for(int m=0;m<vnum;m++)
		{
			if(adjvis[k][m]==0 && g->e[j][m]==1)
			{   
                
				adjvis[k][m]=1;
				dfs(k,m,adjvis,g,vnum); 
			}
			
		}
}

graph *createGraph(graph *g)
{
	int a,b;
	cin>>g->vNum>>g->eNum;
	
//	for(int i=0;i<g->vNum;i++)
//	{
//		for(int j=0;j<g->vNum;j++)
//		{
//			g->e[i][j]=0;
//		}
//	}
  //  memset(g->e,0,sizeof(g->e));   
	for(int i=0;i<g->eNum;i++)
	{
		cin>>a>>b;
	//	cin>>b;
		g->e[a-1][b-1]=1;
		//cout<<g->e[a-1][b-1]<<endl;
	}
	return g;
}

下面是标准答案：

#include<iostream>  
#include<cstdio>  
#include<cstring>  
#include<math.h>  
#include<vector>  
#include<queue>  
using namespace std;  
#define MAXN 10005  
vector<int> g[MAXN];     //使用vector动态数组而不是静态数组，节省了很多空间
vector<int> component[MAXN];  
int STACK[MAXN],TOP=0;  
bool instack[MAXN];  
int dfn[MAXN];  
int low[MAXN];  
int index=1;  
int cnt=0;  
void tarjan(int x){  
    dfn[x]=low[x]=index++;  
    instack[x]=true;  
    STACK[++TOP]=x;  
    int j;  
    for(int i=0;i<g[x].size();i++){     //每个节点都只遍历了一次，节省了时间
        j=g[x][i];  
        if(dfn[j]==-1){  
            tarjan(j);  
            low[x]=min(low[x],low[j]);  
        }  
        else if(instack[j]){  
            low[x]=min(low[x],dfn[j]);  
        }  
    }  
    if(dfn[x]==low[x]){  
            cnt++;  
            do{  
                j=STACK[TOP--];  
                instack[j]=false;  
                component[cnt].push_back(j);  
            }while(x!=j);  
    }  
}  
int main(){  
    int n,m,x,y;  
    int ans=0;  
    cin>>n>>m;  
    memset(dfn,-1,sizeof(dfn));  //使用memset而不是循环初始化，节省了时间
    memset(low,-1,sizeof(low));  
    memset(instack,0,sizeof(instack));  
    memset(STACK,-1,sizeof(STACK));  
    for(int i=1;i<=m;i++){  
        cin>>x>>y;  
        g[x].push_back(y);  
    }  
    for(int i=1;i<=n;i++){  
        if(dfn[i]==-1) tarjan(i);  
    }  
    //cout<<cnt<<endl;  
    for(int i=1;i<=cnt;i++){  
        vector<int> vec=component[i];  
        int sz=vec.size();  
        //cout<<sz<<endl;  
        if(sz==1) continue;  
        else ans+=sz*(sz-1)/2;  
    }  
    cout<<ans<<endl;  
    return 0;  
}