【PAT甲级题解记录】1021 Deepest Root (25 分)

【PAT甲级题解记录】1021 Deepest Root (25 分)

前言

Problem：1021 Deepest Root (25 分)

Tags：DFS 并查集(可用可不用)

Difficulty：剧情模式 想流点汗 想流点血 死而无憾

Address：1021 Deepest Root (25 分)

问题描述

求一个N个点N-1条边的图是否能构成二叉树，能的话输出能形成最大深度的根结点，不能的话输出联通分支数。

解题思路

• 一开始还以为要分别看回路和联通分支，但这道题给的数据N点N-1条边保证了这两种情况只会同时出现，那就简单很多了，直接暴力就可以过题。
• 算法流程很简单，先通过DFS算出联通分支数，如果大于1则输出报错否则以每一个点为根进行DFS最大深度，在这个过程中可以利用对vector的更新维护答案的集合（如参考代码），也可以最后求出深度后再遍历一遍。
• 当然涉及回路和连通分量数量的我们也可以考虑加入并查集

参考代码

1. DFS

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;
int N; // 1e4, node : 1-1N
vector<vector<int>> tree;
vector<int> visited;

void init() {
    cin >> N;
    tree.resize(N + 1); // 1-N
    visited.resize(N + 1, 0);
    for (int i = 0; i < N - 1; ++i) {
        int a, b;
        cin >> a >> b;
        tree[a].push_back(b);
        tree[b].push_back(a);
    }

}

int dfs_depth(int root, int depth) {
    visited[root] = 1;
    int max_depth = depth;
    for (int i = 0; i < int(tree[root].size()); ++i) {
        int next_node = tree[root][i];
        if (visited[next_node] == 0) {
            max_depth = max(max_depth, dfs_depth(next_node, depth + 1));
        }
    }
    return max_depth;
}

void solution_1021() {
    init();
    int cnt = 0;
    for (int i = 1; i <= N; ++i) {
        if (visited[i] == 0) {
            dfs_depth(i, 0);
            cnt++;
        }
    }
    if (cnt > 1) {
        cout << "Error: " << cnt << " components" << endl;
        return;
    }

    vector<int> ans;
    int max_depth = 0;
    for (int i = 1; i <= N; i++) {
        visited.clear(); // 注意要先clear再利用resize初始化，否则原有的元素数值会保持不变
        visited.resize(N + 1, 0);
        int depth = dfs_depth(i, 0);
//        cout << i << ":" << depth << endl;
        if (depth > max_depth) {
            max_depth = depth;
            ans.clear();
            ans.push_back(i);
        } else if (depth == max_depth) {
            ans.push_back(i);
        }
    }
    sort(ans.begin(), ans.end());
    for (int i = 0; i < int(ans.size()); ++i) {
        cout << ans[i] << endl;
    }
}
int main() {
    solution_1021();
    return 0;
}

2. DFS+并查集

/*
 * @Author: Retr0.Wu 
 * @Date: 2022-02-18 22:35:27 
 * @Last Modified by: Retr0.Wu
 * @Last Modified time: 2022-02-18 22:48:13
 */
#include <bits/stdc++.h>
using namespace std;
int N; // 1e4
vector<int> sets(10010);
vector<int> edge[10010];
vector<int> ans;
void init_sets()
{
    for (int i = 1; i <= N; i++)
    {
        sets[i] = i;
    }
}
int find(int x)
{
    if (sets[x] == x)
    {
        return x;
    }
    int ans = find(sets[x]);
    sets[x] = ans;
    return ans;
}
vector<int> visit(10010, 0);
int dfs(int x, int depth)
{
    int maxx = 0;
    for (int i = 0; i < edge[x].size(); i++)
    {
        if (visit[edge[x][i]] == 0)
        {
            visit[edge[x][i]] = 1;
            maxx = max(maxx, dfs(edge[x][i], depth + 1));
            visit[edge[x][i]] = 0;
        }
    }
    if(maxx == 0){
        return depth;
    }
    return maxx;
}
int main()
{
    cin >> N;
    init_sets();
    int flag = 1;
    for (int i = 1; i < N; i++)
    {
        int v1, v2;
        cin >> v1 >> v2;
        int v1_root = find(v1);
        int v2_root = find(v2);
        //cout << v1_root << " " << v2_root << endl;
        if (v1_root == v2_root)
        {
            flag = 0;
        }
        else
        {
            sets[v2_root] = v1_root;  // 注意并入的是根结点不是当前结点
        }
        edge[v1].push_back(v2);
        edge[v2].push_back(v1);
    }
    int cnt = 0;
    map<int, int> exist;
    for (int i = 1; i <= N; i++)
    {
        exist[find(i)] = 1;
    }
    cnt = exist.size();
    // if (!flag || cnt > 1)  // flag判断闭环，cnt判断联通分支
    if (cnt > 1)  // 这题中这俩种情况必定同时出现所以只需要判断是否有多个联通分支
    {
        printf("Error: %d components\n", cnt);
    }
    else
    {
        int max_depth = 0;
        for (int i = 1; i <= N; i++)
        {
            visit[i] = 1;
            int len = dfs(i, 1);
            visit[i] = 0;
            if (len > max_depth)
            {
                ans.clear();
                ans.push_back(i);
                max_depth = len;
            }
            else if (len == max_depth)
            {
                ans.push_back(i);
            }
        }
        sort(ans.begin(), ans.end());
        for (int i = 0; i < ans.size(); i++)
        {
            cout << ans[i] << endl;
        }
    }

    return 0;
}

总结

关于Vector.resize(sz,x)的误区：这题在初始化vector的时候我发现了bug，原因就是resize并不会对vector原有的数据进行更改，扩容后多出来数据才会初始化为x，震惊了以前一直不知道。具体的可以参考这篇文章vector中resize() 用法排坑。