Employee Importance

Employee Importance - Problem

You have a data structure of employee information, including the employee's unique ID, importance value, and direct subordinates' IDs.

You are given an array of employees employees where:

employees[i].id is the ID of the i^th employee
employees[i].importance is the importance value of the i^th employee
employees[i].subordinates is a list of the IDs of the direct subordinates of the i^th employee

Given an integer id that represents an employee's ID, return the total importance value of this employee and all their direct and indirect subordinates.

Input & Output

Example 1 — 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 2 and 3. Employee 2 has importance 3, employee 3 has importance 3. Total: 5 + 3 + 3 = 11.

Example 2 — Single Employee

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

› Output: 1

💡 Note: Employee 5 has importance 1 and no subordinates. Total importance is just 1.

Example 3 — Deep Hierarchy

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

› Output: 12

💡 Note: Employee 1 has subordinate 2, employee 2 has subordinate 3. Total: 5 + 3 + 4 = 12.

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

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 5 f Facebook 4

The key insight is to treat the employee structure as a tree and traverse from the target employee to all subordinates. The optimal approach uses a hash map for O(1) employee lookup combined with DFS or BFS traversal. Time: O(n), Space: O(n).

Common Approaches

✓ Stack

⏱️ Time: N/A Space: N/A

BFS with Queue

⏱️ Time: O(n) Space: O(n)

Build a hash map for O(1) lookup, then use BFS with a queue. Start with the given employee, add to queue. Process each employee: add their importance to total and add all subordinates to queue.

Brute Force Linear Search

⏱️ Time: O(n²) Space: O(h)

Start with the given employee, add their importance. For each subordinate ID, search through the entire employees array to find their data, then recursively process their subordinates.

Hash Map + DFS

⏱️ Time: O(n) Space: O(n)

First pass builds a hash map from employee ID to employee object for O(1) lookup. Second pass uses DFS to traverse the hierarchy, looking up each employee in constant time.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* solution(int n, char** logs, int logsSize, int* returnSize) {
    *returnSize = n;
    int* result = (int*)calloc(n, sizeof(int));
    
    int stack[1000][2]; // [func_id, start_time]
    int stackTop = -1;
    
    for (int i = 0; i < logsSize; i++) {
        // Make a copy to avoid modifying original string
        char logCopy[100];
        strcpy(logCopy, logs[i]);
        
        char* token = strtok(logCopy, ":");
        int funcId = atoi(token);
        token = strtok(NULL, ":");
        char* action = token;
        token = strtok(NULL, ":");
        int timestamp = atoi(token);
        
        if (strcmp(action, "start") == 0) {
            stackTop++;
            stack[stackTop][0] = funcId;
            stack[stackTop][1] = timestamp;
        } else { // end
            int startFunc = stack[stackTop][0];
            int startTime = stack[stackTop][1];
            stackTop--;
            
            int duration = timestamp - startTime + 1;
            result[startFunc] += duration;
            
            // Subtract duration from parent function if exists
            if (stackTop >= 0) {
                result[stack[stackTop][0]] -= duration;
            }
        }
    }
    
    return result;
}

// Helper function to parse JSON array of strings
char** parseLogsArray(char* jsonStr, int* size) {
    cJSON* json = cJSON_Parse(jsonStr);
    if (!json || !cJSON_IsArray(json)) {
        *size = 0;
        return NULL;
    }
    
    *size = cJSON_GetArraySize(json);
    char** logs = (char**)malloc(*size * sizeof(char*));
    
    for (int i = 0; i < *size; i++) {
        cJSON* item = cJSON_GetArrayItem(json, i);
        if (cJSON_IsString(item)) {
            logs[i] = (char*)malloc(strlen(cJSON_GetStringValue(item)) + 1);
            strcpy(logs[i], cJSON_GetStringValue(item));
        }
    }
    
    cJSON_Delete(json);
    return logs;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char buffer[10000];
    scanf(" %s", buffer);
    
    int logsSize;
    char** logs = parseLogsArray(buffer, &logsSize);
    
    int returnSize;
    int* result = solution(n, logs, logsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < logsSize; i++) {
        free(logs[i]);
    }
    free(logs);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

38.6K Views

Medium Frequency

~15 min Avg. Time

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