Acwing. 最深的根、PAT. Deepest Root

系列文章目录

Acwing&LeetCode&PAT算法题解

---

---

关键词：树最深的根、并查集优化

题目:最深的根Acwing1498、PAT: Deepest Root

一个无环连通图可以被视作一个树。

树的高度取决于所选取的根节点。

现在，你要找到可以使得树的高度最大的根节点。

它被称为最深的根。

输入格式
第一行包含整数 N，表示节点数量。
节点编号为 1∼N。

接下来 N−1行，每行包含两个整数，表示两个节点之间存在一条边。

输出格式
输出最深的根的节点编号。
如果最深的根不唯一，则按照从小到大的顺序，将它们依次输出，每个占一行。

如果给定的图不是树，输出 Error: K components，其中 K
是图中连通分量的数量。

数据范围
1≤N≤1e4

输入样例1：

5
1 2
1 3
1 4
2 5

输出样例1：

3
4
5

输入样例2：

5
1 3
1 4
2 5
3 4

输出样例2：

Error: 2 components

一、算法思路

1.并查集判断连通块数目

1.题目要求当所给数据不是一个完整的连通块时要输出连通块数，这里用并查集求解。并查集的实现主要是find函数以及merge函数；两个函数都可以做优化，可以对find函数进行路径压缩，对merge函数做贪心处理，将高度较小的树挂在高度较大的树之下，此时就需要对父节点数组做特殊处理。（此题仅对find函数做路径压缩优化）

2.求最深的根（们）

1.寻找最深的根整体思路：暴搜肯定可以，但时间复杂度是O(n^2)，2s的时间上限会爆掉（实测用了3s多）；优化：任取一个节点作为根进行遍历(深搜广搜均可)，得到其最深的叶子节点，保存下来。再一 一对这些叶子节点进行如上操作，得到它们的最深叶子，将以上两组叶子合并、排序、再去重即为题目所求。如此时间复杂度是O（n），n为节点数目。
2.算法的合理性说明：算法一开始选定的根可以到达任一节点，其最深的叶节点可以通过它到达不同分支下的其他叶节点，而最深的根一定从两组不同分支下的叶节点之间产生。

二、代码

#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
using namespace std;

const int N = 1e4 + 10, M = 2 * N;
int n;
int e[M], ne[M], h[N], p[N], st[N], idx;
vector<int> most_deep;
vector<int>ans;
int cnt, max_depth = 0;

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

void add(int a, int b) {//数组模拟邻接表
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void dfs(int root, int depth) {
    st[root] = 1;//访问状态数组
    for (int i = h[root]; i != -1; i = ne[i]) {//深搜框架
        int j = e[i];
        if (!st[j]) {
            if (max_depth <= depth + 1) {//most_deep记录最深的叶子节点
                if (max_depth < depth + 1) most_deep.clear();
                most_deep.push_back(j);
                max_depth = depth + 1;
            }
            dfs(j, depth + 1);
        }
    }
}

int main() {
    cin >> n;
    cnt = n;
    memset(h, -1, sizeof h);//邻接表初始化
    //并查集父节点数组初始化（find路径压缩但merge不优化版）
    for (int i = 1; i <= n; i++)  p[i] = i;



    for (int i = 1; i < n; i++) {
        int a, b;
        cin >> a >> b;
        add(a, b);//无向图，边存两次
        add(b, a);
        int f1 = find(a), f2 = find(b);
        if (f1 != f2) {
            p[f2] = f1;
            cnt--;
        }
    }

    if (cnt > 1) {
        printf("Error: %d components", cnt);
        return 0;
    }

    most_deep.push_back(1);//树仅有一个根节点时添加该节点
    dfs(1, 0);//默认将1作为根，当然其他1~n范围之内的都可以
    ans = most_deep;
    vector<int>temp(most_deep);
    
    for (auto c : temp) {
        memset(st, 0, sizeof st);
        most_deep.clear();
        max_depth = 0;
        dfs(c, 0);
        ans.insert(ans.end(), most_deep.begin(), most_deep.end());
    }
    
    sort(ans.begin(), ans.end());
    //vector封装好的去重函数，需排序之后使用
    ans.erase(unique(ans.begin(), ans.end()), ans.end());
    
    for (auto c : ans) cout << c << endl;
    return 0;
}

---