Construct String with Minimum Cost

Construct String with Minimum Cost - Problem

You are given a string target, an array of strings words, and an integer array costs, both arrays of the same length.

Imagine an empty string s. You can perform the following operation any number of times (including zero):

Choose an index i in the range [0, words.length - 1]
Append words[i] to s
The cost of operation is costs[i]

Return the minimum cost to make s equal to target. If it's not possible, return -1.

Input & Output

Example 1 — Single Word Match

$ Input: target = "abc", words = ["ab","abc","a","c"], costs = [2,1,3,1]

› Output: 1

💡 Note: Use word "abc" with cost 1 to construct the entire target string directly.

Example 2 — Multiple Words

$ Input: target = "abc", words = ["a","b","c"], costs = [1,1,1]

› Output: 3

💡 Note: Use "a" + "b" + "c" with total cost 1 + 1 + 1 = 3.

Example 3 — Impossible Case

$ Input: target = "abc", words = ["ab","ac"], costs = [1,1]

› Output: -1

💡 Note: Cannot construct "abc" using only "ab" and "ac" - missing required characters.

Constraints

1 ≤ target.length ≤ 5 × 10⁴
1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ target.length
1 ≤ costs[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Meta 28

The key insight is to use dynamic programming to build the target string incrementally. We maintain dp[i] as the minimum cost to construct target[0:i]. For each position, we check all words that could end at that position and take the minimum cost. Best approach is Bottom-Up DP with Time: O(n×m×k), Space: O(n).

Common Approaches

✓ Optimized

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

Greedy

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

Bottom-Up Dynamic Programming

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

Use a 1D DP array where dp[i] represents the minimum cost to construct target[0:i]. Fill the array from left to right, checking all possible words that can end at each position.

Brute Force Recursion

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

For each position in target, try all words that can match starting from that position. Recursively solve for remaining substring and track minimum cost.

Memoized Recursion

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

Same recursive approach but cache results for each position to avoid redundant calculations. This significantly improves performance by eliminating overlapping subproblems.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums1, int len1, int* nums2, int len2) {
    int result1[50], result2[50];
    int used[2001] = {0};
    int maxVal = 0;
    
    // Use greedy approach - assign smallest available numbers
    int pos1 = 0, pos2 = 0;
    
    while (pos1 < len1 || pos2 < len2) {
        int need1 = -1, need2 = -1;
        int min1 = INT_MAX, min2 = INT_MAX;
        
        // Calculate minimum valid value for array1
        if (pos1 < len1) {
            need1 = nums1[pos1];
            min1 = (pos1 > 0) ? result1[pos1-1] + 1 : 1;
            if (need1 == 0 && min1 % 2 == 1) min1++; // Need even
            if (need1 == 1 && min1 % 2 == 0) min1++; // Need odd
            while (min1 < 2001 && used[min1]) min1 += 2;
        }
        
        // Calculate minimum valid value for array2
        if (pos2 < len2) {
            need2 = nums2[pos2];
            min2 = (pos2 > 0) ? result2[pos2-1] + 1 : 1;
            if (need2 == 0 && min2 % 2 == 1) min2++; // Need even
            if (need2 == 1 && min2 % 2 == 0) min2++; // Need odd
            while (min2 < 2001 && used[min2]) min2 += 2;
        }
        
        // Assign to the array that can use the smaller value
        if (pos1 >= len1 || (pos2 < len2 && min2 < min1)) {
            used[min2] = 1;
            result2[pos2++] = min2;
            if (min2 > maxVal) maxVal = min2;
        } else {
            used[min1] = 1;
            result1[pos1++] = min1;
            if (min1 > maxVal) maxVal = min1;
        }
    }
    
    return maxVal;
}

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 line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int nums1[50], nums2[50];
    int len1 = 0, len2 = 0;
    
    char* token = strtok(line1 + 1, ",]");
    while (token) {
        nums1[len1++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    token = strtok(line2 + 1, ",]");
    while (token) {
        nums2[len2++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(nums1, len1, nums2, len2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

23.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