甲级PAT 1021 Deepest Root(dfs+二维vector)

1021 Deepest Root （25 分）

A graph which is connected and acyclic can be considered a tree. The hight of the tree depends on the selected root. Now you are supposed to find the root that results in a highest tree. Such a root is called the deepest root.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤10​4​​) which is the number of nodes, and hence the nodes are numbered from 1 to N. Then N−1 lines follow, each describes an edge by given the two adjacent nodes' numbers.

Output Specification:

For each test case, print each of the deepest roots in a line. If such a root is not unique, print them in increasing order of their numbers. In case that the given graph is not a tree, print Error: K components where K is the number of connected components in the graph.

Sample Input 1:

5
1 2
1 3
1 4
2 5

Sample Output 1:

3
4
5

Sample Input 2:

5
1 3
1 4
2 5
3 4

Sample Output 2:

Error: 2 components

 题目要求：

给出N个结点以及N-1条边，能否构成一个树。如果不能构成则输出它有的连通分量个数，如果能构成一棵树，输出能构成最深的树的高度时，树的根结点。如果有多个，按照从小到大输出。

解题思路：

高时间复杂度版（自己的）：

题目给出N-1条边就排除了一棵树有环路且连通分量为1的情况，因为这样边一定是大于N-1的。所以有环必有多个连通分量。判断连通分量可利用dfs，每执行一次dfs意味着多一个连通分量。判断是否等于1即可。如果等于1则进行之后dfs遍历所有结点找到能构成最深树的高度时树的根结点，利用vector存储满足条件的根结点。

低时间复杂度版（大神的）：

大体思路一样，但对于判断连通分量后找能构成最深树的高度时树的根结点做了优化。对于只有一个连通分量的图，进行两次深度优先搜索，先从一个结点dfs后保留最高高度拥有的结点们，然后从这些结点中的其中任意一个开始dfs得到最高高度的结点们，这两个结点集合的并集就是所求。利用set插入可实现集合合并且有序。

自己画了一下，确实是这样。从任一结点开始dfs，当前遍历具有最高高度的结点们，如果在当前根的左子树，那么用它做根结点dfs遍历时相当于左子树的高度加上右子树的高度，反之，亦然。对于所有的具有最高高度的结点们，就是构成最深树的高度的根结点。

考虑到像一个树，对当前根，左子树高，比如6层，而右子树低，比如2层。以左子树6层中的任一的结点去dfs遍历得到的最深的高度结点一定是右子树第二层的结点。所以进行2次dfs就可以找到所有的满足要求的根结点。

注意：

1.不能用二维数组存储边的连接关系。因为10^4开个二维数组，空间直接炸了，这里直接用二维vector存储边的邻接关系。二维vector<vector<int> > edge;一定要记得>>直接要有空格

遍历时只需要遍历vector[i]里面对应的元素。还要记得在输入N后对vector进行resize，分配大小，否则输入过程中出错。

2.无向图对于输入一个连接关系其实是两个连接关系。edge[m].push_back(n);edge[n].push_back(m);

完整代码：

高时间复杂度版：

#include<bits/stdc++.h>
using namespace std;
#define max 10002

vector<vector<int> > edge; 
int N;
int visited[max];
int mlen = 0;
vector<int> v;

void dfs(int x,int len){
	if(mlen < len) mlen = len;
	visited[x] = 1;
	for(int i = 0; i < edge[x].size(); i++){
		if(visited[edge[x][i]]==0){
			dfs(edge[x][i],len+1);
		}
	}
}

int main(){
	int i,m,n,compartment = 0;
	int maxlen = 0;
	cin>>N;
	edge.resize(N+1);
	memset(visited,0,sizeof(visited));
	for(i=1;i<=N-1;i++){
		scanf("%d %d",&m,&n);
		edge[m].push_back(n);
		edge[n].push_back(m);
	}
	for(i=1;i<=N;i++){
		if(visited[i] == 0){
			dfs(i,1);
			maxlen = mlen;
			compartment++;
			v.push_back(i);
		}
	}
	if(compartment == 1){
		for(i=2;i<=N;i++){
			memset(visited,0,sizeof(visited));
			mlen = 0;
			dfs(i,1);
			if(mlen > maxlen){
				v.clear();
				maxlen = mlen;
				v.push_back(i);
			}else if(mlen == maxlen) v.push_back(i);
		}
		for(i=0;i<=v.size()-1;i++){
			printf("%d\n",v[i]);
		}
	}else{
		printf("Error: %d components",compartment);
	}
	
	return 0;
}

低时间复杂度版：

#include<bits/stdc++.h>
using namespace std;
#define max 10002

vector<vector<int> > edge; 
int visited[max];
int maxlen = 0;
vector<int> v;
set<int> s; 

void dfs(int x,int len){
	if(len > maxlen){
		v.clear();
		maxlen = len;
		v.push_back(x);
	}else if(len == maxlen) v.push_back(x);
	visited[x] = 1;
	for(int i = 0; i < edge[x].size(); i++){
		if(visited[edge[x][i]]==0){
			dfs(edge[x][i],len+1);
		}
	}
}

int main(){
	int i,m,N,n,compartment = 0;
	cin>>N;
	edge.resize(N+1);
	memset(visited,0,sizeof(visited));
	for(i=1;i<=N-1;i++){
		scanf("%d %d",&m,&n);
		edge[m].push_back(n);
		edge[n].push_back(m);
	}
	for(i=1;i<=N;i++){
		if(visited[i] == 0){
			dfs(i,1);
			compartment++;
		}
	}
	if(compartment == 1){
		for(i=0;i<v.size();i++){
			s.insert(v[i]);
		}
		int temp = v[0];
		memset(visited,0,sizeof(visited));
		dfs(temp,1);
		for(i=0;i<v.size();i++){
			s.insert(v[i]);
		}
		set<int>::iterator it;
		for(it = s.begin();it!=s.end();it++){
			printf("%d\n",*it);
		}
	}else{
		printf("Error: %d components",compartment);
	}
	return 0;
}

高时间复杂度差不多560ms，低时间复杂度差不多6,7s，因为dfs次数明显少了很多。

小笔记：
1.vector

2.set