Contain Virus - Practice Coding Problems

Contain Virus - Problem

Pandemic Containment Strategy

Imagine you're leading a global health organization tasked with containing a rapidly spreading virus. The world is represented as an m × n grid where each cell can be either infected (value 1) or healthy (value 0).

🦠 The Challenge: Every night, the virus spreads to all neighboring cells (up, down, left, right) unless blocked by walls. You have limited resources and can only build walls around one infected region per day.

🎯 Your Strategy: Each day, identify all connected infected regions and determine which one threatens the most healthy cells the next night. Build walls around that entire region to contain it permanently.

🏗️ Wall Building: Walls are built on the boundaries between cells. For example, if an infected cell is adjacent to 3 healthy cells, you need 3 wall segments to protect those healthy cells.

Goal: Return the total number of wall segments needed to contain all infected regions before they spread further. If the entire world becomes infected, return the walls used during the process.

Input & Output

example_1.py — Basic Grid

$ Input: [[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: Day 1: Two regions exist. Left region threatens 4 cells, right region threatens 4 cells. Since it's a tie, we choose the first one found. Build 7 walls around left region. Day 2: Right region threatens 4 cells, build 3 walls. Total: 10 walls.

example_2.py — Single Region

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

› Output: 4

💡 Note: Only one infected region exists, forming a ring around a healthy cell. We need 4 walls to protect the center healthy cell from being infected.

example_3.py — Already Contained

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

› Output: 13

💡 Note: Left region threatens 1 cell (center), right region threatens 4 cells. Day 1: Build 13 walls around right region. Day 2: Build 4 walls around left region. Total: 17 walls... Wait, let me recalculate: Day 1 builds walls around the more threatening right region (13 walls), then left region gets contained with 0 additional walls as it can't spread further.

Visualization

Tap to expand

Daily Simulation: Each iteration represents one day in the containment process2. Region Detection: Use DFS/BFS to find all connected infected areas3. Threat Calculation: Count healthy cells each region would infect tomorrow4. Strategic Priority: Always contain the most threatening region first5. Wall Counting: Sum perimeter segments needed for containment6. Spread Simulation: Remaining regions expand to adjacent cells

Understanding the Visualization

Scan for Outbreaks

Use DFS to identify all connected infected regions in the current grid state

Assess Threat Levels

For each region, count how many healthy cells would become infected tomorrow

Strategic Decision

Select the region that threatens the most healthy cells - this is our priority target

Build Containment

Calculate and build walls around the chosen region's perimeter (count wall segments)

Spread Simulation

Allow remaining uncontained regions to spread to adjacent healthy cells

Repeat Daily

Continue the process until all infected regions are contained or grid is fully infected

Key Takeaway

🎯 Key Insight: This is a greedy simulation problem where we must balance immediate containment with long-term strategy, always prioritizing regions that pose the greatest immediate threat to healthy areas.

Time & Space Complexity

Time Complexity

⏱️

O(d × m² × n²)

d days × (m×n grid traversal × m×n regions to check)

⚠ Quadratic Growth

Space Complexity

O(m × n)

Additional space for visited arrays, region tracking, and grid copies

⚡ Linearithmic Space

Constraints

m == isInfected.length
n == isInfected[i].length
1 ≤ m, n ≤ 50
isInfected[i][j] is either 0 or 1
There will always be a contiguous infected region that threatens the most uninfected cells on any given day

Asked in

G Google 28 a Amazon 15 f Meta 12 ⊞ Microsoft 8

The optimal approach uses simulation with DFS/BFS to model the daily containment process. Key insights: identify infected regions using graph traversal, calculate threat levels by counting endangered healthy cells, and always contain the most dangerous region first. Time complexity: O(d × m² × n²) where d is the number of days needed.

Common Approaches

Approach	Time	Space	Notes
✓ Naive Simulation with DFS	O(d × m² × n²)	O(m × n)	Repeatedly find all infected regions, simulate their spread, and contain the most threatening one

Naive Simulation with DFS — Algorithm Steps

Find all connected infected regions using DFS
For each region, count threatened healthy cells and required walls
Select the region threatening the most healthy cells
Build walls around that region (mark as contained)
Spread remaining regions to adjacent healthy cells
Repeat until all regions are contained or world is fully infected

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Infected Regions

Use DFS to identify all connected infected areas (shown in red)

Calculate Threats

For each region, count how many healthy cells (green) would be infected next

Build Strategic Walls

Contain the region threatening the most cells (walls shown as black borders)

Spread Remaining

Other regions spread to adjacent healthy cells

Repeat Process

Continue until all regions are contained

Code -

solution.c — C

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

#define MAX_SIZE 100

typedef struct {
    int r, c;
} Point;

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

int directions[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};

void dfs(int** grid, int rows, int cols, int r, int c, bool** visited, Region* region) {
    if (r < 0 || r >= rows || c < 0 || c >= cols) return;
    if (visited[r][c] || grid[r][c] != 1) return;
    
    visited[r][c] = true;
    region->points[region->size].r = r;
    region->points[region->size].c = c;
    region->size++;
    
    for (int i = 0; i < 4; i++) {
        dfs(grid, rows, cols, r + directions[i][0], c + directions[i][1], visited, region);
    }
}

void getThreatenedCells(int** grid, int rows, int cols, Region* region, int* threat, int* walls) {
    bool threatened[MAX_SIZE][MAX_SIZE] = {false};
    *threat = 0;
    *walls = 0;
    
    for (int i = 0; i < region->size; i++) {
        int r = region->points[i].r;
        int c = region->points[i].c;
        
        for (int j = 0; j < 4; j++) {
            int nr = r + directions[j][0];
            int nc = c + directions[j][1];
            
            if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && grid[nr][nc] == 0) {
                if (!threatened[nr][nc]) {
                    threatened[nr][nc] = true;
                    (*threat)++;
                }
                (*walls)++;
            }
        }
    }
}

int containVirus(int** isInfected, int isInfectedSize, int* isInfectedColSize) {
    int rows = isInfectedSize;
    int cols = isInfectedColSize[0];
    int totalWalls = 0;
    
    while (true) {
        // Create visited array
        bool** visited = (bool**)malloc(rows * sizeof(bool*));
        for (int i = 0; i < rows; i++) {
            visited[i] = (bool*)calloc(cols, sizeof(bool));
        }
        
        Region regions[MAX_SIZE];
        int regionCount = 0;
        
        // Find all infected regions
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (isInfected[i][j] == 1 && !visited[i][j]) {
                    regions[regionCount].size = 0;
                    dfs(isInfected, rows, cols, i, j, visited, &regions[regionCount]);
                    regionCount++;
                }
            }
        }
        
        // Free visited array
        for (int i = 0; i < rows; i++) {
            free(visited[i]);
        }
        free(visited);
        
        if (regionCount == 0) break;
        
        int maxThreat = -1, mostDangerous = -1, wallsNeeded = 0;
        
        for (int i = 0; i < regionCount; i++) {
            int threat, walls;
            getThreatenedCells(isInfected, rows, cols, &regions[i], &threat, &walls);
            if (threat > maxThreat) {
                maxThreat = threat;
                mostDangerous = i;
                wallsNeeded = walls;
            }
        }
        
        if (maxThreat == 0) break;
        
        totalWalls += wallsNeeded;
        
        // Mark most dangerous region as contained
        for (int i = 0; i < regions[mostDangerous].size; i++) {
            int r = regions[mostDangerous].points[i].r;
            int c = regions[mostDangerous].points[i].c;
            isInfected[r][c] = -1;
        }
        
        // Spread other regions
        bool newInfected[MAX_SIZE][MAX_SIZE] = {false};
        
        for (int i = 0; i < regionCount; i++) {
            if (i != mostDangerous) {
                for (int j = 0; j < regions[i].size; j++) {
                    int r = regions[i].points[j].r;
                    int c = regions[i].points[j].c;
                    
                    for (int k = 0; k < 4; k++) {
                        int nr = r + directions[k][0];
                        int nc = c + directions[k][1];
                        
                        if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && isInfected[nr][nc] == 0) {
                            newInfected[nr][nc] = true;
                        }
                    }
                }
            }
        }
        
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (newInfected[i][j]) {
                    isInfected[i][j] = 1;
                }
            }
        }
    }
    
    return totalWalls;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(d × m² × n²)

d days × (m×n grid traversal × m×n regions to check)

⚠ Quadratic Growth

Space Complexity

O(m × n)

Additional space for visited arrays, region tracking, and grid copies

⚡ Linearithmic Space

Constraints

m == isInfected.length
n == isInfected[i].length
1 ≤ m, n ≤ 50
isInfected[i][j] is either 0 or 1
There will always be a contiguous infected region that threatens the most uninfected cells on any given day

71.2K Views

Medium Frequency

~35 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Naive Simulation with DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler