Skip to content

Latest commit

 

History

History
209 lines (166 loc) · 5.65 KB

README.md

File metadata and controls

209 lines (166 loc) · 5.65 KB

1376. 通知所有员工所需的时间

English Version

题目描述

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

解法

找从根节点到叶子节点最长的路径即可。

Python3

class Solution:
    def numOfMinutes(
        self, n: int, headID: int, manager: List[int], informTime: List[int]
    ) -> int:
        def dfs(i):
            ans = 0
            for j in g[i]:
                ans = max(ans, informTime[i] + dfs(j))
            return ans

        g = defaultdict(list)
        for i, m in enumerate(manager):
            g[m].append(i)
        return dfs(headID)

Java

class Solution {
    private Map<Integer, List<Integer>> g;
    private int[] manager;
    private int[] informTime;

    public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
        g = new HashMap<>();
        this.manager = manager;
        this.informTime = informTime;
        for (int i = 0; i < n; ++i) {
            g.computeIfAbsent(manager[i], k -> new ArrayList<>()).add(i);
        }
        return dfs(headID);
    }

    private int dfs(int i) {
        int ans = 0;
        for (int j : g.getOrDefault(i, new ArrayList<>())) {
            ans = Math.max(ans, informTime[i] + dfs(j));
        }
        return ans;
    }
}

C++

class Solution {
public:
    unordered_map<int, vector<int>> g;
    vector<int> manager;
    vector<int> informTime;

    int numOfMinutes(int n, int headID, vector<int>& manager, vector<int>& informTime) {
        this->manager = manager;
        this->informTime = informTime;
        for (int i = 0; i < n; ++i) g[manager[i]].push_back(i);
        return dfs(headID);
    }

    int dfs(int i) {
        int ans = 0;
        for (int j : g[i]) ans = max(ans, informTime[i] + dfs(j));
        return ans;
    }
};

Go

func numOfMinutes(n int, headID int, manager []int, informTime []int) int {
	g := make(map[int][]int)
	for i, m := range manager {
		g[m] = append(g[m], i)
	}
	var dfs func(i int) int
	dfs = func(i int) int {
		ans := 0
		if v, ok := g[i]; ok {
			for _, j := range v {
				ans = max(ans, informTime[i]+dfs(j))
			}
		}
		return ans
	}
	return dfs(headID)
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

TypeScript

function numOfMinutes(
    n: number,
    headID: number,
    manager: number[],
    informTime: number[],
): number {
    if (n === 1) {
        return 0;
    }
    let res = 0;
    const time = new Array(n).fill(0);
    time[headID] = -1;
    const dfs = (i: number) => {
        const aim = manager[i];
        if (time[aim] === -1) {
            return informTime[aim];
        }
        if (time[aim] === 0) {
            time[aim] = dfs(aim);
        }
        return time[aim] + informTime[aim];
    };
    for (let i = 0; i < n; i++) {
        if (time[i] === 0) {
            time[i] = dfs(i);
        }
        res = Math.max(res, time[i]);
    }
    return res;
}

...