Employee Importance - Practice Coding Problems

Employee Importance - Problem

Employee Importance Calculator

Imagine you're building a human resources system that needs to calculate the total impact of an employee within a company hierarchy. You have access to a company's organizational structure where each employee has:

• A unique ID
• An importance value (representing their individual contribution)
• A list of subordinates (employees who report directly to them)

Your Mission: Given a specific employee's ID, calculate the total importance value of that employee plus all their direct and indirect subordinates (their entire sub-organization tree).

Example: If Manager Alice (importance: 5) oversees Bob (importance: 3) and Carol (importance: 2), and Bob oversees Dave (importance: 1), then Alice's total importance would be 5 + 3 + 2 + 1 = 11.

This is essentially a tree traversal problem where you need to sum values across an entire subtree starting from a given node.

Input & Output

example_1.py — Basic Hierarchy

$ Input: employees = [[1,5,[2,3]], [2,3,[]], [3,3,[]]], id = 1

› Output: 11

💡 Note: Employee 1 has importance 5, and has two direct subordinates: employee 2 and employee 3. Both employee 2 and employee 3 have importance 3. So the total importance of employee 1 is 5 + 3 + 3 = 11.

example_2.py — Single Employee

$ Input: employees = [[1,2,[]]], id = 1

› Output: 2

💡 Note: Employee 1 is the only employee in this company, so their total importance is just their individual importance value of 2.

example_3.py — Deep Hierarchy

$ Input: employees = [[1,15,[2]], [2,10,[3]], [3,5,[]]], id = 1

› Output: 30

💡 Note: This represents a chain of command: Employee 1 (importance 15) manages Employee 2 (importance 10), who manages Employee 3 (importance 5). Total: 15 + 10 + 5 = 30.

Visualization

Tap to expand

Understanding the Visualization

Build Employee Directory

Create a hash map for instant employee lookup by ID

Start from Target Employee

Begin DFS traversal from the specified employee

Traverse All Subordinates

Visit each subordinate and their subordinates recursively

Sum Importance Values

Accumulate importance values from entire subtree

Key Takeaway

🎯 Key Insight: Transform the employee array into a hash map for O(1) lookups, then use tree traversal (DFS/BFS) to efficiently navigate the hierarchy and calculate total importance.

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to build hash map + O(n) to traverse all employees in subtree

✓ Linear Growth

Space Complexity

O(n)

O(n) for hash map + O(h) recursion stack where h is tree height

⚡ Linearithmic Space

Constraints

1 ≤ employees.length ≤ 2000
1 ≤ employees[i].id ≤ 2000
0 ≤ employees[i].importance ≤ 1000
One employee has at most one direct leader and may have several subordinates
The IDs in employees[i].subordinates are valid IDs

Asked in

G Google 45 a Amazon 35 f Facebook 28 ⊞ Microsoft 22

The optimal solution uses a hash table for O(1) employee lookups combined with depth-first search (DFS) to traverse the employee hierarchy tree. First, build a hash map mapping employee IDs to employee objects, then use DFS starting from the target employee to sum importance values of the entire subtree. Time complexity: O(n), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Hash Table + DFS Traversal	O(n)	O(n)	Build employee lookup map first, then traverse hierarchy with DFS
Brute Force (Linear Search)	O(n²)	O(h)	Search through the entire employee array for each subordinate lookup

Hash Table + DFS Traversal — Algorithm Steps

Create a hash map mapping employee ID to employee object for O(1) lookups
Start DFS traversal from the given employee ID
For current employee, add their importance to running total
Recursively process all direct subordinates
Return the total sum of importance values

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Map

Create O(1) lookup table for all employees

DFS Traversal

Traverse hierarchy tree summing importance values

Accumulate Results

Sum importance values from current employee and all subordinates

Code -

solution.c — C

int getImportance(struct Employee** employees, int employeesSize, int id) {
    // Create a simple hash table using array (assuming IDs are reasonable)
    struct Employee* empMap[10001] = {NULL}; // Assuming max ID is 10000
    
    // Build hash map
    for (int i = 0; i < employeesSize; i++) {
        empMap[employees[i]->id] = employees[i];
    }
    
    int dfs(int empId) {
        if (empId > 10000 || empMap[empId] == NULL) {
            return 0;
        }
        
        struct Employee* employee = empMap[empId];
        int total = employee->importance;
        
        // Add importance of all subordinates
        for (int i = 0; i < employee->subordinatesSize; i++) {
            total += dfs(employee->subordinates[i]);
        }
        
        return total;
    }
    
    return dfs(id);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to build hash map + O(n) to traverse all employees in subtree

✓ Linear Growth

Space Complexity

O(n)

O(n) for hash map + O(h) recursion stack where h is tree height

⚡ Linearithmic Space

Constraints

1 ≤ employees.length ≤ 2000
1 ≤ employees[i].id ≤ 2000
0 ≤ employees[i].importance ≤ 1000
One employee has at most one direct leader and may have several subordinates
The IDs in employees[i].subordinates are valid IDs

28.5K Views

Medium Frequency

~15 min Avg. Time

1.3K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Table + DFS Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler