Medium

题目描述

公司里有 n 名员工，每个员工的 ID 都是独一无二的，编号从 0 到 n - 1。公司的总负责人通过 headID 进行标识。

在 manager 数组中，每个员工都有一个直属负责人，其中 manager[i] 是第 i 名员工的直属负责人。对于总负责人，manager[headID] = -1。题目保证从属关系可以用树结构来表示。

公司总负责人想要向公司所有员工通告一条紧急消息。他将会首先通知他的直属下属们，然后由这些下属通知他们的下属，依次类推，直到所有的员工都得知这条紧急消息。

第 i 名员工需要 informTime[i] 分钟来通知它的所有直属下属（也就是说在 informTime[i] 分钟后，他的所有直属下属都可以开始传播这一消息）。

返回通知所有员工这一紧急消息所需要的 分钟数。

示例 1：

输入：n = 1, headID = 0, manager = [-1], informTime = [0]
输出：0
解释：公司总负责人是公司的唯一一名员工。

示例 2：

输入：n = 6, headID = 2, manager = [2,2,-1,2,2,2], informTime = [0,0,1,0,0,0]
输出：1
解释：id = 2 的员工是公司的总负责人，也是其他所有员工的直属负责人，他需要 1 分钟的时间来通知所有员工。

提示：

  • 1 <= n <= 10^5
  • 0 <= headID < n
  • manager.length == n
  • 0 <= manager[i] < n
  • manager[headID] == -1
  • informTime.length == n
  • 0 <= informTime[i] <= 1000
  • 如果员工 i 没有下属，informTime[i] == 0。
  • 题目保证所有员工都可以被通知到。

解题思路

这是一个典型的树形结构问题。公司的组织架构形成一棵树，总负责人是根节点，需要计算从根节点传播消息到所有叶子节点的最长时间。

解法一：深度优先搜索（DFS） 首先构建从管理者到下属的邻接表，然后从根节点开始深度优先遍历。对于每个节点，递归计算其所有子树的最大传播时间，再加上当前节点的通知时间。

解法二：自底向上计算 从每个叶子节点出发，向上累计到根节点的时间。但这种方法需要多次遍历，效率较低。

推荐解法一，时间复杂度更优，代码更简洁。关键思路是：

  1. 构建邻接表表示管理关系
  2. 从根节点开始DFS遍历
  3. 对于每个管理者，计算通知所有下属的最大时间
  4. 答案是所有路径中的最大值

代码实现

class Solution {
public:
    int numOfMinutes(int n, int headID, vector<int>& manager, vector<int>& informTime) {
        vector<vector<int>> children(n);
        
        // 构建从管理者到下属的邻接表
        for (int i = 0; i < n; i++) {
            if (manager[i] != -1) {
                children[manager[i]].push_back(i);
            }
        }
        
        return dfs(headID, children, informTime);
    }
    
private:
    int dfs(int employee, vector<vector<int>>& children, vector<int>& informTime) {
        int maxTime = 0;
        
        // 遍历所有直属下属
        for (int child : children[employee]) {
            maxTime = max(maxTime, dfs(child, children, informTime));
        }
        
        // 当前员工的通知时间 + 下属中最长的传播时间
        return informTime[employee] + maxTime;
    }
};

class Solution:
    def numOfMinutes(self, n: int, headID: int, manager: List[int], informTime: List[int]) -> int:
        from collections import defaultdict
        
        # 构建从管理者到下属的邻接表
        children = defaultdict(list)
        for i in range(n):
            if manager[i] != -1:
                children[manager[i]].append(i)
        
        def dfs(employee):
            max_time = 0
            
            # 遍历所有直属下属
            for child in children[employee]:
                max_time = max(max_time, dfs(child))
            
            # 当前员工的通知时间 + 下属中最长的传播时间
            return informTime[employee] + max_time
        
        return dfs(headID)

public class Solution {
    public int NumOfMinutes(int n, int headID, int[] manager, int[] informTime) {
        List<List<int>> children = new List<List<int>>();
        
        // 初始化邻接表
        for (int i = 0; i < n; i++) {
            children.Add(new List<int>());
        }
        
        // 构建从管理者到下属的邻接表
        for (int i = 0; i < n; i++) {
            if (manager[i] != -1) {
                children[manager[i]].Add(i);
            }
        }
        
        return DFS(headID, children, informTime);
    }
    
    private int DFS(int employee, List<List<int>> children, int[] informTime) {
        int maxTime = 0;
        
        // 遍历所有直属下属
        foreach (int child in children[employee]) {
            maxTime = Math.Max(maxTime, DFS(child, children, informTime));
        }
        
        // 当前员工的通知时间 + 下属中最长的传播时间
        return informTime[employee] + maxTime;
    }
}

var numOfMinutes = function(n, headID, manager, informTime) {
    const children = Array.from({ length: n }, () => []);
    
    // 构建从管理者到下属的邻接表
    for (let i = 0; i < n; i++) {
        if (manager[i] !== -1) {
            children[manager[i]].push(i);
        }
    }
    
    const dfs = (employee) => {
        let maxTime = 0;
        
        // 遍历所有直属下属
        for (const child of children[employee]) {
            maxTime = Math.max(maxTime, dfs(child));
        }
        
        // 当前员工的通知时间 + 下属中最长的传播时间
        return informTime[employee] + maxTime;
    };
    
    return dfs(headID);
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度类型值说明
时间复杂度O(n)每个节点只访问一次
空间复杂度O(n)邻接表存储和递归调用栈的空间

相关题目