[LeetCode] 1376. Time Needed to Inform All Employees

A company has n employees with a unique ID for each employee from 0 to n - 1. The head of the company has is the one with headID.

Each employee has one direct manager given in the manager array where manager[i] is the direct manager of the i-th employee, manager[headID] = -1. Also it's guaranteed that the subordination relationships have a tree structure.

The head of the company wants to inform all the employees of the company of an urgent piece of news. He will inform his direct subordinates and they will inform their subordinates and so on until all employees know about the urgent news.

The i-th employee needs informTime[i] minutes to inform all of his direct subordinates (i.e After informTime[i] minutes, all his direct subordinates can start spreading the news).

Return the number of minutes needed to inform all the employees about the urgent news.

Example 1:

Input: n = 1, headID = 0, manager = [-1], informTime = [0]
Output: 0
Explanation: The head of the company is the only employee in the company.

Example 2:

Input: n = 6, headID = 2, manager = [2,2,-1,2,2,2], informTime = [0,0,1,0,0,0]
Output: 1
Explanation: The head of the company with id = 2 is the direct manager of all the employees in the company and needs 1 minute to inform them all.
The tree structure of the employees in the company is shown.

Example 3:

Input: n = 7, headID = 6, manager = [1,2,3,4,5,6,-1], informTime = [0,6,5,4,3,2,1]
Output: 21
Explanation: The head has id = 6. He will inform employee with id = 5 in 1 minute.
The employee with id = 5 will inform the employee with id = 4 in 2 minutes.
The employee with id = 4 will inform the employee with id = 3 in 3 minutes.
The employee with id = 3 will inform the employee with id = 2 in 4 minutes.
The employee with id = 2 will inform the employee with id = 1 in 5 minutes.
The employee with id = 1 will inform the employee with id = 0 in 6 minutes.
Needed time = 1 + 2 + 3 + 4 + 5 + 6 = 21.

Example 4:

Input: n = 15, headID = 0, manager = [-1,0,0,1,1,2,2,3,3,4,4,5,5,6,6], informTime = [1,1,1,1,1,1,1,0,0,0,0,0,0,0,0]
Output: 3
Explanation: The first minute the head will inform employees 1 and 2.
The second minute they will inform employees 3, 4, 5 and 6.
The third minute they will inform the rest of employees.

Example 5:

Input: n = 4, headID = 2, manager = [3,3,-1,2], informTime = [0,0,162,914]
Output: 1076

Constraints:

• 1 <= n <= 10^5
• 0 <= headID < n
• manager.length == n
• 0 <= manager[i] < n
• manager[headID] == -1
• informTime.length == n
• 0 <= informTime[i] <= 1000
• informTime[i] == 0 if employee i has no subordinates.
• It is guaranteed that all the employees can be informed.

通知所有员工所需的时间。

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

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

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/time-needed-to-inform-all-employees
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这是一道图论的题，我这里提供BFS和DFS两种做法。无论哪种做法，我们都需要先把图建立起来。在DFS中我用一个hashmap<employee, <a list of his/her subordinates>>建图。DFS的base case是当搜索到某个员工在hashmap中并不存在的话，就返回。如果某个员工不存在于hashmap的话意味着这个员工是没有下属的。对于每个有下属的员工，我们用DFS去遍历他的每一个下属，DFS最后返回的是max + 当前员工需要通知其下属的时间 informTime[cur]。

时间O(n)

空间O(n)

Java实现

class Solution {
    public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
        HashMap<Integer, List<Integer>> graph = new HashMap<>();
        int total = 0;
        for (int i = 0; i < manager.length; i++) {
            int m = manager[i];
            if (!graph.containsKey(m)) {
                graph.put(m, new ArrayList<>());
            }
            graph.get(m).add(i);
        }
        return dfs(graph, informTime, headID);
    }

    private int dfs(HashMap<Integer, List<Integer>> graph, int[] informTime, int cur) {
        int max = 0;
        if (!graph.containsKey(cur)) {
            return max;
        }
        for (int i = 0; i < graph.get(cur).size(); i++) {
            max = Math.max(max, dfs(graph, informTime, graph.get(cur).get(i)));
        }
        return max + informTime[cur];
    }
}

在BFS中我用一个List<Integer>[] 建图，array里面每个index代表当前的员工，每个index下面挂着一个list，代表当前员工的直属部下。既然是BFS，那么我们还是需要一个queue，首先我们把headID加入queue，同时我们也加入一个用时0，因为通知manager是不需要时间的。接着开始从queue中弹出元素，弹出的时候得到两个信息，一个是当前遍历到的员工id，另一个是通知到当前这个员工为止的时间cost。遍历当前员工的下属列表，并且把他的所有下属连同时间花费也加入queue进行下一轮遍历。注意最后计算结果的不同，我们用res一直去记录全局最大的时间花费，但是对于每一个被加入队列的员工，我们通知到TA的时间花费是当前已经产生的花费cost + informTime[employee]。

时间O(n)

空间O(n)

Java实现

class Solution {
    public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
        // <employee, <his/her subordinates>>
        List<Integer>[] graph = new List[n];
        for (int i = 0; i < n; i++) {
            graph[i] = new ArrayList<>();
        }
        // 如果当前这个人有manager，就把当前这个人加入其manager的subordinate list中
        for (int i = 0; i < n; i++) {
            if (manager[i] != -1) {
                graph[manager[i]].add(i);
            }
        }

        int res = 0;
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[] { headID, 0 });
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int employee = cur[0];
            int cost = cur[1];
            res = Math.max(res, cost);
            for (int sub : graph[employee]) {
                queue.offer(new int[] { sub, cost + informTime[employee] });
            }
        }
        return res;
    }
}

LeetCode 题目总结