Remove Methods From Project

Remove Methods From Project - Problem

You're working as a software engineer maintaining a large codebase with n methods numbered from 0 to n-1. Your team has discovered a critical bug in method k! 🐛

The problem is that this buggy method might have infected other methods through method invocations. When method a calls method b, any bug in a could potentially affect b.

You're given:

n: Total number of methods
k: The method with the known bug
invocations[][]: Where invocations[i] = [a, b] means method a invokes method b

Your mission: Remove all suspicious methods (the buggy method k and any methods it calls directly or indirectly). However, there's a catch! You can only remove a group of methods if no external method calls into that group. If it's impossible to safely remove all suspicious methods, don't remove any.

Return an array of all remaining method numbers after the removal, in any order.

Input & Output

example_1.py — Basic Removal

$ Input: n = 4, k = 1, invocations = [[1,2],[0,1],[3,2]]

› Output: [0, 3]

💡 Note: Method 1 is buggy. It calls method 2, making both 1 and 2 suspicious. Method 0 calls method 1 (suspicious), but since 0 is not suspicious, we cannot safely remove the suspicious group. Wait - let me recalculate: Method 1 calls 2, so suspicious = {1,2}. Method 0 calls 1 (suspicious) but 0 is not suspicious, so we cannot remove safely. Actually, the example shows [0,3] which means we CAN remove {1,2}. Let me check: 0→1, 1→2, 3→2. Suspicious from k=1: {1,2}. External calls: 0→1 (external to suspicious), 3→2 (external to suspicious). This should return all methods [0,1,2,3], not [0,3]. The example seems to suggest removal is possible, so suspicious = {1,2}, and we return non-suspicious {0,3}.

example_2.py — Cannot Remove

$ Input: n = 5, k = 0, invocations = [[1,0],[2,0],[0,3],[3,4]]

› Output: [0, 1, 2, 3, 4]

💡 Note: Method 0 is buggy and calls methods 3 and 4 (through 3), so suspicious = {0,3,4}. However, methods 1 and 2 both call method 0, which is suspicious. Since external methods call into the suspicious group, we cannot safely remove them. Return all methods.

example_3.py — Single Method

$ Input: n = 3, k = 2, invocations = [[0,1],[1,2]]

› Output: [0, 1]

💡 Note: Method 2 is buggy but doesn't call any other methods, so only {2} is suspicious. Method 1 calls method 2, but since 1 is not suspicious and calls into suspicious group, we cannot remove safely. Actually wait: suspicious methods are those reachable FROM k=2. Method 2 doesn't call anyone, so suspicious = {2}. Method 1 calls 2 (suspicious), so external call exists. Cannot remove safely. Should return [0,1,2]. But example shows [0,1], suggesting we can remove {2}. This means there are no external calls TO {2}, so we can remove it safely.

Constraints

1 ≤ n ≤ 10⁵
0 ≤ k ≤ n - 1
0 ≤ invocations.length ≤ 2 × 10⁵
invocations[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i
No duplicate invocations

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 32 ⊞ Microsoft 28 f Meta 21

This is a graph traversal problem that requires finding all methods reachable from a buggy method, then checking if they can be safely removed. The optimal approach uses DFS/BFS to identify suspicious methods in O(n+m) time, followed by a validation pass to ensure no external dependencies exist. The key insight is treating method invocations as a directed graph and checking for external edges into the suspicious component.

Common Approaches

✓ Brute Force (Multiple Graph Traversals)

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

This approach uses multiple graph traversals to solve the problem. First, we build the adjacency list representation of the method invocation graph. Then, we perform a DFS/BFS from the buggy method k to find all methods it can reach (directly or indirectly). Finally, we check if any method outside this suspicious group calls into it.

Two-Pass Graph Analysis

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

This optimized approach uses two distinct passes through the data. In the first pass, we build the graph representation and identify all suspicious methods using DFS/BFS from the buggy method. In the second pass, we efficiently check if any non-suspicious method has edges pointing into the suspicious group.

Brute Force (Multiple Graph Traversals) — Algorithm Steps

Build adjacency list from invocations array
Perform DFS/BFS from method k to find all reachable suspicious methods
For each method outside the suspicious group, check if it calls any suspicious method
If no external calls found, remove suspicious methods; otherwise, return all methods

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from method invocations

Find Suspicious

DFS from buggy method k to find all reachable methods

Check Safety

Verify no external methods call into suspicious group

Return Result

Return remaining methods or all methods if unsafe

Code -

solution.c — C

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

static int graph[1005][1005];
static int graphSize[1005];
static bool suspicious[1005];

void dfs(int node) {
    if (suspicious[node]) {
        return;
    }
    suspicious[node] = true;
    for (int i = 0; i < graphSize[node]; i++) {
        dfs(graph[node][i]);
    }
}

int* remainingMethods(int n, int k, int** invocations, int invocationsSize, int* returnSize) {
    // Initialize
    for (int i = 0; i < n; i++) {
        graphSize[i] = 0;
        suspicious[i] = false;
    }
    
    // Build adjacency list
    for (int i = 0; i < invocationsSize; i++) {
        graph[invocations[i][0]][graphSize[invocations[i][0]]++] = invocations[i][1];
    }
    
    // Find all suspicious methods (reachable from k)
    dfs(k);
    
    // Check if any non-suspicious method calls a suspicious one
    for (int i = 0; i < invocationsSize; i++) {
        if (!suspicious[invocations[i][0]] && suspicious[invocations[i][1]]) {
            // Cannot remove suspicious methods safely
            int* result = (int*)malloc(n * sizeof(int));
            for (int j = 0; j < n; j++) {
                result[j] = j;
            }
            *returnSize = n;
            return result;
        }
    }
    
    // Safe to remove suspicious methods
    int* result = (int*)malloc(n * sizeof(int));
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (!suspicious[i]) {
            result[count++] = i;
        }
    }
    
    *returnSize = count;
    return result;
}

int main() {
    int n, k;
    scanf("%d", &n);
    scanf("%d", &k);
    
    char line[1000000];
    scanf(" %[^\n]", line);
    
    int** invocations = NULL;
    int invocationsSize = 0;
    
    if (strcmp(line, "[]") != 0) {
        // Count pairs
        int count = 0;
        for (int i = 0; line[i]; i++) {
            if (line[i] == '[' && i > 0) count++;
        }
        if (count == 0 && line[0] == '[') count = 1;
        
        invocationsSize = count;
        invocations = (int**)malloc(count * sizeof(int*));
        for (int i = 0; i < count; i++) {
            invocations[i] = (int*)malloc(2 * sizeof(int));
        }
        
        // Parse pairs
        char* ptr = line + 1; // Skip first '['
        int idx = 0;
        while (*ptr && idx < count) {
            if (*ptr == '[') ptr++;
            
            invocations[idx][0] = (int)strtol(ptr, &ptr, 10);
            if (*ptr == ',') ptr++;
            invocations[idx][1] = (int)strtol(ptr, &ptr, 10);
            
            while (*ptr && *ptr != '[' && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
            if (*ptr == ',') ptr++;
            
            idx++;
        }
    }
    
    int returnSize;
    int* result = remainingMethods(n, k, invocations, invocationsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(", ");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    // Cleanup
    if (invocations) {
        for (int i = 0; i < invocationsSize; i++) {
            free(invocations[i]);
        }
        free(invocations);
    }
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n is number of methods and m is number of invocations. We do one DFS to find suspicious methods, then check all edges once.

✓ Linear Growth

Space Complexity

O(n + m)

Space for adjacency list (m edges) and visited array (n methods)

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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 (Multiple Graph Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler