Count the Number of Infection Sequences - Problem

You are given an integer n and an array sick sorted in increasing order, representing positions of infected people in a line of n people (positions 0 to n-1).

At each step, one uninfected person adjacent to an infected person gets infected. This process continues until everyone is infected.

An infection sequence is the order in which uninfected people become infected, excluding those initially infected.

Return the number of different infection sequences possible, modulo 10^9 + 7.

Input & Output

Example 1 — Basic Internal Segment

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

› Output: 4

💡 Note: Uninfected people are [1,2,3]. Person 1 can only be infected by 0, and person 3 can only be infected by 4. Person 2 can be infected by either 1 or 3, creating multiple valid sequences: [1,2,3], [1,3,2], [2,1,3], [3,2,1].

Example 2 — Single Gap

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

› Output: 2

💡 Note: Uninfected people are [0,2]. Position 0 can only be infected by 1, position 2 can only be infected by 3. Valid sequences: [0,2] and [2,0].

Example 3 — All Initially Sick

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

› Output: 1

💡 Note: Everyone is already infected, so there's only one empty sequence (no one to infect).

Constraints

2 ≤ n ≤ 10⁵
1 ≤ sick.length ≤ n
0 ≤ sick[i] ≤ n - 1
sick is sorted in increasing order

Visualization

Tap to expand

Asked in

G Google 12 f Meta 8 a Amazon 6

The key insight is that infection spreads in segments between initially infected people. Each internal segment of size k can be filled in 2^(k-1) ways. The optimal approach uses combinatorics to count sequences mathematically instead of generating them. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Sequences

⏱️ Time: O((n-k)!) Space: O(n)

For each uninfected person, try all possible orders of infection. Check if each sequence follows the adjacency rule where infection can only spread to neighbors of already infected people.

Dynamic Programming with Combinatorics

⏱️ Time: O(n) Space: O(1)

Divide the problem into segments between initially infected people. Each segment can be filled independently. Use combinatorics to count the number of ways to fill each segment, then multiply the results.

Brute Force - Try All Sequences — Algorithm Steps

Identify all uninfected positions
Generate all permutations of uninfected people
For each permutation, simulate infection process
Count valid sequences that follow adjacency rules

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Uninfected

Find all positions not initially sick

Generate Permutations

Create all possible infection orders

Validate Sequences

Check each sequence follows adjacency rule

Count Valid

Sum up all valid infection sequences

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 100

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

bool nextPermutation(int* arr, int n) {
    int i = n - 2;
    while (i >= 0 && arr[i] >= arr[i + 1]) i--;
    if (i == -1) return false;
    
    int j = n - 1;
    while (arr[j] <= arr[i]) j--;
    swap(&arr[i], &arr[j]);
    
    int left = i + 1, right = n - 1;
    while (left < right) {
        swap(&arr[left], &arr[right]);
        left++;
        right--;
    }
    return true;
}

int solution(int n, int* sick, int sickSize) {
    bool isSick[MAX_N] = {false};
    for (int i = 0; i < sickSize; i++) {
        isSick[sick[i]] = true;
    }
    
    int uninfected[MAX_N];
    int uninfectedSize = 0;
    for (int i = 0; i < n; i++) {
        if (!isSick[i]) {
            uninfected[uninfectedSize++] = i;
        }
    }
    
    if (uninfectedSize == 0) return 1;
    
    int count = 0;
    
    do {
        bool infected[MAX_N];
        for (int i = 0; i < n; i++) {
            infected[i] = isSick[i];
        }
        
        bool valid = true;
        for (int i = 0; i < uninfectedSize; i++) {
            int person = uninfected[i];
            bool adjacent = false;
            
            if (person > 0 && infected[person - 1]) adjacent = true;
            if (person < n - 1 && infected[person + 1]) adjacent = true;
            
            if (!adjacent) {
                valid = false;
                break;
            }
            
            infected[person] = true;
        }
        
        if (valid) count++;
    } while (nextPermutation(uninfected, uninfectedSize));
    
    return count % MOD;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[1000];
    scanf(" %s", line);
    
    int sick[MAX_N];
    int sickSize = 0;
    
    if (strlen(line) > 2) {
        char* p = line + 1;
        while (*p && *p != ']') {
            if (*p >= '0' && *p <= '9') {
                sick[sickSize++] = (int)strtol(p, &p, 10);
            } else {
                p++;
            }
        }
    }
    
    printf("%d\n", solution(n, sick, sickSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((n-k)!)

Generate all permutations of uninfected people, where k is number of initially sick

✓ Linear Growth

Space Complexity

O(n)

Store infection state and current sequence

✓ Linear Space

8.8K Views

Medium Frequency

~35 min Avg. Time

234 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

Count the Number of Infection Sequences - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Sequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler