Time Needed to Inform All Employees - Practice Coding Problems

Time Needed to Inform All Employees - Problem

Imagine you're the head of a company and you need to spread urgent news to all your employees as quickly as possible! 🏢📢

Your company has n employees, each with a unique ID from 0 to n-1. The organizational structure forms a tree hierarchy where:

You are the head with ID headID
Each employee has exactly one direct manager (except you)
The manager[i] array tells us who manages employee i
Each employee needs informTime[i] minutes to inform all their direct subordinates

The Challenge: Information flows down the hierarchy - you inform your direct reports, they inform theirs, and so on. Since people can inform their subordinates simultaneously, we need to find the maximum time along any path from head to leaf.

Goal: Return the minimum number of minutes needed to inform all employees in the company.

Input & Output

example_1.py — Small Company

$ Input: n = 6, headID = 2, manager = [2,2,-1,2,2,2], informTime = [0,0,1,0,0,0]

› Output: 1

💡 Note: The head (employee 2) informs all 5 subordinates directly in 1 minute since they're all direct reports. No further propagation needed.

example_2.py — Multi-level Hierarchy

$ Input: n = 4, headID = 0, manager = [-1,0,0,1], informTime = [1,1,1,0]

› Output: 3

💡 Note: Head (0) takes 1 min to inform subordinates 1 and 2. Employee 1 takes 1 more min to inform employee 3. Path 0→1→3 takes 1+1+0=2 minutes, path 0→2 takes 1+1=2 minutes. Wait, let me recalculate: 0 informs 1,2 (1 min), then 1 informs 3 (1 min), and 2 finishes (1 min). Maximum path is 1+1=2 minutes.

example_3.py — Single Employee

$ Input: n = 1, headID = 0, manager = [-1], informTime = [0]

› Output: 0

💡 Note: Only one employee (the head) exists, so no time needed to inform anyone.

Constraints

1 ≤ n ≤ 10⁵
0 ≤ headID < n
manager.length == n
0 ≤ manager[i] < n
manager[headID] == -1
informTime.length == n
0 ≤ informTime[i] ≤ 1000
The subordination relationships form a tree structure

Visualization

Tap to expand

Understanding the Visualization

Build Organization Tree

Map out who reports to whom in the corporate hierarchy

Start from Head

CEO begins informing direct reports simultaneously

Cascade Down Levels

Each manager informs their team, creating parallel information flows

Find Critical Path

The longest path determines when the last employee is informed

Key Takeaway

🎯 Key Insight: This is a tree traversal problem where the answer is the maximum depth-weighted path from root to leaf, representing the time when the last employee receives the information.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

This is a tree traversal problem where we need to find the maximum path sum from root to any leaf. The optimal approach uses DFS with memoization in O(n) time. Key insight: since employees inform subordinates simultaneously, we need the longest path, not the sum of all paths. Each employee's total time = their inform time + maximum time among all subordinates.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Build Tree + Calculate All Paths)	O(n²)	O(n)	Build the organizational tree and calculate time for every possible path
Optimized DFS (Bottom-Up Approach)	O(n)	O(n)	Use DFS with memoization, calculating from leaves up to root efficiently

Brute Force (Build Tree + Calculate All Paths) — Algorithm Steps

Build subordinate lists for each employee by scanning the entire manager array
Use DFS from head to explore every path to leaf employees
For each employee, calculate: their inform time + max time of all subordinates
Return the maximum time among all paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Subordinate Lists

Scan through manager array to build adjacency lists

Start DFS from Head

Begin traversal from the head of company

Calculate Path Times

For each node, calculate inform time + max subordinate time

Return Maximum

The longest path determines total inform time

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int max(int a, int b) {
    return a > b ? a : b;
}

int dfs(int employeeId, int** subordinates, int* subordinateCount, int* informTime) {
    // If no subordinates, this employee doesn't need to inform anyone
    if (subordinateCount[employeeId] == 0) {
        return 0;
    }
    
    // Calculate max time among all subordinates
    int maxSubordinateTime = 0;
    for (int i = 0; i < subordinateCount[employeeId]; i++) {
        int subordinate = subordinates[employeeId][i];
        maxSubordinateTime = max(maxSubordinateTime, dfs(subordinate, subordinates, subordinateCount, informTime));
    }
    
    // Total time = this employee's inform time + max subordinate time
    return informTime[employeeId] + maxSubordinateTime;
}

int numOfMinutes(int n, int headID, int* manager, int* informTime) {
    // Build subordinates list for each employee
    int** subordinates = (int**)malloc(n * sizeof(int*));
    int* subordinateCount = (int*)calloc(n, sizeof(int));
    
    // First pass: count subordinates
    for (int i = 0; i < n; i++) {
        if (manager[i] != -1) {
            subordinateCount[manager[i]]++;
        }
    }
    
    // Allocate memory for subordinate lists
    for (int i = 0; i < n; i++) {
        subordinates[i] = (int*)malloc(subordinateCount[i] * sizeof(int));
    }
    
    // Second pass: populate subordinate lists
    int* indices = (int*)calloc(n, sizeof(int));
    for (int i = 0; i < n; i++) {
        if (manager[i] != -1) {
            subordinates[manager[i]][indices[manager[i]]++] = i;
        }
    }
    
    int result = dfs(headID, subordinates, subordinateCount, informTime);
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(subordinates[i]);
    }
    free(subordinates);
    free(subordinateCount);
    free(indices);
    
    return result;
}

int main() {
    int n, headID;
    scanf("%d %d", &n, &headID);
    
    int* manager = (int*)malloc(n * sizeof(int));
    int* informTime = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        scanf("%d", &manager[i]);
    }
    for (int i = 0; i < n; i++) {
        scanf("%d", &informTime[i]);
    }
    
    printf("%d\n", numOfMinutes(n, headID, manager, informTime));
    
    free(manager);
    free(informTime);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n²) to build subordinate lists + O(n) for DFS traversal

⚠ Quadratic Growth

Space Complexity

O(n)

O(n) for storing subordinate lists + O(h) recursion stack where h is tree height

⚡ Linearithmic Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Build Tree + Calculate All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler