Minimize Malware Spread II - Practice Coding Problems

Minimize Malware Spread II - Problem

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

Imagine a computer network under cyber attack! You have a network of n nodes represented as an n x n adjacency matrix graph, where nodes are connected if graph[i][j] == 1.

The Attack Scenario: Some nodes in the initial array are already infected with malware. The malware spreads through direct connections - whenever two nodes are connected and at least one is infected, both become infected. This continues until no more nodes can be infected.

Your Mission: You can completely remove exactly one infected node (and all its connections) from the network before the malware spreads. Your goal is to minimize the final number of infected nodes M(initial).

Return: The index of the node to remove that minimizes the spread. If multiple nodes give the same minimum result, return the smallest index.

Input & Output

example_1.py — Basic network

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

› Output: 0

💡 Note: Removing node 0 leaves only node 1 infected, which can infect node 2 through their connection, resulting in 1 infected node total. Removing node 1 would leave node 0 infected, which can still reach node 2, also resulting in 1 infected node. We return 0 (smaller index).

example_2.py — Isolated components

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

› Output: 0

💡 Note: Nodes are isolated, so removing either infected node results in 1 remaining infected node. Return the smaller index (0).

example_3.py — Bridge node removal

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

› Output: 1

💡 Note: Node 1 acts as a bridge. Removing node 1 isolates node 0, leaving only node 0 infected (1 total). Removing node 0 leaves node 1 connected to nodes 2,3, resulting in 3 infected nodes total. Better to remove node 1.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Identify Infected Buildings

Start with multiple infected buildings (nodes) connected by bridges (edges)

Analyze Demolition Impact

For each infected building, simulate what happens if we demolish it completely

Calculate Spread

See how zombies spread from remaining infected buildings through connected bridges

Choose Optimal Demolition

Select the building whose removal results in minimum total infected buildings

Key Takeaway

🎯 Key Insight: The optimal strategy focuses on identifying and removing bridge nodes that connect multiple components. By analyzing the graph structure with Union-Find, we can efficiently determine which infected node's removal will minimize the total spread.

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 25

The optimal approach uses Union-Find data structure to efficiently analyze connected components. For each infected node, we temporarily remove it and calculate the resulting malware spread by examining which components remain infected. The key insight is that removing a node is only beneficial if it disconnects infected components or prevents uninfected components from being reached. Time complexity is O(n²α(n)) where α is the inverse Ackermann function.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find Optimization	O(n² α(n) + k × n)	O(n)	Use Union-Find to efficiently track connected components and calculate impact
Simulation for Each Removal	O(k * n²)	O(n²)	Try removing each infected node and simulate the malware spread

Union-Find Optimization — Algorithm Steps

Build Union-Find structure for the entire graph
Identify connected components and their sizes
For each infected node, calculate how many uninfected nodes it could potentially infect
Find the infected node whose removal saves the most nodes
Return the node with minimum index among optimal choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Union-Find

Create Union-Find structure excluding the node to be removed

Identify Components

Find all connected components and their sizes

Count Infected per Component

Determine how many infected nodes are in each component

Calculate Total Spread

Sum up sizes of all components that have at least one infected node

Code -

solution.c — C

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

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

UnionFind* createUF(int n) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->rank = (int*)calloc(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 unionNodes(UnionFind* uf, int x, int y) {
    int px = find(uf, x), py = find(uf, y);
    if (px == py) return;
    if (uf->rank[px] < uf->rank[py]) {
        int temp = px; px = py; py = temp;
    }
    uf->parent[py] = px;
    uf->size[px] += uf->size[py];
    if (uf->rank[px] == uf->rank[py]) uf->rank[px]++;
}

void freeUF(UnionFind* uf) {
    free(uf->parent);
    free(uf->rank);
    free(uf->size);
    free(uf);
}

int minMalwareSpread(int** graph, int graphSize, int* graphColSize, int* initial, int initialSize) {
    int n = graphSize;
    int* initialSet = (int*)calloc(n, sizeof(int));
    for (int i = 0; i < initialSize; i++) {
        initialSet[initial[i]] = 1;
    }
    
    int minInfected = INT_MAX;
    int result = initial[0];
    for (int i = 1; i < initialSize; i++) {
        if (initial[i] < result) result = initial[i];
    }
    
    for (int idx = 0; idx < initialSize; idx++) {
        int removeNode = initial[idx];
        UnionFind* uf = createUF(n);
        
        // Build Union-Find excluding removeNode
        for (int i = 0; i < n; i++) {
            if (i == removeNode) continue;
            for (int j = i + 1; j < n; j++) {
                if (j == removeNode) continue;
                if (graph[i][j] == 1) {
                    unionNodes(uf, i, j);
                }
            }
        }
        
        // Count infected nodes in each component
        int* componentInfected = (int*)calloc(n, sizeof(int));
        int* rootExists = (int*)calloc(n, sizeof(int));
        
        for (int node = 0; node < n; node++) {
            if (node == removeNode) continue;
            int root = find(uf, node);
            rootExists[root] = 1;
            if (initialSet[node]) {
                componentInfected[root]++;
            }
        }
        
        // Calculate total infected after spread
        int totalInfected = 0;
        for (int root = 0; root < n; root++) {
            if (rootExists[root] && componentInfected[root] > 0) {
                totalInfected += uf->size[root];
            }
        }
        
        if (totalInfected < minInfected || (totalInfected == minInfected && removeNode < result)) {
            minInfected = totalInfected;
            result = removeNode;
        }
        
        freeUF(uf);
        free(componentInfected);
        free(rootExists);
    }
    
    free(initialSet);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² α(n) + k × n)

Union-Find operations with near-constant amortized time, plus analysis for each infected node

⚠ Quadratic Growth

Space Complexity

O(n)

Union-Find parent and rank arrays, plus auxiliary data structures

⚡ Linearithmic Space

28.5K Views

Medium-High Frequency

~25 min Avg. Time

875 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 Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler