Count the Number of Infection Sequences - Practice Coding Problems

Count the Number of Infection Sequences - Problem

Pandemic Spread Simulation

Imagine a pandemic spreading through a line of n people, where some individuals are initially infected. You're given an integer n representing the total number of people and an array sick (sorted in increasing order) representing the positions of people who are already infected.

The infection spreads with these rules:
• At each time step, exactly one uninfected person adjacent to an infected person becomes infected
• This continues until everyone is infected
• An infection sequence is the specific order in which the uninfected people become infected

Goal: Calculate how many different infection sequences are possible.

Example: If n=5 and sick=[0,4] (positions 0 and 4 are infected), the infection can spread inward from both ends. Person at position 1 or 3 could be infected first, leading to different sequences.

Return the answer modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: n = 5, sick = [0, 4]

› Output: 4

💡 Note: People at positions 0 and 4 are initially infected. The infection can spread inward. Possible sequences: [1,2,3], [1,3,2], [3,2,1], [3,1,2] - total of 4 different sequences.

example_2.py — Single Group

$ Input: n = 4, sick = [1]

› Output: 6

💡 Note: Only position 1 is infected initially. Infection can spread left to 0 and right to 2,3. The sequences are different orderings of [0,2,3], giving us 3! = 6 possibilities.

example_3.py — All Infected

$ Input: n = 3, sick = [0, 1, 2]

› Output: 1

💡 Note: Everyone is already infected, so there's only 1 way (no additional infections needed).

Constraints

1 ≤ n ≤ 10⁵
1 ≤ sick.length ≤ n
0 ≤ sick[i] ≤ n - 1
sick is sorted in increasing order
All values in sick are distinct

Visualization

Tap to expand

Combinatorial Formula:• Boundary groups: Choose when in sequence to infect (binomial coefficient)• Middle groups: Choose when + choose direction (binomial × 2^(size-1))• Total: Product of all group possibilities (multiplication principle)

Understanding the Visualization

Identify Groups

Split uninfected people into isolated groups between infected positions

Group Independence

Each group spreads independently - use multiplication principle

Calculate Coefficients

For each group, calculate how many ways it can be infected using combinatorics

Combine Results

Multiply all group possibilities to get total sequences

Key Takeaway

🎯 Key Insight: Transform the infection simulation problem into a combinatorial counting problem by recognizing that isolated groups of uninfected people spread independently, allowing us to use mathematical formulas instead of expensive simulation.

Asked in

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

The optimal approach uses combinatorial mathematics instead of simulation. Key insight: identify isolated groups of uninfected people between infected positions, then use multinomial coefficients to count infection sequences for each group independently. Time complexity: O(n), much faster than the exponential brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Combinatorial Mathematics (Optimal)	O(n)	O(1)	Use multinomial coefficients to count infection sequences mathematically
Recursive Simulation (Brute Force)	O(2^n)	O(n)	Simulate every possible infection sequence using recursion

Combinatorial Mathematics (Optimal) — Algorithm Steps

Identify isolated groups of uninfected people between infected positions
For each group of size k, calculate multinomial coefficient for infection from both ends
Handle edge groups (at boundaries) that only spread from one direction
Multiply all group possibilities together
Apply modular arithmetic throughout to prevent overflow

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Groups

Find isolated segments between infected positions

Calculate Coefficients

For each group, determine infection possibilities

Multiply Results

Combine all group possibilities using multiplication principle

Code -

solution.c — C

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

#define MOD 1000000007

long long factorial(int x) {
    if (x <= 1) return 1;
    long long result = 1;
    for (int i = 2; i <= x; i++) {
        result = (result * i) % MOD;
    }
    return result;
}

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    base = base % mod;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        exp = exp / 2;
        base = (base * base) % mod;
    }
    return result;
}

long long modInverse(long long x) {
    return modPow(x, MOD - 2, MOD);
}

long long multinomialCoeff(int n, int groupSize) {
    if (n == 0) return 1;
    long long num = factorial(n);
    long long den = factorial(groupSize);
    return (num * modInverse(den)) % MOD;
}

long long numberOfSequences(int n, int* sick, int sickSize) {
    if (sickSize == n) return 1;
    
    int* groups = (int*)malloc(n * sizeof(int));
    int groupCount = 0;
    int totalUninfected = n - sickSize;
    
    // Left boundary
    if (sick[0] > 0) {
        groups[groupCount++] = sick[0];
    }
    
    // Middle groups
    for (int i = 1; i < sickSize; i++) {
        int gap = sick[i] - sick[i-1] - 1;
        if (gap > 0) {
            groups[groupCount++] = gap;
        }
    }
    
    // Right boundary
    if (sick[sickSize-1] < n - 1) {
        groups[groupCount++] = n - 1 - sick[sickSize-1];
    }
    
    if (groupCount == 0) {
        free(groups);
        return 1;
    }
    
    long long result = 1;
    int remaining = totalUninfected;
    
    for (int i = 0; i < groupCount; i++) {
        if (groups[i] == 0) continue;
        long long coeff = multinomialCoeff(remaining, groups[i]);
        result = (result * coeff) % MOD;
        remaining -= groups[i];
    }
    
    free(groups);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int* sick = (int*)malloc(n * sizeof(int));
    int sickSize = 0;
    int pos;
    
    while (scanf("%d", &pos) == 1) {
        sick[sickSize++] = pos;
    }
    
    printf("%lld\n", numberOfSequences(n, sick, sickSize));
    
    free(sick);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to identify groups plus factorial calculations, which are bounded by group sizes

✓ Linear Growth

Space Complexity

O(1)

Only need constant extra space for calculations, no recursion or large data structures

✓ Linear Space

26.1K Views

Medium Frequency

~35 min Avg. Time

847 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

Combinatorial Mathematics (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler