1004. 有向图边的分类

题目

Time Limit: 1sec Memory Limit:256MB
Description
输入一个有向图，从顶点1开始做dfs对边进行分类。

Input
输入的第一行包含两个整数n和m，n是图的顶点数，m是边数。1<=n<=100，0<=m<=10000。

接下来的m行，每行是一个数对u v，表示存在有向边(u,v)。顶点编号从1开始。

接下来的1行，包含一个整数k，表示会查询k条边的类型。

接下来的k行，每行是一个数对u v，表示查询边u v的类型。

Output
对每条查询的边，单独一行输出边的类型，参见输出样例。

Sample Input Copy
4 6
1 2
2 3
3 1
1 3
1 4
4 2
4
1 2
3 1
1 3
4 2
Sample Output Copy
edge (1,2) is Tree Edge
edge (3,1) is Back Edge
edge (1,3) is Down Edge
edge (4,2) is Cross Edge
Problem Source: 刘晓铭

学习

学到了很多：https://blog.csdn.net/LoHiauFung/article/details/53352307
逻辑思想，见上行博客的【说明图】，算法由逻辑图而来，然后转化为代码
【伪代码】1)i没有被访问过，kind[0]
1)i被访问过 2)它不是所有的子孙都被访问过，kind[1]
2)它所有子孙都被访问过 3)v不是初始值 ，kind[2]
3)v是初始值， kind[3]

code

#include 
#include //memset
//#include 
//#include 

using namespace std;
bool matrix[101][101];//edge // 顶点序号从1开始，所以所有的数组0都设定无效 
bool isvisited[101]; 
int edgeKind[101][101];//the king of edge 
int vers, edges;

void DFS(int v);
bool isAllSpringVisited(int v);
bool isSource(int u, int v);
 
int main()
{
	cin >> vers >> edges;
	memset(matrix, false, 101 * 101 * sizeof(bool));
	memset(isvisited, false, 101 * sizeof(bool));
	memset(edgeKind, -1, (vers + 1) * (vers + 1) * sizeof(int));//vers + 1 
	
	int a, b;
	for(int i = 0; i < edges; ++i)
	{
		cin >> a >> b;
		matrix[a][b] = true;
	}
	
	isvisited[1] = true;//from 1
	DFS(1);
	
	int test;
	cin >> test;
	string kind[4] = {"Tree Edge", "Back Edge", "Cross Edge", "Down Edge"};
	while(test--)
	{
		cin >> a >> b;
		cout << "edge (" << a << "," << b << ") is " << kind[edgeKind[a][b]] << endl;
	}
	
	return 0;
}

void DFS(int v)
{
	for(int i = 1; i <= vers; ++i)
	{
		//edge exits
		if(matrix[v][i])
		{
			//node not visited. tree edge & DFS(i)
			if(!isvisited[i])
			{
				isvisited[i] = 1;
				edgeKind[v][i] = 0;
				DFS(i);
			}
			//node is visited
			else
			{
				//not all spring is visited
				if(!isAllSpringVisited(i))
				{
					edgeKind[v][i] = 1;
				}
				//all spring is visited
				else
				{
					//v is not the initial edge of i
					if(!isSource(v, i))
					{
						edgeKind[v][i] = 2;
					}
					//v is initial
					else
					{
						edgeKind[v][i] = 3;
					}
				}
			}
		}
	}
}
bool isAllSpringVisited(int v)
{
	for(int i = 1; i <= vers; ++i)
	{
		if(matrix[v][i] && (!isvisited[i]))
			return false;
	}
	
	return true;//!!!!!!
}
bool isSource(int u, int v)
{
	return 1 == u;
}