Contain Virus

Contain Virus - Problem

A virus is spreading rapidly, and your task is to quarantine the infected area by installing walls.

The world is modeled as an m x n binary grid isInfected, where:

isInfected[i][j] == 0 represents uninfected cells
isInfected[i][j] == 1 represents cells contaminated with the virus

A wall can be installed between any two 4-directionally adjacent cells, on the shared boundary.

Every night, the virus spreads to all neighboring cells in all four directions unless blocked by a wall. Resources are limited - each day, you can install walls around only one region (the affected area that threatens the most uninfected cells the following night).

Return the number of walls used to quarantine all the infected regions. If the world will become fully infected, return the number of walls used.

Input & Output

Example 1 — Basic Containment

$ Input: isInfected = [[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,1],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]

› Output: 10

💡 Note: Two regions exist. Left region threatens 2 cells, right region threatens 4 cells. We contain the right region first with 10 walls, then the left spreads. Process continues until all contained.

Example 2 — Single Region

$ Input: isInfected = [[1,1,1],[1,0,1],[1,1,1]]

› Output: 4

💡 Note: Single infected region surrounds one uninfected cell. We need 4 walls to completely isolate the center cell from infection.

Example 3 — No Infection

$ Input: isInfected = [[0,0,0],[0,0,0],[0,0,0]]

› Output: 0

💡 Note: No infected cells exist, so no walls are needed.

Constraints

m == isInfected.length
n == isInfected[i].length
1 ≤ m, n ≤ 50
isInfected[i][j] is either 0 or 1
There will never be a tie for the region that threatens the most uninfected cells

Visualization

Tap to expand

Asked in

G Google 8 f Facebook 5

The key insight is to simulate day-by-day virus containment by always walling off the region that threatens the most uninfected cells next. Best approach uses BFS to find regions and track threatened cells. Time: O(m²n²), Space: O(mn)

Common Approaches

✓ Simulation Approach

⏱️ Time: O(m²n²) Space: O(mn)

Each day, we identify all connected infected regions, calculate how many uninfected cells each would spread to next, contain the most threatening region with walls, then spread the remaining regions.

Simulation Approach — Algorithm Steps

Step 1: Find all connected infected regions using DFS/BFS
Step 2: For each region, count threatened uninfected cells and walls needed
Step 3: Contain the region threatening most cells, spread others
Step 4: Repeat until no more infected regions exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Day 1: Find Regions

Identify all connected infected regions using BFS

Assess Threats

Count how many uninfected cells each region would spread to

Contain & Spread

Build walls around biggest threat, spread other regions

Code -

solution.c — C

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

#define MAX_SIZE 50

typedef struct {
    int r, c;
} Point;

typedef struct {
    Point points[MAX_SIZE * MAX_SIZE];
    int size;
} PointList;

int solution(int isInfected[][MAX_SIZE], int m, int n) {
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    int totalWalls = 0;
    
    while (true) {
        bool visited[MAX_SIZE][MAX_SIZE] = {false};
        PointList regions[MAX_SIZE];
        PointList threatened[MAX_SIZE];
        int regionCount = 0;
        
        // Find all infected regions
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (isInfected[i][j] == 1 && !visited[i][j]) {
                    regions[regionCount].size = 0;
                    threatened[regionCount].size = 0;
                    
                    // BFS to find region
                    Point queue[MAX_SIZE * MAX_SIZE];
                    int front = 0, rear = 0;
                    queue[rear++] = (Point){i, j};
                    visited[i][j] = true;
                    
                    bool threatenedSet[MAX_SIZE][MAX_SIZE] = {false};
                    
                    while (front < rear) {
                        Point curr = queue[front++];
                        regions[regionCount].points[regions[regionCount].size++] = curr;
                        
                        for (int d = 0; d < 4; d++) {
                            int nr = curr.r + directions[d][0];
                            int nc = curr.c + directions[d][1];
                            
                            if (nr >= 0 && nr < m && nc >= 0 && nc < n) {
                                if (isInfected[nr][nc] == 1 && !visited[nr][nc]) {
                                    visited[nr][nc] = true;
                                    queue[rear++] = (Point){nr, nc};
                                } else if (isInfected[nr][nc] == 0 && !threatenedSet[nr][nc]) {
                                    threatenedSet[nr][nc] = true;
                                    threatened[regionCount].points[threatened[regionCount].size++] = (Point){nr, nc};
                                }
                            }
                        }
                    }
                    
                    regionCount++;
                }
            }
        }
        
        if (regionCount == 0) break;
        
        // Find region threatening most cells
        int maxThreat = 0, containIdx = 0;
        for (int i = 0; i < regionCount; i++) {
            if (threatened[i].size > maxThreat) {
                maxThreat = threatened[i].size;
                containIdx = i;
            }
        }
        
        // Count walls needed
        int wallsNeeded = 0;
        for (int i = 0; i < regions[containIdx].size; i++) {
            Point p = regions[containIdx].points[i];
            for (int d = 0; d < 4; d++) {
                int nr = p.r + directions[d][0];
                int nc = p.c + directions[d][1];
                if ((nr >= 0 && nr < m && nc >= 0 && nc < n && isInfected[nr][nc] == 0) ||
                    (nr < 0 || nr >= m || nc < 0 || nc >= n)) {
                    wallsNeeded++;
                }
            }
        }
        
        totalWalls += wallsNeeded;
        
        // Contain the region
        for (int i = 0; i < regions[containIdx].size; i++) {
            Point p = regions[containIdx].points[i];
            isInfected[p.r][p.c] = -1;
        }
        
        // Spread other regions
        for (int i = 0; i < regionCount; i++) {
            if (i != containIdx) {
                for (int j = 0; j < threatened[i].size; j++) {
                    Point p = threatened[i].points[j];
                    isInfected[p.r][p.c] = 1;
                }
            }
        }
    }
    
    return totalWalls;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int isInfected[MAX_SIZE][MAX_SIZE];
    int m = 0, n = 0;
    
    // Parse 2D array - simplified parsing
    char* ptr = line + 1; // Skip first '['
    char* rowStart;
    
    while ((rowStart = strchr(ptr, '[')) != NULL) {
        rowStart++; // Skip '['
        char* rowEnd = strchr(rowStart, ']');
        *rowEnd = '\0';
        
        n = 0;
        char* token = strtok(rowStart, ",");
        while (token != NULL) {
            isInfected[m][n++] = atoi(token);
            token = strtok(NULL, ",");
        }
        
        m++;
        ptr = rowEnd + 1;
        if (*ptr == ']') break;
    }
    
    printf("%d\n", solution(isInfected, m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

Each day we scan the entire grid multiple times, worst case runs for mn days

⚠ Quadratic Growth

Space Complexity

O(mn)

Need visited arrays and sets to track regions and threatened cells

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~35 min Avg. Time

421 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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler