Minimum Cost to Convert String II

Minimum Cost to Convert String II - Problem

Array String Dynamic Programming Graph Trie Shortest Path Hard

Minimum Cost to Convert String II

You're given two strings source and target of equal length, along with transformation rules. Each rule specifies that you can convert a substring original[i] to changed[i] at a cost of cost[i].

The challenge is to find the minimum cost to transform the entire source string into the target string using these substring replacement operations.

Key Rules:
• Operations on substrings must either be disjoint (non-overlapping) or identical (same positions)
• You can use any transformation rule multiple times
• If transformation is impossible, return -1

Example: If source = "abcd" and target = "acce", and you have rules to convert "b" → "c" (cost 2) and "d" → "e" (cost 3), the minimum cost would be 5.

Input & Output

example_1.py — Basic transformation

$ Input: source = "abcd", target = "acce", original = ["a","b","c","cc","d"], changed = ["a","c","b","e","e"], cost = [1,2,3,4,5]

› Output: 7

💡 Note: We can transform 'b' to 'c' (cost 2) and 'd' to 'e' (cost 5). Total cost is 2 + 5 = 7. The character 'a' stays the same and 'c' becomes 'c' with no cost.

example_2.py — Impossible transformation

$ Input: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]

› Output: -1

💡 Note: We need to transform 'd' to 'e', but there's no rule for this transformation. The only rule transforms 'a' to 'e', which doesn't help us.

example_3.py — Multi-character transformations

$ Input: source = "abcdef", target = "axydef", original = ["bc","x","y"], changed = ["xy","a","b"], cost = [5,3,2]

› Output: 5

💡 Note: We can directly transform the substring 'bc' to 'xy' with cost 5. This is more efficient than trying to transform individual characters.

Constraints

1 ≤ source.length == target.length ≤ 10³
source, target consist only of lowercase English letters
1 ≤ original.length == changed.length == cost.length ≤ 100
1 ≤ original[i].length == changed[i].length ≤ source.length
original[i], changed[i] consist only of lowercase English letters
1 ≤ cost[i] ≤ 10⁶
Operations must be on disjoint substrings or identical positions

Visualization

Tap to expand

Asked in

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

This problem combines graph algorithms with dynamic programming. The optimal approach uses Floyd-Warshall algorithm to precompute shortest transformation paths between all substring pairs, then applies DP to find the minimum cost segmentation. Key insight: treat substring transformations as a shortest path problem in a graph, then optimize the segmentation separately.

Common Approaches

✓ Brute Force Recursive

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

For each position, try all possible substrings that can be transformed, then recursively solve the remaining part. This explores all possible segmentations and transformations.

Graph + DP Optimal Solution

⏱️ Time: O(n³ + n²×m) Space: O(n² + k²)

This optimal approach combines graph algorithms with dynamic programming. First, we build a graph of all possible substring transformations and use Floyd-Warshall to find shortest transformation paths. Then we use DP to find the optimal way to segment and transform the string.

Brute Force Recursive — Algorithm Steps

For each position in the string, try all possible substring transformations
Recursively solve for the remaining part after each transformation
Return the minimum cost among all valid transformations
Use memoization to avoid recomputing the same subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Begin exploring all possible substring transformations from the start

Try different lengths

For each position, try substrings of different lengths

Check transformations

See if any transformation rules can convert the substring to target

Recurse on remainder

Recursively solve for the remaining part of the string

Code -

solution.c — C

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

#define MAX_TRANSFORMS 1000
#define MAX_LEN 1000

typedef struct {
    char changed[MAX_LEN];
    int cost;
} Transform;

typedef struct {
    char original[MAX_LEN];
    Transform transforms[MAX_TRANSFORMS];
    int count;
} TransformGroup;

static TransformGroup groups[MAX_TRANSFORMS];
static long long dp[MAX_LEN + 1];

int findMinCost(int group_count, const char* source_sub, const char* target_sub) {
    for (int i = 0; i < group_count; i++) {
        if (strcmp(groups[i].original, source_sub) == 0) {
            int min_cost = INT_MAX;
            int found = 0;
            for (int j = 0; j < groups[i].count; j++) {
                if (strcmp(groups[i].transforms[j].changed, target_sub) == 0) {
                    if (groups[i].transforms[j].cost < min_cost) {
                        min_cost = groups[i].transforms[j].cost;
                    }
                    found = 1;
                }
            }
            return found ? min_cost : -1;
        }
    }
    return -1;
}

long long minimumCost(char* source, char* target, char** original, int originalSize, char** changed, int changedSize, int* cost, int costSize) {
    int n = strlen(source);
    
    // Build transformation map with minimum costs
    int group_count = 0;
    
    for (int i = 0; i < originalSize; i++) {
        int found = -1;
        for (int j = 0; j < group_count; j++) {
            if (strcmp(groups[j].original, original[i]) == 0) {
                found = j;
                break;
            }
        }
        
        if (found == -1) {
            strcpy(groups[group_count].original, original[i]);
            groups[group_count].count = 0;
            found = group_count++;
        }
        
        // Check if this transformation already exists and update with minimum cost
        int transform_exists = 0;
        for (int j = 0; j < groups[found].count; j++) {
            if (strcmp(groups[found].transforms[j].changed, changed[i]) == 0) {
                if (cost[i] < groups[found].transforms[j].cost) {
                    groups[found].transforms[j].cost = cost[i];
                }
                transform_exists = 1;
                break;
            }
        }
        
        if (!transform_exists) {
            strcpy(groups[found].transforms[groups[found].count].changed, changed[i]);
            groups[found].transforms[groups[found].count].cost = cost[i];
            groups[found].count++;
        }
    }
    
    // DP array where dp[i] = minimum cost to transform source[i:] to target[i:]
    for (int i = 0; i <= n; i++) {
        dp[i] = LLONG_MAX;
    }
    dp[n] = 0;
    
    // Fill DP table from right to left
    for (int i = n - 1; i >= 0; i--) {
        // Try all possible substring lengths starting at position i
        for (int length = 1; length <= n - i; length++) {
            char source_sub[MAX_LEN], target_sub[MAX_LEN];
            strncpy(source_sub, source + i, length);
            source_sub[length] = '\0';
            strncpy(target_sub, target + i, length);
            target_sub[length] = '\0';
            
            // If substrings already match, no transformation needed
            if (strcmp(source_sub, target_sub) == 0) {
                if (dp[i + length] < dp[i]) {
                    dp[i] = dp[i + length];
                }
            }
            // Check if there's a transformation rule
            else {
                int transform_cost = findMinCost(group_count, source_sub, target_sub);
                if (transform_cost != -1 && dp[i + length] != LLONG_MAX) {
                    long long new_cost = (long long)transform_cost + dp[i + length];
                    if (new_cost < dp[i]) {
                        dp[i] = new_cost;
                    }
                }
            }
        }
    }
    
    return dp[0] == LLONG_MAX ? -1 : dp[0];
}

int main() {
    char source[MAX_LEN], target[MAX_LEN];
    char originalLine[MAX_LEN], changedLine[MAX_LEN], costLine[MAX_LEN];
    
    fgets(source, sizeof(source), stdin);
    source[strcspn(source, "\n")] = 0;
    
    fgets(target, sizeof(target), stdin);
    target[strcspn(target, "\n")] = 0;
    
    fgets(originalLine, sizeof(originalLine), stdin);
    originalLine[strcspn(originalLine, "\n")] = 0;
    
    fgets(changedLine, sizeof(changedLine), stdin);
    changedLine[strcspn(changedLine, "\n")] = 0;
    
    fgets(costLine, sizeof(costLine), stdin);
    costLine[strcspn(costLine, "\n")] = 0;
    
    // Parse arrays
    char* original[100];
    char* changed[100];
    int cost[100];
    int originalSize = 0, changedSize = 0, costSize = 0;
    
    if (strcmp(originalLine, "[]") != 0) {
        char* token = originalLine;
        char* end;
        while ((end = strchr(token, ',')) != NULL) {
            *end = '\0';
            original[originalSize] = malloc(strlen(token) + 1);
            strcpy(original[originalSize], token);
            originalSize++;
            token = end + 1;
        }
        if (strlen(token) > 0) {
            original[originalSize] = malloc(strlen(token) + 1);
            strcpy(original[originalSize], token);
            originalSize++;
        }
    }
    
    if (strcmp(changedLine, "[]") != 0) {
        char* token = changedLine;
        char* end;
        while ((end = strchr(token, ',')) != NULL) {
            *end = '\0';
            changed[changedSize] = malloc(strlen(token) + 1);
            strcpy(changed[changedSize], token);
            changedSize++;
            token = end + 1;
        }
        if (strlen(token) > 0) {
            changed[changedSize] = malloc(strlen(token) + 1);
            strcpy(changed[changedSize], token);
            changedSize++;
        }
    }
    
    if (strcmp(costLine, "[]") != 0) {
        char* token = costLine;
        char* end;
        while ((end = strchr(token, ',')) != NULL) {
            *end = '\0';
            cost[costSize] = (int)strtol(token, NULL, 10);
            costSize++;
            token = end + 1;
        }
        if (strlen(token) > 0) {
            cost[costSize] = (int)strtol(token, NULL, 10);
            costSize++;
        }
    }
    
    long long result = minimumCost(source, target, original, originalSize, changed, changedSize, cost, costSize);
    printf("%lld\n", result);
    
    // Free allocated memory
    for (int i = 0; i < originalSize; i++) {
        free(original[i]);
    }
    for (int i = 0; i < changedSize; i++) {
        free(changed[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each position, we have multiple choices leading to exponential branching

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and memoization table

⚡ Linearithmic Space

31.5K Views

Medium Frequency

~35 min Avg. Time

1.3K 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 Recursive — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler