Remove Methods From Project - Practice Coding Problems

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

Understanding the Visualization

Identify Patient Zero

Start with the buggy method k as the source of contamination

Trace Infection Spread

Use graph traversal to find all methods reachable from k

Check Quarantine Feasibility

Verify no clean methods have connections to infected ones

Execute Quarantine Decision

Either remove infected methods or keep everything if unsafe

Key Takeaway

🎯 Key Insight: This problem combines graph reachability (finding infected methods) with dependency validation (checking quarantine safety). The critical decision point is whether external methods have dependencies on the infected group - if yes, quarantine fails!

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

Approach	Time	Space	Notes
✓ Brute Force (Multiple Graph Traversals)	O(n + m)	O(n + m)	Repeatedly traverse the graph to find all suspicious methods, then check removal feasibility
Two-Pass Graph Analysis	O(n + m)	O(n + m)	First pass to build graph and find suspicious methods, second pass to verify removal safety

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>

int* remainingMethods(int n, int k, int** invocations, int invocationsSize, int* invocationsColSize, int* returnSize) {
    // Build adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSize = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < invocationsSize; i++) {
        graph[invocations[i][0]][graphSize[invocations[i][0]]++] = invocations[i][1];
    }
    
    // Find suspicious methods using DFS
    bool* suspicious = (bool*)calloc(n, sizeof(bool));
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int* stack = (int*)malloc(n * sizeof(int));
    int stackTop = 0;
    
    stack[stackTop++] = k;
    
    while (stackTop > 0) {
        int node = stack[--stackTop];
        if (visited[node]) continue;
        visited[node] = true;
        suspicious[node] = true;
        
        for (int i = 0; i < graphSize[node]; i++) {
            if (!visited[graph[node][i]]) {
                stack[stackTop++] = graph[node][i];
            }
        }
    }
    
    // Check if removal is safe
    for (int i = 0; i < invocationsSize; i++) {
        if (!suspicious[invocations[i][0]] && suspicious[invocations[i][1]]) {
            int* result = (int*)malloc(n * sizeof(int));
            for (int j = 0; j < n; j++) {
                result[j] = j;
            }
            *returnSize = n;
            
            // Cleanup
            for (int j = 0; j < n; j++) free(graph[j]);
            free(graph); free(graphSize); free(suspicious);
            free(visited); free(stack);
            return result;
        }
    }
    
    // Return remaining 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;
    
    // Cleanup
    for (int i = 0; i < n; i++) free(graph[i]);
    free(graph); free(graphSize); free(suspicious);
    free(visited); free(stack);
    return result;
}

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