Minimum Recolors to Get K Consecutive Black Blocks

Minimum Recolors to Get K Consecutive Black Blocks - Problem

Painting Challenge: Transform a row of blocks to create a sequence of consecutive black blocks!

You're given a string blocks where each character represents a colored block: 'B' for black and 'W' for white. Your goal is to find the minimum number of white blocks you need to repaint to black in order to have at least k consecutive black blocks.

The Rules:
• You can only change white blocks ('W') to black blocks ('B')
• You cannot change black blocks to white
• You need at least one occurrence of k consecutive black blocks

Example: If blocks = "WBBWWBBWBW" and k = 7, you need to find the best window of 7 consecutive positions and count how many white blocks need to be painted black.

Input & Output

example_1.py — Basic Case

$ Input: blocks = "WBBWWBBWBW", k = 7

› Output: 3

💡 Note: We need a window of 7 consecutive blocks. The optimal window is from index 1 to 7: "BBWWBBW". This contains 3 white blocks that need to be recolored to black.

example_2.py — All Black

$ Input: blocks = "BBBBBB", k = 4

› Output: 0

💡 Note: We already have more than 4 consecutive black blocks, so no recoloring is needed. Any window of size 4 will have 0 white blocks.

example_3.py — All White

$ Input: blocks = "WWWWWW", k = 3

› Output: 3

💡 Note: All blocks are white, so any window of size 3 will require recoloring all 3 white blocks to black.

Constraints

1 ≤ blocks.length ≤ 100
blocks[i] is either 'W' or 'B'
1 ≤ k ≤ blocks.length
k cannot be larger than the total number of blocks

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Start with the first k blocks and count white blocks

Slide and Update

Move window right, remove left element, add right element

Track Minimum

Keep track of the minimum white count across all windows

Return Result

The minimum white count is our answer

Key Takeaway

🎯 Key Insight: The sliding window technique transforms this from an O(n×k) problem to O(n) by maintaining a running count and updating it incrementally rather than recounting the entire window each time.

Asked in

a Amazon 25 ⊞ Microsoft 18 G Google 15 f Meta 12

The optimal solution uses the sliding window technique to achieve O(n) time complexity. Instead of recounting white blocks for each window position, we maintain a running count and efficiently update it by adding/removing one element as the window slides. This transforms an O(n×k) brute force approach into an elegant O(n) solution.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to efficiently count white blocks in each window
Brute Force (Check All Windows)	O(n × k)	O(1)	Check every possible window of size k and count white blocks in each

Sliding Window (Optimal) — Algorithm Steps

Count white blocks in the first window of size k
Set this as the initial minimum recolors needed
Slide the window one position to the right
Update the count: subtract 1 if the left element leaving is 'W', add 1 if the right element entering is 'W'
Update the minimum recolors if current count is smaller
Repeat until all windows are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize first window

Count white blocks in positions 0 to k-1

Slide window right

Remove leftmost element, add new rightmost element

Update count efficiently

Adjust count based on what left and what entered

Track minimum

Keep track of minimum white count seen

Code -

solution.c — C

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

int minimumRecolors(char* blocks, int k) {
    int n = strlen(blocks);
    
    // Count white blocks in first window
    int whiteCount = 0;
    for (int i = 0; i < k; i++) {
        if (blocks[i] == 'W') {
            whiteCount++;
        }
    }
    
    int minRecolors = whiteCount;
    
    // Slide the window
    for (int i = k; i < n; i++) {
        // Remove the leftmost element from window
        if (blocks[i - k] == 'W') {
            whiteCount--;
        }
        
        // Add the new rightmost element to window
        if (blocks[i] == 'W') {
            whiteCount++;
        }
        
        // Update minimum
        if (whiteCount < minRecolors) {
            minRecolors = whiteCount;
        }
    }
    
    return minRecolors;
}

int main() {
    char blocks[1001];
    int k;
    fgets(blocks, sizeof(blocks), stdin);
    // Remove quotes and newline
    int len = strlen(blocks);
    if (blocks[len-1] == '\n') blocks[len-1] = '\0';
    if (blocks[0] == '"') {
        memmove(blocks, blocks+1, len-1);
        len = strlen(blocks);
        if (blocks[len-1] == '"') blocks[len-1] = '\0';
    }
    scanf("%d", &k);
    printf("%d\n", minimumRecolors(blocks, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each element at most twice - once when entering window, once when leaving

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track the current window count and minimum

✓ Linear Space

28.5K Views

Medium Frequency

~15 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

Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler