Minimum Cost to Convert String II - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Build transformation graph

Each unique substring becomes a node, transformation rules become weighted edges

Find shortest paths

Use Floyd-Warshall to find cheapest way to transform between any two substrings

Segment optimally

Use DP to find the best way to divide the string into transformable segments

Combine costs

Each segment uses the precomputed shortest transformation cost

Key Takeaway

🎯 Key Insight: Transform the substring replacement problem into a shortest path problem on a graph, then use dynamic programming to find the optimal segmentation. This combines graph algorithms (Floyd-Warshall) with DP for an elegant and efficient solution.

Time & Space Complexity

Time Complexity

⏱️

O(n³ + n²×m)

O(n³) for Floyd-Warshall on substring graph, O(n²×m) for DP where m is average substring length

⚠ Quadratic Growth

Space Complexity

O(n² + k²)

O(n²) for DP table, O(k²) for shortest path matrix where k is number of unique substrings

⚠ Quadratic Space

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

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

Approach	Time	Space	Notes
✓ Graph + DP Optimal Solution	O(n³ + n²×m)	O(n² + k²)	Build transformation graph with shortest paths, then use DP for optimal segmentation
Brute Force Recursive	O(3^n)	O(n)	Try all possible ways to segment and transform the string recursively

Graph + DP Optimal Solution — Algorithm Steps

Build a graph where nodes are unique substrings and edges are transformation costs
Apply Floyd-Warshall algorithm to find shortest paths between all substring pairs
Use dynamic programming to find optimal segmentation of the string
For each position, try all possible segments using precomputed shortest paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Build transformation graph

Create nodes for all unique substrings and edges for transformations

Apply Floyd-Warshall

Find shortest paths between all pairs of substrings

Dynamic programming

Use DP to find optimal segmentation with precomputed costs

Combine results

Each DP state uses shortest path costs for transformations

Code -

solution.c — C

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

#define MAX_STRINGS 1000
#define MAX_LEN 100

typedef struct {
    char str[MAX_LEN];
    long long dist[MAX_STRINGS];
    int dist_count;
} StringNode;

StringNode nodes[MAX_STRINGS];
int node_count = 0;
long long dp[MAX_LEN];

int findOrCreateNode(char* s) {
    for (int i = 0; i < node_count; i++) {
        if (strcmp(nodes[i].str, s) == 0) {
            return i;
        }
    }
    strcpy(nodes[node_count].str, s);
    for (int i = 0; i < MAX_STRINGS; i++) {
        nodes[node_count].dist[i] = LLONG_MAX;
    }
    nodes[node_count].dist[node_count] = 0;
    return node_count++;
}

long long minimumCost(char* source, char* target, char** original, int originalSize, char** changed, int changedSize, int* cost, int costSize) {
    int n = strlen(source);
    if (strcmp(source, target) == 0) return 0;
    
    node_count = 0;
    
    // Build graph
    for (int i = 0; i < originalSize; i++) {
        int src = findOrCreateNode(original[i]);
        int dst = findOrCreateNode(changed[i]);
        
        if (nodes[src].dist[dst] > cost[i]) {
            nodes[src].dist[dst] = cost[i];
        }
    }
    
    // Floyd-Warshall
    for (int k = 0; k < node_count; k++) {
        for (int i = 0; i < node_count; i++) {
            for (int j = 0; j < node_count; j++) {
                if (nodes[i].dist[k] != LLONG_MAX && nodes[k].dist[j] != LLONG_MAX) {
                    long long new_dist = nodes[i].dist[k] + nodes[k].dist[j];
                    if (new_dist < nodes[i].dist[j]) {
                        nodes[i].dist[j] = new_dist;
                    }
                }
            }
        }
    }
    
    // DP
    for (int i = 0; i <= n; i++) {
        dp[i] = LLONG_MAX;
    }
    dp[n] = 0;
    
    for (int i = n - 1; i >= 0; i--) {
        if (strcmp(source + i, target + i) == 0) {
            dp[i] = 0;
            continue;
        }
        
        for (int j = i + 1; j <= n; j++) {
            char src_sub[MAX_LEN], tgt_sub[MAX_LEN];
            strncpy(src_sub, source + i, j - i);
            src_sub[j - i] = '\0';
            strncpy(tgt_sub, target + i, j - i);
            tgt_sub[j - i] = '\0';
            
            if (strcmp(src_sub, tgt_sub) == 0) {
                if (dp[j] < dp[i]) {
                    dp[i] = dp[j];
                }
            } else {
                int src_idx = -1, tgt_idx = -1;
                for (int k = 0; k < node_count; k++) {
                    if (strcmp(nodes[k].str, src_sub) == 0) src_idx = k;
                    if (strcmp(nodes[k].str, tgt_sub) == 0) tgt_idx = k;
                }
                
                if (src_idx != -1 && tgt_idx != -1 && nodes[src_idx].dist[tgt_idx] != LLONG_MAX) {
                    if (dp[j] != LLONG_MAX) {
                        long long new_cost = nodes[src_idx].dist[tgt_idx] + dp[j];
                        if (new_cost < dp[i]) {
                            dp[i] = new_cost;
                        }
                    }
                }
            }
        }
    }
    
    return dp[0] == LLONG_MAX ? -1 : dp[0];
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ + n²×m)

O(n³) for Floyd-Warshall on substring graph, O(n²×m) for DP where m is average substring length

⚠ Quadratic Growth

Space Complexity

O(n² + k²)

O(n²) for DP table, O(k²) for shortest path matrix where k is number of unique substrings

⚠ Quadratic Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Graph + DP Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler