Apply Operations to Make Two Strings Equal

Apply Operations to Make Two Strings Equal - Problem

You're given two binary strings s1 and s2 of equal length n, and a positive integer x. Your goal is to transform s1 into s2 using the minimum cost operations.

Available Operations:

Operation 1: Choose any two indices i and j, flip both s1[i] and s1[j] (cost: x)
Operation 2: Choose an index i where i < n-1, flip both s1[i] and s1[i+1] (cost: 1)

Flipping a character means changing '0' to '1' or '1' to '0'. Return the minimum cost to make the strings equal, or -1 if impossible.

Example: If s1 = "1100" and s2 = "0011", you need to fix positions 0, 1, 2, and 3. You could use adjacent flips (cost 1 each) or strategic any-two-indices flips (cost x each).

Input & Output

example_1.py — Basic Case

$ Input: s1 = "1100", s2 = "0011", x = 3

› Output: 4

💡 Note: Differences at positions [0,1,2,3]. We can pair (0,1) with adjacent operation (cost 1) and (2,3) with adjacent operation (cost 1), but positions 1 and 2 are also adjacent. Optimal: pair (0,3) with any-pair operation (cost 3) and (1,2) with adjacent operation (cost 1), total = 4.

example_2.py — Impossible Case

$ Input: s1 = "100", s2 = "001", x = 2

› Output: -1

💡 Note: Differences at positions [0,2]. Since we have odd number of differences (1 difference at positions 0 and 2 = 2 total, but we need pairs), it's impossible to make them equal using operations that flip exactly 2 positions each.

example_3.py — All Adjacent

$ Input: s1 = "0000", s2 = "1111", x = 10

› Output: 2

💡 Note: Differences at all positions [0,1,2,3]. We can pair adjacent positions: (0,1) with cost 1 and (2,3) with cost 1. Total cost = 2, which is much better than using any-pair operations.

Visualization

Tap to expand

Understanding the Visualization

Identify Mismatches

Find all positions where s1 and s2 differ - these are our 'broken switches'

Check Feasibility

If odd number of differences, impossible since each operation fixes exactly 2 positions

Optimal Pairing

Use DP to find minimum cost pairing: adjacent fixes cost 1, any-pair fixes cost x

Apply Operations

Execute the optimal sequence of operations to transform s1 into s2

Key Takeaway

🎯 Key Insight: The problem reduces to optimally pairing difference positions. Use dynamic programming with memoization to explore all pairing possibilities while avoiding redundant calculations. Always prefer adjacent operations (cost 1) over any-pair operations (cost x) when possible.

Time & Space Complexity

Time Complexity

⏱️

O(n^2 * 2^k)

Where k is number of differences. With memoization, many subproblems are avoided

⚠ Quadratic Growth

Space Complexity

O(2^k)

Space for memoization table storing results for different subsequences

✓ Linear Space

Constraints

1 ≤ n ≤ 1000 where n is the length of both strings
1 ≤ x ≤ 10⁶
s1 and s2 consist of only characters '0' and '1'
Both strings have equal length

Asked in

G Google 28 f Meta 22 a Amazon 18 ⊞ Microsoft 15

The optimal approach uses dynamic programming with bitmask to represent states of unfixed differences. Key insight: each operation flips exactly 2 positions, so we need an even number of differences. The algorithm tries pairing each unfixed position optimally, choosing between adjacent operations (cost 1) and any-pair operations (cost x). Memoization prevents redundant calculations, achieving much better performance than brute force.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(n)	Try every possible sequence of operations to find minimum cost
Dynamic Programming (Optimal)	O(n^2 * 2^k)	O(2^k)	Use DP to find optimal pairing of difference positions with memoization

Brute Force (Try All Combinations) — Algorithm Steps

Find all positions where s1 and s2 differ
Generate all possible ways to pair these positions
For each pairing, calculate cost using adjacent operations where possible
Try all combinations of operations and track minimum cost
Return minimum cost found, or -1 if no solution exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Differences

Identify all positions where s1 and s2 differ

Generate Combinations

Create all possible ways to pair up difference positions

Calculate Costs

For each combination, compute cost using available operations

Find Minimum

Return the minimum cost among all valid combinations

Code -

solution.c — C

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

int solveBruteForce(int* diffs, int diffCount, int cost, int x) {
    if (diffCount == 0) return cost;
    if (diffCount == 1) return INT_MAX;
    
    int minCost = INT_MAX;
    
    for (int i = 1; i < diffCount; i++) {
        int* newDiffs = (int*)malloc((diffCount - 2) * sizeof(int));
        int newCount = 0;
        
        for (int j = 1; j < diffCount; j++) {
            if (j != i) {
                newDiffs[newCount++] = diffs[j];
            }
        }
        
        // Operation 1
        if (cost <= INT_MAX - x) {
            int op1Cost = solveBruteForce(newDiffs, newCount, cost + x, x);
            if (op1Cost != INT_MAX && op1Cost < minCost) {
                minCost = op1Cost;
            }
        }
        
        // Operation 2
        if (diffs[i] == diffs[0] + 1 && cost <= INT_MAX - 1) {
            int op2Cost = solveBruteForce(newDiffs, newCount, cost + 1, x);
            if (op2Cost != INT_MAX && op2Cost < minCost) {
                minCost = op2Cost;
            }
        }
        
        free(newDiffs);
    }
    
    return minCost;
}

int minOperations(char* s1, char* s2, int x) {
    int n = strlen(s1);
    int* diffs = (int*)malloc(n * sizeof(int));
    int diffCount = 0;
    
    for (int i = 0; i < n; i++) {
        if (s1[i] != s2[i]) {
            diffs[diffCount++] = i;
        }
    }
    
    if (diffCount % 2 == 1) {
        free(diffs);
        return -1;
    }
    if (diffCount == 0) {
        free(diffs);
        return 0;
    }
    
    int result = solveBruteForce(diffs, diffCount, 0, x);
    free(diffs);
    return result == INT_MAX ? -1 : result;
}

int main() {
    printf("Implementation requires JSON parsing\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we try all possible combinations of operations, which can be exponential

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing difference positions and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000 where n is the length of both strings
1 ≤ x ≤ 10⁶
s1 and s2 consist of only characters '0' and '1'
Both strings have equal length

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler