通知所有员工所需的时间

题目描述

公司里有 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 。
题目 保证 所有员工都可以收到通知。

分析

我们只需要从总负责人出发访问所有下属，访问的同时计算出当前节点（下属）的得到通知的时间，返回最大的时间。这里采用BFS算法遍历。

代码

class Solution {
    public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
        LinkedList<Integer> tree=new LinkedList<>();
        tree.add(headID);
        int ans=0;
        int[] dp=new int[n];//dp[i]表示节点i得到通知的时间
        dp[headID]=0;
        while(tree.isEmpty()==false){
            int node=tree.poll();
            for(int i=0;i<n;i++){//对于每个节点找到它的子节点
                if(manager[i]==node){
                    tree.add(i);
                    //当前节点得到信息的时间=父节点时间+父节点到当前节点的时间
                    dp[i]=dp[node]+informTime[node];
                    ans=Math.max(ans,dp[i]);//取最大时间
                }
            }
        }
        return ans;
    }
}

优化

对于每一个节点寻找子节点的过程中，都需要遍历一遍manager[]，时间复杂度是O（n^2）。我们可以先把节点对应的子节点先找出来，这样寻找子节点就不需要遍历整个数组。

class Solution {
    public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
        LinkedList<Integer> tree=new LinkedList<>();
        tree.add(headID);
        int[] dp=new int[n];
        dp[headID]=0;
        //先找出每个节点的子节点保存到map中
        HashMap<Integer,List<Integer>> map=new HashMap<>();
        for(int i=0;i<n;i++){
            if(map.containsKey(manager[i])){
                map.get(manager[i]).add(i);
            }else {
                List<Integer> list=new ArrayList<>();
                list.add(i);
                map.put(manager[i],list);
            }
        }
        int ans=0;
        while(tree.isEmpty()==false){
            int node=tree.poll();
            if(map.containsKey(node)){
                for(int i:map.get(node)){
                    tree.add(i);
                    dp[i]=dp[node]+informTime[node];
                    ans=Math.max(ans,dp[i]);
                }
            }
        }
        return ans;
    }
}

时间复杂度=O（n）