Minimum Cost to Convert String I

Minimum Cost to Convert String I - Problem

You are given two 0-indexed strings source and target, both of length n and consisting of lowercase English letters. You are also given two 0-indexed character arrays original and changed, and an integer array cost, where cost[i] represents the cost of changing the character original[i] to the character changed[i].

You start with the string source. In one operation, you can pick a character x from the string and change it to the character y at a cost of z if there exists any index j such that cost[j] == z, original[j] == x, and changed[j] == y.

Return the minimum cost to convert the string source to the string target using any number of operations. If it is impossible to convert source to target, return -1.

Note that there may exist indices i, j such that original[j] == original[i] and changed[j] == changed[i].

Input & Output

Example 1 — Basic Conversion

$ Input: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]

› Output: 25

💡 Note: We need to convert position 1: b→c (cost 5) and position 3: d→e (cost 20). The Floyd-Warshall algorithm finds these are the optimal paths. Total cost = 5 + 20 = 25.

Example 2 — Impossible Conversion

$ Input: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]

› Output: 12

💡 Note: We can convert a→c (cost 1) then c→b (cost 2), so each 'a' converts to 'b' with total cost 3. Since we need to convert 4 characters, total cost is 4 × 3 = 12.

Example 3 — No Conversion Needed

$ Input: source = "abcd", target = "abcd", original = ["a"], changed = ["b"], cost = [5]

› Output: 0

💡 Note: Source and target are identical, no conversions needed, cost is 0

Constraints

1 ≤ source.length == target.length ≤ 10⁵
source, target consist of lowercase English letters
1 ≤ original.length == changed.length == cost.length ≤ 2000
original[i], changed[i] are lowercase English letters
1 ≤ cost[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is modeling character conversions as a weighted graph and finding shortest paths. The optimal Floyd-Warshall approach precomputes all shortest paths between character pairs in O(26³) time, then answers each query in O(1). Time: O(26³ + n), Space: O(26²)

Common Approaches

✓ Brute Force DFS

⏱️ Time: O(n × 26^k) Space: O(k)

For each position where source and target differ, use depth-first search to find the minimum cost path from source character to target character. This explores all possible conversion sequences.

Floyd-Warshall All-Pairs Shortest Path

⏱️ Time: O(26³ + n) Space: O(26²)

Build a graph of character conversions and use Floyd-Warshall algorithm to find shortest paths between all pairs of characters. Then for each character difference, lookup the precomputed minimum cost.

Brute Force DFS — Algorithm Steps

For each character position, check if conversion is needed
Use DFS to explore all possible conversion paths
Return minimum cost or -1 if impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Analysis

Compare source and target, identify differences

DFS Exploration

For each difference, recursively try all conversion paths

Result

Return minimum total cost or -1 if impossible

Code -

solution.c — C

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

#define MAX_EDGES 1000
#define MAX_LEN 1000

struct Edge {
    char to;
    int cost;
};

struct Graph {
    struct Edge edges[26][MAX_EDGES];
    int count[26];
};

long long dfs(char start, char end, int visited[26], struct Graph* graph) {
    if (start == end) return 0;
    int startIdx = start - 'a';
    if (visited[startIdx]) return LLONG_MAX;
    
    visited[startIdx] = 1;
    long long minCost = LLONG_MAX;
    
    for (int i = 0; i < graph->count[startIdx]; i++) {
        char nextChar = graph->edges[startIdx][i].to;
        int edgeCost = graph->edges[startIdx][i].cost;
        long long subCost = dfs(nextChar, end, visited, graph);
        if (subCost != LLONG_MAX) {
            long long totalCost = (long long)edgeCost + subCost;
            if (totalCost < minCost) {
                minCost = totalCost;
            }
        }
    }
    
    visited[startIdx] = 0;
    return minCost;
}

long long solution(char* source, char* target, char* original, char* changed, int* cost, int numConversions) {
    if (strlen(source) != strlen(target)) return -1;
    
    struct Graph graph;
    memset(&graph, 0, sizeof(graph));
    
    for (int i = 0; i < numConversions; i++) {
        int fromIdx = original[i] - 'a';
        graph.edges[fromIdx][graph.count[fromIdx]].to = changed[i];
        graph.edges[fromIdx][graph.count[fromIdx]].cost = cost[i];
        graph.count[fromIdx]++;
    }
    
    long long totalCost = 0;
    int len = strlen(source);
    for (int i = 0; i < len; i++) {
        if (source[i] != target[i]) {
            int visited[26] = {0};
            long long costToConvert = dfs(source[i], target[i], visited, &graph);
            if (costToConvert == LLONG_MAX) return -1;
            totalCost += costToConvert;
        }
    }
    
    return totalCost;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char source[MAX_LEN], target[MAX_LEN];
    char original[MAX_EDGES], changed[MAX_EDGES];
    int cost[MAX_EDGES];
    
    fgets(source, sizeof(source), stdin);
    source[strcspn(source, "\n")] = 0;
    
    fgets(target, sizeof(target), stdin);
    target[strcspn(target, "\n")] = 0;
    
    // Simple parsing for arrays - assumes well-formed input
    char line[MAX_LEN * 10];
    fgets(line, sizeof(line), stdin);
    int numConversions = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] == '"' && token[2] == '"') {
            original[numConversions++] = token[1];
        }
        token = strtok(NULL, "[,]");
    }
    
    fgets(line, sizeof(line), stdin);
    int idx = 0;
    token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] == '"' && token[2] == '"') {
            changed[idx++] = token[1];
        }
        token = strtok(NULL, "[,]");
    }
    
    fgets(line, sizeof(line), stdin);
    idx = 0;
    token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            cost[idx++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    printf("%lld\n", solution(source, target, original, changed, cost, numConversions));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 26^k)

For each of n characters, DFS can explore up to 26^k paths where k is conversion depth

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth for DFS traversal

✓ Linear Space

12.4K Views

Medium Frequency

~25 min Avg. Time

456 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 DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler