Kill Process

Kill Process - Problem

You have n processes forming a rooted tree structure. You are given two integer arrays pid and ppid, where pid[i] is the ID of the i-th process and ppid[i] is the ID of the i-th process's parent process.

Each process has only one parent process but may have multiple children processes. Only one process has ppid[i] = 0, which means this process has no parent process (the root of the tree).

When a process is killed, all of its children processes will also be killed. Given an integer kill representing the ID of a process you want to kill, return a list of the IDs of the processes that will be killed.

You may return the answer in any order.

Input & Output

Example 1 — Basic Tree Structure

$ Input: pid = [1,3,10,5], ppid = [3,0,5,3], kill = 5

› Output: [5,10]

💡 Note: Process 5 has child 10. When we kill 5, both 5 and 10 are terminated.

Example 2 — Deeper Tree

$ Input: pid = [1,2,3,4,5], ppid = [0,1,1,3,3], kill = 3

› Output: [3,4,5]

💡 Note: Process 3 has children 4 and 5. Killing 3 removes processes 3, 4, and 5.

Example 3 — Root Process

$ Input: pid = [1,2,3], ppid = [0,1,1], kill = 1

› Output: [1,2,3]

💡 Note: Process 1 is root with children 2 and 3. Killing root kills entire tree.

Constraints

n == pid.length
n == ppid.length
1 ≤ n ≤ 5 × 10⁴
1 ≤ pid[i] ≤ 5 × 10⁴
0 ≤ ppid[i] ≤ 5 × 10⁴
Only one process has no parent
All the PIDs are distinct
kill is guaranteed to be in pid

Visualization

Tap to expand

Asked in

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

The key insight is to model the processes as a tree structure and use tree traversal. Build a parent-to-children hash map, then use DFS or BFS starting from the target process to collect all descendants. Best approach is Hash Map + DFS/BFS with Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map + BFS	O(n)	O(n)	Build parent-to-children map, then use BFS queue to process level by level
Hash Map + DFS	O(n)	O(n)	Build parent-to-children map first, then use DFS to traverse from target
Brute Force - Linear Search	O(n²)	O(n)	For each process, check if it should be killed by searching through relationships

Hash Map + BFS — Algorithm Steps

Build hash map: parent → list of children
Initialize queue with the target process
While queue not empty: dequeue process, add children to queue
Continue until all descendants processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Build map and start with target in queue

Process

Dequeue process and add its children

Continue

Process all children level by level

Code -

solution.c — C

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

typedef struct Node {
    int val;
    struct Node* next;
} Node;

typedef struct {
    Node* head;
} List;

typedef struct {
    int* data;
    int front, rear, size;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (int*)malloc(capacity * sizeof(int));
    q->front = q->rear = 0;
    q->size = 0;
    return q;
}

void enqueue(Queue* q, int val) {
    q->data[q->rear] = val;
    q->rear = (q->rear + 1) % 1000;
    q->size++;
}

int dequeue(Queue* q) {
    int val = q->data[q->front];
    q->front = (q->front + 1) % 1000;
    q->size--;
    return val;
}

void addChild(List* children, int parent, int child) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->val = child;
    newNode->next = children[parent].head;
    children[parent].head = newNode;
}

int* solution(int* pid, int pidSize, int* ppid, int ppidSize, int kill, int* returnSize) {
    List* children = (List*)calloc(50001, sizeof(List));
    
    for (int i = 0; i < pidSize; i++) {
        addChild(children, ppid[i], pid[i]);
    }
    
    int* result = (int*)malloc(pidSize * sizeof(int));
    int count = 0;
    
    Queue* queue = createQueue(1000);
    enqueue(queue, kill);
    
    while (queue->size > 0) {
        int current = dequeue(queue);
        result[count++] = current;
        
        Node* childNode = children[current].head;
        while (childNode) {
            enqueue(queue, childNode->val);
            childNode = childNode->next;
        }
    }
    
    *returnSize = count;
    
    // Free memory
    for (int i = 0; i <= 50000; i++) {
        Node* current = children[i].head;
        while (current) {
            Node* next = current->next;
            free(current);
            current = next;
        }
    }
    free(children);
    free(queue->data);
    free(queue);
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int pid[1000], ppid[1000];
    int pidSize = 0, ppidSize = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token) {
        pid[pidSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line + 1, ",]");
    while (token) {
        ppid[ppidSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int kill;
    scanf("%d", &kill);
    
    int returnSize;
    int* result = solution(pid, pidSize, ppid, ppidSize, kill, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to build map + BFS visits each killed process once

✓ Linear Growth

Space Complexity

O(n)

Hash map stores parent-child relationships + queue + result array

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

845 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

Hash Map + BFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler