Minimize Malware Spread - Practice Coding Problems

Minimize Malware Spread - Problem

Array Hash Table Depth-First Search Breadth-First Search Union Find Graph Hard

Imagine you're a cybersecurity expert dealing with a malware outbreak in a computer network! You have a network of n computers represented as an n × n adjacency matrix graph, where graph[i][j] == 1 means computers i and j are directly connected.

Some computers in the initial array are already infected with malware. The malware spreads according to this rule: whenever two computers are directly connected and at least one is infected, both become infected. This continues until no more computers can be infected.

Here's your mission: You can quarantine exactly one computer from the initial infected list before the malware starts spreading. Your goal is to find which computer to quarantine to minimize the total number of infected computers after the spread stops.

If multiple computers would result in the same minimum infection count, return the one with the smallest index. Note that a quarantined computer might still get infected later if the malware reaches it through other paths!

Input & Output

example_1.py — Small Network

$ Input: graph = [[1,1,0],[1,1,0],[0,0,1]], initial = [0,1]

› Output: 0

💡 Note: Nodes 0 and 1 are connected, and node 2 is isolated. If we remove node 0, node 1 still spreads to node 0 later, infecting 2 total. If we remove node 1, node 0 still spreads to node 1, infecting 2 total. Since both result in the same infection count, we return the smaller index: 0.

example_2.py — Multiple Components

$ Input: graph = [[1,0,0],[0,1,0],[0,0,1]], initial = [0,2]

› Output: 0

💡 Note: Each node is in its own component (no connections). Removing either node 0 or 2 results in 1 infection instead of 2. Since both give the same result, we return the smaller index: 0.

example_3.py — Optimal Removal

$ Input: graph = [[1,1,1],[1,1,1],[1,1,1]], initial = [1,2]

› Output: 1

💡 Note: All nodes are connected in one component. No matter which initially infected node we remove, the malware will still spread through the other initially infected node to infect all 3 nodes. Since the result is the same, return the smaller index: 1.

Constraints

n == graph.length == graph[i].length
2 ≤ n ≤ 300
graph[i][j] is 0 or 1
graph[i][i] == 1
graph[i][j] == graph[j][i]
1 ≤ initial.length ≤ n
All integers in initial are unique

Visualization

Tap to expand

Understanding the Visualization

Map the Network

Identify all connected areas (hospital wards) where the infection can spread

Analyze Infected Areas

For each ward, count how many patients are already infected

Find Strategic Quarantine

Look for wards with exactly one infected patient - quarantining them saves the entire ward

Maximize Impact

Among all strategic quarantines, choose the one that saves the most people

Key Takeaway

🎯 Key Insight: Use Union-Find to identify connected components, then quarantine the infected node that's alone in its component and saves the most people. This transforms a complex simulation into an elegant graph analysis problem!

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal approach uses Union-Find to identify connected components in O(n²α(n)) time. Key insight: removing an infected node only helps if it's the only infected node in its component. Among all beneficial removals, choose the one that saves the most nodes, breaking ties by selecting the smallest index.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find with Component Analysis	O(n²α(n))	O(n)	Use Union-Find to identify connected components and analyze impact of removing each infected node
Brute Force Simulation	O(n³)	O(n)	Try removing each infected node and simulate malware spread for each scenario

Union-Find with Component Analysis — Algorithm Steps

Build Union-Find structure to group all connected nodes
For each connected component, count how many initially infected nodes it contains
For each initially infected node, check if it's the only infected node in its component
If a node is alone in its component, removing it saves the entire component
Among all beneficial removals, choose the one that saves the most nodes
If no removal helps, return the smallest indexed initially infected node

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Components

Use Union-Find to group all connected nodes into components

Count Infections

For each component, count how many initially infected nodes it contains

Find Unique Infections

Identify components with exactly one infected node

Calculate Savings

Removing the unique infected node saves the entire component

Code -

solution.c — C

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

typedef struct {
    int* parent;
    int* size;
    int n;
} UnionFind;

UnionFind* createUnionFind(int n) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->size = (int*)malloc(n * sizeof(int));
    uf->n = n;
    
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
        uf->size[i] = 1;
    }
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void unionSets(UnionFind* uf, int x, int y) {
    int px = find(uf, x), py = find(uf, y);
    if (px == py) return;
    if (uf->size[px] < uf->size[py]) {
        int temp = px; px = py; py = temp;
    }
    uf->parent[py] = px;
    uf->size[px] += uf->size[py];
}

int getSize(UnionFind* uf, int x) {
    return uf->size[find(uf, x)];
}

int minMalwareSpread(int** graph, int graphSize, int* graphColSize, int* initial, int initialSize) {
    int n = graphSize;
    
    // Build connected components
    UnionFind* uf = createUnionFind(n);
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (graph[i][j] == 1) {
                unionSets(uf, i, j);
            }
        }
    }
    
    // Count infected nodes per component
    int* componentInfectedCount = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < initialSize; i++) {
        int root = find(uf, initial[i]);
        componentInfectedCount[root]++;
    }
    
    // Find the best node to remove
    int maxSaved = 0;
    int bestRemoval = initial[0];
    for (int i = 1; i < initialSize; i++) {
        if (initial[i] < bestRemoval) {
            bestRemoval = initial[i];
        }
    }
    
    for (int i = 0; i < initialSize; i++) {
        int node = initial[i];
        int root = find(uf, node);
        // If this node is the only infected node in its component
        if (componentInfectedCount[root] == 1) {
            int saved = getSize(uf, node);
            if (saved > maxSaved || (saved == maxSaved && node < bestRemoval)) {
                maxSaved = saved;
                bestRemoval = node;
            }
        }
    }
    
    free(uf->parent);
    free(uf->size);
    free(uf);
    free(componentInfectedCount);
    
    return bestRemoval;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²α(n))

O(n²) to process adjacency matrix + O(nα(n)) for Union-Find operations where α is inverse Ackermann

⚠ Quadratic Growth

Space Complexity

O(n)

Space for Union-Find parent and size arrays

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

980 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

Union-Find with Component Analysis — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler