Minimum Time For K Virus Variants to Spread

Minimum Time For K Virus Variants to Spread - Problem

Virus Spread Simulation

Imagine an infinite 2D grid where n unique virus variants begin spreading simultaneously from different origin points. You are given a 2D array points, where points[i] = [xi, yi] represents the initial location of virus variant i on day 0.

Key mechanics:
• Each day, every infected cell spreads its virus(es) to all 4 neighboring cells (up, down, left, right)
• Multiple virus variants can coexist in the same cell without interfering
• Each variant spreads independently following Manhattan distance rules

Goal: Given an integer k, find the minimum number of days required for any single point in the grid to contain at least k different virus variants.

This is essentially finding the point that minimizes the sum of Manhattan distances to the k closest virus origins.

Input & Output

example_1.py — Basic case

$ Input: points = [[0,0], [1,1], [2,0]], k = 2

› Output: 1

💡 Note: On day 1, virus from (0,0) reaches (1,0), virus from (1,1) reaches (1,0). Point (1,0) contains 2 variants after 1 day.

example_2.py — Same starting points

$ Input: points = [[0,0], [0,0], [1,1]], k = 3

› Output: 1

💡 Note: Two variants start at (0,0), one at (1,1). Point (0,0) already has 2 variants on day 0, and gets the third variant from (1,1) on day 1.

example_3.py — Impossible case

$ Input: points = [[0,0], [1,1]], k = 3

› Output: -1

💡 Note: Only 2 virus variants exist, but we need 3. This is impossible.

Constraints

1 ≤ n ≤ 100
points[i].length == 2
-10⁶ ≤ x_i, y_i ≤ 10⁶
1 ≤ k ≤ n
All virus variants are distinct (even if starting at same point)

Visualization

Tap to expand

Key Insight: Find the point where k virus coverage diamonds intersect with minimum radius

Understanding the Visualization

Initial State

Virus variants positioned at given coordinates on day 0

Diamond Expansion

Each virus spreads in diamond pattern (Manhattan distance) daily

Coverage Analysis

Find intersections of k diamond-shaped coverage areas

Optimal Point

Identify point where k variants converge in minimum time

Key Takeaway

🎯 Key Insight: Transform the problem from finding optimal meeting points to geometric intersection of Manhattan distance diamonds. Binary search on time combined with coordinate transformation makes this efficient.

Asked in

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

The optimal approach uses binary search on the answer combined with geometric intersection analysis. Key insight: transform Manhattan distance diamonds into axis-aligned rectangles using coordinate transformation (u,v) = (x+y, x-y). For each candidate time T, check if any combination of k virus coverage areas intersect using interval intersection logic. Time complexity: O(n² log max_coord).

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer	O(n² log(max_coord))	O(1)	Binary search on time T, check if any point can be reached by k viruses in T days
Brute Force Enumeration	O(R² × n log n)	O(n)	Check all possible grid points within reasonable bounds

Binary Search on Answer — Algorithm Steps

Binary search on time T from 0 to maximum possible time
For each T, check if any point can be reached by k variants in T days
A point (x,y) is reachable by virus i in T days if |x-xi| + |y-yi| ≤ T
Use geometric intersection to find if k virus coverage areas overlap
Adjust search bounds based on feasibility

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search

Try time T = (left + right) / 2

Transform Coordinates

Convert Manhattan diamonds to axis-aligned squares

Check Intersections

Find if k coverage areas have common intersection

Adjust Bounds

Update left/right based on feasibility

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Point;

bool hasIntersection(Point* viruses, int count, int time) {
    long long minU = LLONG_MIN, maxU = LLONG_MAX;
    long long minV = LLONG_MIN, maxV = LLONG_MAX;
    
    for (int i = 0; i < count; i++) {
        long long u = viruses[i].x + viruses[i].y;
        long long v = viruses[i].x - viruses[i].y;
        
        if (u - time > minU) minU = u - time;
        if (u + time < maxU) maxU = u + time;
        if (v - time > minV) minV = v - time;
        if (v + time < maxV) maxV = v + time;
        
        if (minU > maxU || minV > maxV) {
            return false;
        }
    }
    
    return true;
}

bool canReachKVariantsHelper(Point* points, int n, int k, int time, int start, Point* current, int currentCount) {
    if (currentCount == k) {
        return hasIntersection(current, k, time);
    }
    
    for (int i = start; i < n; i++) {
        current[currentCount] = points[i];
        if (canReachKVariantsHelper(points, n, k, time, i + 1, current, currentCount + 1)) {
            return true;
        }
    }
    
    return false;
}

bool canReachKVariants(Point* points, int n, int k, int time) {
    Point* current = (Point*)malloc(k * sizeof(Point));
    bool result = canReachKVariantsHelper(points, n, k, time, 0, current, 0);
    free(current);
    return result;
}

int minimumTimeForKVariants(Point* points, int n, int k) {
    int left = 0, right = 2000000;
    
    while (left < right) {
        int mid = (left + right) / 2;
        if (canReachKVariants(points, n, k, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

int main() {
    Point points[] = {{0,0}, {1,1}};
    int n = 2, k = 2;
    printf("%d\n", minimumTimeForKVariants(points, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log(max_coord))

Binary search O(log max_coord) iterations, each checking O(n²) virus pair intersections

⚠ Quadratic Growth

Space Complexity

O(1)

Only need constant space for calculations

✓ Linear Space

24.6K Views

Medium Frequency

~35 min Avg. Time

892 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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler