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.

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

Visualization

Tap to expand

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

✓ Greedy

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

Brute Force (Try All Combinations)

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

Generate all possible ways to apply operations and track the minimum cost. This approach explores every combination of using adjacent flips vs any-two-indices flips.

Dynamic Programming (Optimal)

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

This approach recognizes that we need to optimally pair up difference positions. We use dynamic programming to find the minimum cost way to resolve all differences, considering both adjacent operations (cost 1) and any-pair operations (cost x).

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(char* s1, char* s2, int x) {
    int len = strlen(s1);
    static int diffPositions[1000];
    int diffCount = 0;
    
    // Find all positions where strings differ
    for (int i = 0; i < len; i++) {
        if (s1[i] != s2[i]) {
            diffPositions[diffCount++] = i;
        }
    }
    
    // If odd number of differences, impossible to fix
    if (diffCount % 2 == 1) {
        return -1;
    }
    
    if (diffCount == 0) {
        return 0;
    }
    
    // Greedy approach: pair differences optimally
    int totalCost = 0;
    int i = 0;
    
    while (i < diffCount) {
        // Check if current and next positions are adjacent
        if (i + 1 < diffCount && diffPositions[i + 1] == diffPositions[i] + 1) {
            // Adjacent positions: choose min cost between adjacent flip (1) and any-pair flip (x)
            if (1 <= x) {
                totalCost += 1;  // Use adjacent flip
            } else {
                totalCost += x;  // Use any-pair flip
            }
            i += 2;
        } else {
            // Non-adjacent positions: must use any-pair flip
            totalCost += x;
            i += 2;
        }
    }
    
    return totalCost;
}

int main() {
    static char s1[1001], s2[1001];
    int x;
    
    fgets(s1, sizeof(s1), stdin);
    fgets(s2, sizeof(s2), stdin);
    scanf("%d", &x);
    
    // Remove newlines
    s1[strcspn(s1, "\n")] = 0;
    s2[strcspn(s2, "\n")] = 0;
    
    printf("%d\n", solution(s1, s2, x));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

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