【leetcode】5354. 通知所有员工所需的时间( Time Needed to Inform All Employees )_同知所有员工所需的时间

---

题目描述

【leetcode】5354. 通知所有员工所需的时间( Time Needed to Inform All Employees )

公司里有 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 分钟来通知所有员工。
上图显示了公司员工的树结构。

示例 3：

输入：n = 7, headID = 6, manager = [1,2,3,4,5,6,-1], informTime = [0,6,5,4,3,2,1]
输出：21
解释：总负责人 id = 6。他将在 1 分钟内通知 id = 5 的员工。
id = 5 的员工将在 2 分钟内通知 id = 4 的员工。
id = 4 的员工将在 3 分钟内通知 id = 3 的员工。
id = 3 的员工将在 4 分钟内通知 id = 2 的员工。
id = 2 的员工将在 5 分钟内通知 id = 1 的员工。
id = 1 的员工将在 6 分钟内通知 id = 0 的员工。
所需时间 = 1 + 2 + 3 + 4 + 5 + 6 = 21 。

示例 4：
输入：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]
输出：3
解释：第一分钟总负责人通知员工 1 和 2 。
第二分钟他们将会通知员工 3, 4, 5 和 6 。
第三分钟他们将会通知剩下的员工。

示例 5：
输入：n = 4, headID = 2, manager = [3,3,-1,2], informTime = [0,0,162,914]
输出：1076

提示：

• 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，后来想想若同一层中通知不同员工耗时不一样，dfs恐怕还不好弄。
然后换成dfs，相当于深度优先遍历一个树，只是这个树不是二叉树，树的表示方法比较奇怪而已。这个题解能比较好的表达我的思想过程。
同时为了避免重复运算，一开始先获取了结点间的对应关系放到vector<vector<int>> my_map(n);里，相当于是建了个树吧。
通过全局变量的方式把最大通知时间拿出来，每次遍历到叶子结点（这里通过0 == informTime[headID]进行叶子结点的判断），就判断是否要更新通知时间。
代码：

#include <queue>
class Solution {
public:
    int total_time = 0;
    void helper(int headID, vector<int>& manager, vector<int>& informTime, int curr_time, vector<vector<int>> &my_map){
        if(0 == informTime[headID]){
            // 遍历到叶子结点
            if(curr_time > total_time){
                total_time = curr_time;
            }
            return;
        }
        curr_time += informTime[headID];
        
        for(int j=0; j<my_map[headID].size(); ++j){
            helper(my_map[headID][j], manager, informTime, curr_time, my_map);
        }
    }
    int numOfMinutes(int n, int headID, vector<int>& manager, vector<int>& informTime) {
        // 建立索引表
        vector<vector<int>> my_map(n);
        for(int i=0; i<n; ++i){
            if(-1 == manager[i])
                continue;
            my_map[manager[i]].push_back(i);
        }
        // 深度优先遍历，层次遍历不行
        helper(headID, manager, informTime, 0, my_map);
        return total_time;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

结果：

第二次解答

看了题解，发现第一次解答是从上到下dfs遍历，这要求先自己建一棵树。
实际上按照题目给的数据格式，我们不需要额外的加工，直接就可以从叶子结点向上遍历，即自底向上。
据说这种方法就是并查集的方法，不过我之前没接触过。

#include <cmath>
class Solution {
public:
    int numOfMinutes(int n, int headID, vector<int>& manager, vector<int>& informTime) {

        // 找到所有叶子结点
        vector<int> leaf_nodes;
        leaf_nodes.reserve(informTime.size());
        for(int i=0; i<informTime.size(); ++i){
            if(0 == informTime[i]){
                leaf_nodes.push_back(i);
            }
        }

        // 从每个叶子结点向上遍历，得到通知时间
        int max_time = 0;
        for(auto & node : leaf_nodes){
            int node_time = 0;
            int parent = manager[node];
            while(-1 != parent){
                node_time += informTime[parent];
                parent = manager[parent];
            }
            max_time = max(node_time, max_time);
        }
        return max_time;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

结果：

相关/参考链接