Minimum Recolors to Get K Consecutive Black Blocks

Minimum Recolors to Get K Consecutive Black Blocks - Problem

You are given a 0-indexed string blocks of length n, where blocks[i] is either 'W' or 'B', representing the color of the i^th block. The characters 'W' and 'B' denote the colors white and black, respectively.

You are also given an integer k, which is the desired number of consecutive black blocks.

In one operation, you can recolor a white block such that it becomes a black block.

Return the minimum number of operations needed such that there is at least one occurrence of k consecutive black blocks.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: We can change blocks[0] from 'W' to 'B' to get "BBBWWBBW", which has 3 consecutive black blocks at the beginning.

Example 2 — Already Optimal

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

› Output: 0

💡 Note: There are already 3 consecutive black blocks (BBB) in the string, so no operations are needed.

Example 3 — All White

$ Input: blocks = "WWWWW", k = 2

› Output: 2

💡 Note: We need to change any 2 consecutive white blocks to black blocks, requiring 2 operations.

Constraints

1 ≤ blocks.length ≤ 100
blocks[i] is either 'W' or 'B'
1 ≤ k ≤ blocks.length

Visualization

Tap to expand

Asked in

M Microsoft 15 a Amazon 12 A Apple 8

The sliding window approach is optimal. We maintain a window of size k and slide it across the string, efficiently counting white blocks that need to be recolored. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Check All Subarrays

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

For each starting position, examine the next k blocks and count how many white blocks need to be recolored. Keep track of the minimum operations needed across all possible k-length windows.

Sliding Window - Optimal

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

Maintain a sliding window of size k. Start by counting white blocks in the first window, then slide the window one position at a time, updating the count by removing the leftmost element and adding the new rightmost element.

Brute Force - Check All Subarrays — Algorithm Steps

Iterate through each possible starting position (0 to n-k)
For each position, count white blocks in the k-length window
Track the minimum number of white blocks found

Visualization

Tap to expand

Step-by-Step Walkthrough

Window 1

Check first k blocks and count white blocks

Window 2

Move window right by 1, recount all k blocks

Continue

Repeat until all windows checked, return minimum

Code -

solution.c — C

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

int solution(char* blocks, int k) {
    int n = strlen(blocks);
    int minOperations = INT_MAX;
    
    for (int i = 0; i <= n - k; i++) {
        int whiteCount = 0;
        for (int j = i; j < i + k; j++) {
            if (blocks[j] == 'W') {
                whiteCount++;
            }
        }
        if (whiteCount < minOperations) {
            minOperations = whiteCount;
        }
    }
    
    return minOperations;
}

int main() {
    char blocks[100001];
    int k;
    fgets(blocks, sizeof(blocks), stdin);
    blocks[strcspn(blocks, "\n")] = 0;
    scanf("%d", &k);
    
    int result = solution(blocks, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×k)

Outer loop runs n-k+1 times, inner loop runs k times

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track count and minimum

✓ Linear Space

23.4K 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

Brute Force - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler