Number of Distinct Binary Strings After Applying Operations

Number of Distinct Binary Strings After Applying Operations - Problem

Math String Medium

You are given a binary string s and a positive integer k. You can apply the following operation on the string any number of times:

Choose any substring of size k from s and flip all its characters, that is, turn all 1's into 0's, and all 0's into 1's.

Return the number of distinct strings you can obtain. Since the answer may be too large, return it modulo 10⁹ + 7.

Note that:

A binary string is a string that consists only of the characters 0 and 1.
A substring is a contiguous part of a string.

Input & Output

Example 1 — Basic Case

$ Input: s = "001", k = 2

› Output: 4

💡 Note: We can flip positions [0,1] to get "111", or flip [1,2] to get "010". From "111" we can get "100" by flipping [1,2]. From "010" we can get "100" by flipping [0,1]. All reachable states are: {"001", "111", "010", "100"} giving us 4 distinct strings.

Example 2 — Single Operation

$ Input: s = "10", k = 2

› Output: 2

💡 Note: We can apply the flip operation at position 0 to get "01". So we have 2 distinct strings: "10" and "01".

Example 3 — No Operations Possible

$ Input: s = "1", k = 2

› Output: 1

💡 Note: String length is 1 but k=2, so no flip operations are possible. Only the original string "1" exists.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only '0' and '1'
1 ≤ k ≤ s.length

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is modeling flip operations as linear transformations over GF(2). Each k-flip creates a row in a matrix, and the rank determines how many distinct states are reachable. Best approach uses Linear Algebra with Gaussian elimination. Time: O(n³), Space: O(n²)

Common Approaches

✓ Brute Force with BFS

⏱️ Time: O(2^n) Space: O(2^n)

Use BFS to explore all reachable states by applying the flip operation at every possible position. Keep track of visited states to avoid duplicates and count the total number of distinct strings.

Linear Algebra over GF(2)

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

Represent each flip operation as a vector in GF(2) and find the dimension of the vector space spanned by all possible operations. The number of distinct strings equals 2^dimension.

Brute Force with BFS — Algorithm Steps

Step 1: Start with the original string in a queue
Step 2: For each string, try flipping every possible substring of length k
Step 3: Add new strings to queue if not seen before
Step 4: Continue until no new states can be generated

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original binary string

Generate Variants

Apply k-flip operation at each position

Explore New States

Continue from each unique string found

Count Results

Total distinct strings reachable

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_STATES 100000

char states[MAX_STATES][21];
int stateCount = 0;

int findState(char* s) {
    for (int i = 0; i < stateCount; i++) {
        if (strcmp(states[i], s) == 0) {
            return i;
        }
    }
    return -1;
}

void addState(char* s) {
    if (findState(s) == -1) {
        strcpy(states[stateCount], s);
        stateCount++;
    }
}

int solution(char* s, int k) {
    int len = strlen(s);
    char queue[MAX_STATES][21];
    int front = 0, rear = 0;
    
    strcpy(queue[rear], s);
    rear++;
    addState(s);
    
    while (front < rear) {
        char current[21];
        strcpy(current, queue[front]);
        front++;
        
        // Try flipping every substring of length k
        for (int i = 0; i <= len - k; i++) {
            char flipped[21];
            strcpy(flipped, current);
            
            for (int j = i; j < i + k; j++) {
                flipped[j] = flipped[j] == '0' ? '1' : '0';
            }
            
            if (findState(flipped) == -1) {
                addState(flipped);
                strcpy(queue[rear], flipped);
                rear++;
            }
        }
    }
    
    return stateCount % MOD;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we might generate up to 2^n different strings

⚠ Quadratic Growth

Space Complexity

O(2^n)

Set stores all possible distinct strings, queue holds pending states

⚠ Quadratic Space

15.2K Views

Medium Frequency

~35 min Avg. Time

487 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 with BFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler