LeetCode 310. 最小高度树题解

310. 最小高度树

题目来源：310. 最小高度树

2022.04.06 每日一题

LeetCode 题解持续更新中GitHub仓库地址 CSDN博客地址

今天的题目就和树有关

我们可以使用BFS和DFS来进行求解，将每个节点都当作一个根节点进行树的构建，然后统计树的最小深度，即可得到最后的答案

设$ \textit{dist}[x][y]$ 表示从节点 x到节点 y 的距离，假设树中距离最长的两个节点为 (x,y)，它们之间的距离为$ \textit{minheight} = ceil(\textit{maxdist/2})$，且最小高度的树根节点一定在 节点 x 到节点 y 的路径上。

class Solution {
public:
    vector<int> findMinHeightTrees(int n, vector<vector<int>> &edges) {
        vector<int> ans;
        if (n == 1) {
            // 如果只有一个节点，那么最短的就是 0
            ans.push_back(0);
            return ans;
        }
        // 创建一个二维数组统计相通的节点
        vector<vector<int>> adj;

        // 统计无向图的各个节点
        for (vector<int> &edge: edges) {
            adj[edge[0]].push_back(edge[1]);
            adj[edge[1]].push_back(edge[0]);
        }

        // 创建一个数组，统计节点的父节点
        // 将初始值默认赋为 -1
        vector<int> parent(n, -1);
        // 找到与节点 0 最远的节点 x 
        int x = bfs(0, parent, adj);
        // 找到与节点 x 最远的节点 y 
        int y = bfs(x, parent, adj);
        // 求出节点 x 到节点 y 的路径 
        vector<int> path;
        // 将当前父节点置为 -1，令其查找路径截止
        parent[x] = -1;
        while (y != -1) {
            path.push_back(y);
            y = parent[y];
        }
        int m = path.size();
        if (m % 2 == 0) {
            ans.push_back(path[m / 2 - 1]);
        }
        ans.push_back(path[m / 2]);
        return ans;
    }

    // 使用 BFS 对树进行搜索
    int bfs(int u, vector<int> &parent, vector<vector<int>> &adj) {
        int n = adj.size();
        queue<int> qu;
        // 创建布尔数组，判断相应的节点是否已经访问过了
        vector<bool> visit(n);
        qu.push(u);
        visit[u] = true;
        int node = -1;

        while (!qu.empty()) {
            int curr = qu.front();
            qu.pop();
            node = curr;
            for (int v: adj[curr]) {
                if (!visit[v]) {
                    visit[v] = true;
                    parent[v] = curr;
                    qu.push(v);
                }
            }
        }
        return node;
    }
};

class Solution {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer> ans = new ArrayList<>();
        if (n == 1) {
            // 如果只有一个节点，那么最短的就是 0
            ans.add(0);
            return ans;
        }
        // 创建一个二维数组统计相通的节点
        List<Integer>[] adj = new List[n];
        for (int i = 0; i < n; i++)
            adj[i] = new ArrayList<>();

        // 统计无向图的各个节点
        for (int[] edge : edges) {
            adj[edge[0]].add(edge[1]);
            adj[edge[1]].add(edge[0]);
        }

        // 创建一个数组，统计节点的父节点
        int[] parent = new int[n];
        // 将初始值默认赋为 -1
        Arrays.fill(parent, -1);
        // 找到与节点 0 最远的节点 x 
        int x = bfs(0, parent, adj);
        // 找到与节点 x 最远的节点 y 
        int y = bfs(x, parent, adj);
        // 求出节点 x 到节点 y 的路径 
        List<Integer> path = new ArrayList<>();
        // 将当前父节点置为 -1，令其查找路径截止
        parent[x] = -1;
        while (y != -1) {
            path.add(y);
            y = parent[y];
        }
        int m = path.size();
        if (m % 2 == 0) {
            ans.add(path.get(m / 2 - 1));
        }
        ans.add(path.get(m / 2));
        return ans;
    }

    // 使用 BFS 对树进行搜索
    public int bfs(int u, int[] parent, List<Integer>[] adj) {
        int n = adj.length;
        Queue<Integer> queue = new ArrayDeque<>();
        // 创建布尔数组，判断相应的节点是否已经访问过了
        boolean[] visit = new boolean[n];
        queue.offer(u);
        visit[u] = true;
        int node = -1;

        while (!queue.isEmpty()) {
            int curr = queue.poll();
            node = curr;
            for (int v : adj[curr]) {
                if (!visit[v]) {
                    visit[v] = true;
                    parent[v] = curr;
                    queue.offer(v);
                }
            }
        }
        return node;
    }
}