1021 Deepest Root（25分）

题目翻译：

给出一个数n代表节点的个数（节点编号1-n），给出各个边的连接方式，问哪个节点为根节点时，这棵树最高，如果有多个这样的结点，则按升序的方式输出。如果给出的图不是一棵树，那么输出它有几个部分组成。

题解思路：

先用dfs或者并查集查找独立子图个数，若为1则进行下一步dfs查找将每个结点都作为根时树的深度。

也可以参考

代码：

#include<bits/stdc++.h>
using namespace std;
int N;
vector<int> v[10001];
int visited[10001], deepth[10001];

void dfs1(int curnode)
{
	visited[curnode] = 1;
	for (int i : v[curnode])
	{
		if (visited[i] == 0)
			dfs1(i);
	}
}

void dfs2(int curnode, int count1, int goalnode)
{
	visited[curnode] = 1;
	for (int i : v[curnode])
	{
		if (visited[i] == 0)
		{
			int newCount = count1 + 1;
			if (newCount > deepth[goalnode])
			{
				deepth[goalnode] = newCount;
			}
			dfs2(i, newCount, goalnode);
		}
	}
}

int main()
{
	cin >> N;
	int j, k, Independent_map=0;
	visited[1] = deepth[1] = 0;
	for (int i = 2;i <= N;i++)
	{
		cin >> j >> k;
		v[j].push_back(k);
		v[k].push_back(j);
		visited[i] = 0;
		deepth[i] = 0;
	}
	for (int i = 1;i <= N;i++)
	{
		if (visited[i] == 0)
		{
			Independent_map++;
			dfs1(i);
		}
	}
	if (Independent_map > 1)
	{
		cout << "Error: " << Independent_map << " components";
		return 0;
	}
	else
	{
		memset(visited, 0, sizeof(visited));
		for (int i = 1;i <= N;i++)
		{
			dfs2(i, 1, i);
			memset(visited, 0, sizeof(visited));
		}
		int max_deepth = *max_element(deepth + 1, deepth + N + 1);
		vector<int> set_deepth;
		for (int i = 1;i <= N;i++)
		{
			if (deepth[i] == max_deepth)
				set_deepth.push_back(i);
		}
		sort(set_deepth.begin(), set_deepth.end());
		for (int i = 0;i < set_deepth.size();i++)
			cout << set_deepth[i] << endl;
	}
}

也可以参考柳神的代码：

#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
int n, maxheight = 0;
vector<vector<int>> v;
bool visit[10010];
set<int> s;
vector<int> temp;
void dfs(int node, int height) {
    if(height > maxheight) {
        temp.clear();
        temp.push_back(node);
        maxheight = height;
    } else if(height == maxheight){
        temp.push_back(node);
    }
    visit[node] = true;
    for(int i = 0; i < v[node].size(); i++) {
        if(visit[v[node][i]] == false)
            dfs(v[node][i], height + 1);
    }
}
int main() {
    scanf("%d", &n);
    v.resize(n + 1);
    int a, b, cnt = 0, s1 = 0;
    for(int i = 0; i < n - 1; i++) {
        scanf("%d%d", &a, &b);
        v[a].push_back(b);
        v[b].push_back(a);
    }
    for(int i = 1; i <= n; i++) {
        if(visit[i] == false) {
            dfs(i, 1);
            if(i == 1) {
                if (temp.size() != 0) s1 = temp[0];
                for(int j = 0; j < temp.size(); j++)
                    s.insert(temp[j]);
            }
            cnt++;
        }
    }
    if(cnt >= 2) {
        printf("Error: %d components", cnt);
    } else {
        temp.clear();
        maxheight = 0;
        fill(visit, visit + 10010, false);
        dfs(s1, 1);
        for(int i = 0; i < temp.size(); i++)
            s.insert(temp[i]);
        for(auto it = s.begin(); it != s.end(); it++)
            printf("%d\n", *it);
    }
    return 0;
}

坑点：

注意测试点1是输入为1的情况，输出应当为1

二刷：

#include<bits/stdc++.h>
using namespace std;
using PII = pair<int, int>;
const int N = 1e4 + 10;
vector<int> v[N];//邻接表
int vis[N];//某个结点是否访问过

bool cmp(PII v1, PII v2)
{
	if (v1.first > v2.first || (v1.first == v2.first && v1.second < v2.second)) return true;
	else return false;
}

set<PII, bool (*)(PII, PII)> res(cmp);//存储最终的结果<深度，根结点>
int p[N];//父亲结点，用于并查集
int du[N];//每个结点的度
vector<int> leaf;//叶子结点
vector<PII> edge;
int n;
int max_depth = 1;

int find(int x) {
	if (x != p[x]) p[x] = find(p[x]);
	return p[x];
}

void dfs(int curdepth, int curnode) {
	if (curdepth > max_depth) max_depth = curdepth;
	vis[curnode] = 1;
	for (auto i : v[curnode]) {
		if (!vis[i])
			dfs(curdepth + 1, i);
	}
}

int main(){
	cin >> n;
	if (n == 1) {
		cout << 1;
		return 0;
	}
	for (int i = 0;i < n - 1;i++) {
		int a, b;
		cin >> a >> b;
		v[a].push_back(b);
		v[b].push_back(a);
		edge.push_back({ a,b });
		du[a]++;
		du[b]++;
	}
	for (int i = 1;i <= n;i++)
		if (du[i] == 1) leaf.push_back(i);
	for (int i = 1;i <= n;i++) p[i] = i;
	int num = n;
	for (auto i : edge) {
		int a = i.first, b = i.second;
		int pa = find(a), pb = find(b);
		if (pa != pb) {
			p[pa] = pb;
			num--;
		}
	}
	if (num >= 2) {
		cout << "Error: " << num << " components";
		return 0;
	}
	for (auto i : leaf) {
		memset(vis, 0, sizeof(vis));
		max_depth = 1;
		dfs(1, i);
		res.insert({ max_depth,i });
	}
	int last = res.begin()->first;
	for (auto i : res) {
		if (i.first == last) cout << i.second << endl;
	}
}