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

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

✓ Binary Search on Answer

⏱️ Time: O(n² log(max_coord)) Space: O(1)

Instead of checking all points, binary search on the answer T. For each candidate time T, determine if there exists any point that can be reached by at least k virus variants within T days. This reduces the search space significantly.

Brute Force Enumeration

⏱️ Time: O(R² × n log n) Space: O(n)

For each possible point in a bounded grid area, calculate the Manhattan distance to all virus origins, sort these distances, and take the k-th smallest as the time needed for k variants to reach this point. Track the minimum across all points.

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 <string.h>
#include <ctype.h>

typedef struct {
    int x, y;
} Point;

int compareInts(const void* a, const void* b) {
    int ai = *(int*)a;
    int bi = *(int*)b;
    if (ai < bi) return -1;
    if (ai > bi) return 1;
    return 0;
}

int abs_val(int x) {
    return x < 0 ? -x : x;
}

static int xs[1001], ys[1001], distances[1001];

int minimumTimeForKVariants(Point* points, int n, int k) {
    if (k > n) {
        return -1;
    }
    
    // Collect all unique x and y coordinates
    for (int i = 0; i < n; i++) {
        xs[i] = points[i].x;
        ys[i] = points[i].y;
    }
    
    qsort(xs, n, sizeof(int), compareInts);
    qsort(ys, n, sizeof(int), compareInts);
    
    // Remove duplicates
    int nx = 1, ny = 1;
    for (int i = 1; i < n; i++) {
        if (xs[i] != xs[nx-1]) xs[nx++] = xs[i];
        if (ys[i] != ys[ny-1]) ys[ny++] = ys[i];
    }
    
    int minTime = 2000000000;
    
    // Check all combinations of x and y coordinates
    // Optimal point must use x from some point and y from some point
    for (int i = 0; i < nx; i++) {
        for (int j = 0; j < ny; j++) {
            int cx = xs[i];
            int cy = ys[j];
            
            // Calculate Manhattan distance to all points
            for (int p = 0; p < n; p++) {
                distances[p] = abs_val(cx - points[p].x) + abs_val(cy - points[p].y);
            }
            
            // Sort distances
            qsort(distances, n, sizeof(int), compareInts);
            
            // k-th smallest distance (0-indexed: k-1)
            if (distances[k-1] < minTime) {
                minTime = distances[k-1];
            }
        }
    }
    
    return minTime;
}

// Parse all integers from the input string
int parseAllInts(char* str, int* nums, int maxNums) {
    int count = 0;
    char* p = str;
    
    while (*p && count < maxNums) {
        // Skip non-digit, non-minus characters
        while (*p && !isdigit(*p) && *p != '-') p++;
        if (!*p) break;
        
        // Check if this minus is actually a negative sign (followed by digit)
        if (*p == '-' && !isdigit(*(p+1))) {
            p++;
            continue;
        }
        
        // Parse the integer
        int neg = 0;
        if (*p == '-') {
            neg = 1;
            p++;
        }
        
        int num = 0;
        while (*p && isdigit(*p)) {
            num = num * 10 + (*p - '0');
            p++;
        }
        
        if (neg) num = -num;
        nums[count++] = num;
    }
    
    return count;
}

static char line[500000];
static Point points[1000];
static int nums[2000];

int main() {
    int n = 0;
    int k = 0;
    
    // Read all input
    size_t total_len = 0;
    while (fgets(line + total_len, sizeof(line) - total_len, stdin)) {
        total_len += strlen(line + total_len);
    }
    
    // Find where points array ends (after the ]] for 2D array)
    char* points_end = NULL;
    char* p = line;
    int bracket_depth = 0;
    int found_start = 0;
    
    while (*p) {
        if (*p == '[') {
            if (!found_start) found_start = 1;
            bracket_depth++;
        } else if (*p == ']') {
            bracket_depth--;
            if (found_start && bracket_depth == 0) {
                points_end = p + 1;
                break;
            }
        }
        p++;
    }
    
    if (points_end) {
        // Parse points from start to points_end
        char temp = *points_end;
        *points_end = '\0';
        int num_count = parseAllInts(line, nums, 2000);
        *points_end = temp;
        
        // Convert to points (pairs of coordinates)
        n = num_count / 2;
        for (int i = 0; i < n; i++) {
            points[i].x = nums[2*i];
            points[i].y = nums[2*i + 1];
        }
        
        // Parse k from the rest
        int k_nums[10];
        int k_count = parseAllInts(points_end, k_nums, 10);
        if (k_count > 0) {
            k = k_nums[0];
        }
    }
    
    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