K Empty Slots

K Empty Slots - Problem

Array Binary Indexed Tree Segment Tree Queue Sliding Window Heap (Priority Queue) Ordered Set Monotonic Queue Hard

You have n bulbs in a row numbered from 1 to n. Initially, all the bulbs are turned off. We turn on exactly one bulb every day until all bulbs are on after n days.

You are given an array bulbs of length n where bulbs[i] = x means that on the (i+1)th day, we will turn on the bulb at position x where i is 0-indexed and x is 1-indexed.

Given an integer k, return the minimum day number such that there exists two turned on bulbs that have exactly k bulbs between them that are all turned off. If there isn't such day, return -1.

Input & Output

Example 1 — Basic Case

$ Input: bulbs = [1,3,2], k = 1

› Output: 2

💡 Note: Day 1: bulb 1 is on. Day 2: bulb 3 is on, now we have bulbs 1 and 3 with exactly 1 bulb (position 2) between them that is off. Return day 2.

Example 2 — No Valid Pattern

$ Input: bulbs = [1,2,3], k = 1

› Output: -1

💡 Note: Day 1: bulb 1 on. Day 2: bulbs 1,2 on (no gap). Day 3: bulbs 1,2,3 on (no valid k=1 gap). Return -1.

Example 3 — Larger Gap

$ Input: bulbs = [1,5,3], k = 2

› Output: -1

💡 Note: Day 1: bulb 1 on. Day 2: bulb 5 on, bulbs 1 and 5 have 3 positions between them (not k=2). Day 3: bulb 3 on, but no two lit bulbs have exactly k=2 positions between them. Return -1.

Constraints

1 ≤ bulbs.length ≤ 2 × 10⁴
1 ≤ bulbs[i] ≤ bulbs.length
bulbs is a permutation of numbers from 1 to bulbs.length
0 ≤ k ≤ 2 × 10⁴

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 12 M Microsoft 8

The key insight is that we only need to check newly lit bulbs against their immediate neighbors in sorted order. The optimal approach uses a sliding window technique to track adjacent lit bulbs, achieving O(n²) time in the worst case but much better in practice. For very large inputs, a Binary Indexed Tree can provide O(n log n) performance with efficient range queries.

Common Approaches

✓ Binary Indexed Tree (Fenwick Tree)

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

Use a Binary Indexed Tree to track lit bulbs and efficiently check if there are exactly k unlit bulbs between any two positions. This allows fast range sum queries.

Greedy

⏱️ Time: N/A Space: N/A

Brute Force Simulation

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

For each day, turn on the bulb and check all pairs of currently lit bulbs to see if any pair has exactly k bulbs between them.

Sliding Window with Adjacent Tracking

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

Maintain a list of lit bulb positions in sorted order. For each new bulb, only check its immediate neighbors since they form the smallest possible valid windows.

Binary Indexed Tree (Fenwick Tree) — Algorithm Steps

Build BIT to track lit bulb positions
For each new bulb, query ranges of size k+2
Return first day when valid range is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Update BIT

Mark new bulb position as lit

Range Query

Check if k+2 window has exactly 2 lit bulbs

Validate Gap

Confirm middle k positions are unlit

Code -

solution.c — C

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

int solution(int* bulbs, int bulbsSize, int k) {
    int* litPositions = (int*)malloc(bulbsSize * sizeof(int));
    int litCount = 0;
    
    for (int day = 0; day < bulbsSize; day++) {
        int pos = bulbs[day];
        
        // Find insertion point
        int idx = 0;
        while (idx < litCount && litPositions[idx] < pos) {
            idx++;
        }
        
        // Insert at position
        for (int i = litCount; i > idx; i--) {
            litPositions[i] = litPositions[i-1];
        }
        litPositions[idx] = pos;
        litCount++;
        
        // Check left neighbor
        if (idx > 0) {
            int left = litPositions[idx - 1];
            if (pos - left - 1 == k) {
                free(litPositions);
                return day + 1;
            }
        }
        
        // Check right neighbor
        if (idx < litCount - 1) {
            int right = litPositions[idx + 1];
            if (right - pos - 1 == k) {
                free(litPositions);
                return day + 1;
            }
        }
    }
    
    free(litPositions);
    return -1;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int bulbs[1000];
    int count = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            bulbs[count++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(bulbs, count, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each BIT update and query takes O(log n), done n times

⚡ Linearithmic

Space Complexity

O(n)

BIT array stores cumulative counts for positions

⚡ Linearithmic Space

28.5K 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 Indexed Tree (Fenwick Tree) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler