Minimum Steps to Convert String with Operations

Minimum Steps to Convert String with Operations - Problem

Transform One String Into Another with Minimal Operations

You're given two strings word1 and word2 of equal length, and your goal is to transform word1 into word2 using the minimum number of operations.

Here's how it works: You can partition word1 into one or more contiguous substrings. For each substring, you have three powerful operations at your disposal:

🔄 Replace: Change any single character to any other lowercase letter
🔀 Swap: Exchange any two characters within the substring
↩️ Reverse: Flip the entire substring backwards

Important constraint: Each character can participate in at most one operation of each type. So a character at position i can be involved in one replace, one swap, AND one reverse operation.

Your mission: Find the minimum total operations needed across all substrings to transform word1 into word2.

For example: "abc" → "bac" can be done in just 1 operation by swapping 'a' and 'b' in the entire string.

Input & Output

example_1.py — Basic Swap

$ Input: word1 = "abc", word2 = "bac"

› Output: 1

💡 Note: We can transform 'abc' to 'bac' with a single swap operation: swap characters at positions 0 and 1 ('a' and 'b'). The entire string can be treated as one partition.

example_2.py — Reverse Operation

$ Input: word1 = "abcd", word2 = "dcba"

› Output: 1

💡 Note: The target string 'dcba' is exactly the reverse of 'abcd'. We can achieve this with a single reverse operation on the entire string.

example_3.py — Multiple Operations

$ Input: word1 = "abxy", word2 = "xyba"

› Output: 2

💡 Note: Optimal approach: partition into ['ab', 'xy']. Transform 'ab'→'xy' (2 replacements would be 2 ops, but we can reverse 'xy'→'yx' then need 1 replacement) and 'xy'→'ba' (2 replacements). Better: partition as ['abxy'] and reverse to get 'yxba', then 2 swaps. Actually optimal is 2 operations total with right partitioning.

Constraints

1 ≤ word1.length, word2.length ≤ 100
word1.length == word2.length
word1 and word2 consist of lowercase English letters only
Each character can be used in at most one operation of each type

Visualization

Tap to expand

Understanding the Visualization

Partition the String

Divide word1 into contiguous sections that can be transformed efficiently

Apply Mirror Test

For each section, check if reversing it gets closer to the target

Optimize with Swaps

Use beneficial swaps to fix multiple positions with fewer operations

Replace Remainder

Use replacements only for characters that can't be fixed by swapping

Key Takeaway

🎯 Key Insight: The optimal approach combines dynamic programming for partitioning with greedy operation selection - always prefer swaps and reverses over replacements when possible!

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22 Apple 18

The optimal solution uses dynamic programming with memoization to find the best string partitioning strategy. For each substring, we efficiently calculate the minimum operations by considering reverse, swap, and replace operations in optimal combinations. The key insight is that any substring transformation can be optimized by first checking if a reverse operation helps, then greedily applying swaps before replacements.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n³)	O(n)	Use DP to find optimal partitioning with memoization
Brute Force (Try All Partitions)	O(2^n * n^3)	O(n)	Try every possible way to partition the string and calculate operations for each

Dynamic Programming (Optimal) — Algorithm Steps

Create a DP array where dp[i] represents minimum operations for first i characters
For each position i, try all possible starting positions j for the last partition
Use an efficient helper function to calculate operations for substring word1[j:i] → word2[j:i]
The helper function optimally combines reverse, swap, and replace operations
Return dp[n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Create DP array where dp[i] = min operations for first i characters

Fill DP Table

For each position, try all possible last partitions

Optimize Operations

Use memoization to efficiently calculate substring operations

Build Solution

Combine optimal subproblems to get final answer

Code -

solution.c — C

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

#define MAX_LEN 100
#define HASH_SIZE 10007

typedef struct HashNode {
    char key[MAX_LEN];
    int value;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];

int hash(char* key) {
    int hash = 0;
    for (int i = 0; key[i]; i++) {
        hash = (hash * 31 + key[i]) % HASH_SIZE;
    }
    return hash;
}

void putHash(char* key, int value) {
    int h = hash(key);
    HashNode* node = malloc(sizeof(HashNode));
    strcpy(node->key, key);
    node->value = value;
    node->next = hashTable[h];
    hashTable[h] = node;
}

int getHash(char* key) {
    int h = hash(key);
    HashNode* node = hashTable[h];
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return node->value;
        }
        node = node->next;
    }
    return -1;
}

void reverseString(char* str, int len) {
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }
}

int calculateSwapsAndReplacements(char* s1, char* s2, int len) {
    char* temp = malloc((len + 1) * sizeof(char));
    strcpy(temp, s1);
    int operations = 0;
    
    for (int i = 0; i < len; i++) {
        if (temp[i] != s2[i]) {
            int foundSwap = 0;
            
            for (int j = i + 1; j < len; j++) {
                if (temp[j] == s2[i] && temp[i] == s2[j]) {
                    char t = temp[i];
                    temp[i] = temp[j];
                    temp[j] = t;
                    operations++;
                    foundSwap = 1;
                    break;
                }
            }
            
            if (!foundSwap) {
                for (int j = i + 1; j < len; j++) {
                    if (temp[j] == s2[i]) {
                        char t = temp[i];
                        temp[i] = temp[j];
                        temp[j] = t;
                        operations++;
                        break;
                    }
                }
                if (temp[i] != s2[i]) {
                    temp[i] = s2[i];
                    operations++;
                }
            }
        }
    }
    
    free(temp);
    return operations;
}

int minOpsForSubstring(char* s1, char* s2, int len) {
    char key[MAX_LEN];
    sprintf(key, "%s|%s", s1, s2);
    
    int cached = getHash(key);
    if (cached != -1) return cached;
    
    if (strcmp(s1, s2) == 0) {
        putHash(key, 0);
        return 0;
    }
    
    char* rev = malloc((len + 1) * sizeof(char));
    strcpy(rev, s1);
    reverseString(rev, len);
    
    if (strcmp(rev, s2) == 0) {
        putHash(key, 1);
        free(rev);
        return 1;
    }
    
    int opsWithoutReverse = calculateSwapsAndReplacements(s1, s2, len);
    int opsWithReverse = 1 + calculateSwapsAndReplacements(rev, s2, len);
    
    int result = (opsWithoutReverse < opsWithReverse) ? opsWithoutReverse : opsWithReverse;
    putHash(key, result);
    free(rev);
    return result;
}

int minSteps(char* word1, char* word2) {
    int n = strlen(word1);
    int* dp = malloc((n + 1) * sizeof(int));
    
    dp[0] = 0;
    for (int i = 1; i <= n; i++) {
        dp[i] = INT_MAX;
    }
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < i; j++) {
            int subLen = i - j;
            char* sub1 = malloc((subLen + 1) * sizeof(char));
            char* sub2 = malloc((subLen + 1) * sizeof(char));
            
            strncpy(sub1, word1 + j, subLen);
            strncpy(sub2, word2 + j, subLen);
            sub1[subLen] = '\0';
            sub2[subLen] = '\0';
            
            int ops = minOpsForSubstring(sub1, sub2, subLen);
            if (dp[j] != INT_MAX && dp[j] + ops < dp[i]) {
                dp[i] = dp[j] + ops;
            }
            
            free(sub1);
            free(sub2);
        }
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

int main() {
    char word1[] = "abc";
    char word2[] = "bac";
    printf("%d\n", minSteps(word1, word2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for trying all partition positions, and O(n) for calculating operations for each substring

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n plus recursion stack space

⚡ Linearithmic Space

27.4K Views

Medium-High Frequency

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler