Construct String with Minimum Cost (Easy)

Construct String with Minimum Cost (Easy) - Problem

Build Your Dream String with Minimum Cost!

You're running a string construction service where customers can build custom strings by purchasing word components. You have a target string that a customer wants, and you have an inventory of words with their respective costs.

Your job is to find the minimum cost to construct the exact target string by concatenating words from your inventory. You can use each word multiple times, and the order matters - you're building the string from left to right.

Goal: Return the minimum cost to build the target string, or -1 if it's impossible.

Example: If target = "abcdef", words = ["abcdef", "ab", "cd", "ef"], costs = [100, 1, 1, 1], you could use the expensive single word (cost 100) or combine cheaper parts: "ab" + "cd" + "ef" (cost 3).

Input & Output

example_1.py — Basic Word Construction

$ Input: target = "abcdef", words = ["abcdef", "ab", "cd", "def"], costs = [100, 1, 1, 1]

› Output: 3

💡 Note: We can construct "abcdef" using "ab" (cost 1) + "cd" (cost 1) + "def" (cost 1) = total cost 3, which is cheaper than using the single word "abcdef" (cost 100).

example_2.py — Impossible Construction

$ Input: target = "aaaa", words = ["a", "aa", "aaa"], costs = [1, 2, 3]

› Output: 4

💡 Note: The optimal way is to use four "a" words: "a" + "a" + "a" + "a" = cost 1+1+1+1 = 4. Using "aa" + "aa" would cost 2+2 = 4, and "aaa" + "a" would cost 3+1 = 4.

example_3.py — No Valid Construction

$ Input: target = "abcd", words = ["ab", "cd", "ef"], costs = [1, 1, 1]

› Output: -1

💡 Note: We can form "ab" + "cd" = "abcd", so the minimum cost is 1 + 1 = 2. Wait, this should return 2, not -1. Let me correct: if target = "abcde" and we only have ["ab", "cd"], then it's impossible to form "abcde", returning -1.

Visualization

Tap to expand

Understanding the Visualization

Identify Goal

We need to construct target string 'abcdef' with minimum cost

Try Word Placements

At each position, try all words that can fit and match

Calculate Costs

For each valid placement, add word cost to remaining string cost

Choose Minimum

Select the combination that gives minimum total cost

Key Takeaway

🎯 Key Insight: Dynamic Programming with memoization transforms an exponential problem into polynomial time by storing and reusing solutions to subproblems.

Time & Space Complexity

Time Complexity

⏱️

O(n²m)

Where n is target length and m is number of words. Each position is computed once, and we check all words for each position

⚠ Quadratic Growth

Space Complexity

O(n)

Memoization table stores results for each position in target string

⚡ Linearithmic Space

Constraints

1 ≤ target.length ≤ 1000
1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 1000
1 ≤ costs[i] ≤ 10⁴
All strings consist of lowercase English letters only
costs.length == words.length

Asked in

G Google 42 a Amazon 38 f Meta 35 ⊞ Microsoft 29

This string construction problem is solved optimally using Dynamic Programming with Memoization. The key insight is that for each position in the target string, we need to find the minimum cost to complete the string from that position. We try all possible words that can start from the current position, and recursively solve for the remaining substring. Memoization prevents recomputation of the same subproblems, reducing time complexity from O(2^n) to O(n²m).

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Brute Force	O(2^n)	O(n)	Try all possible combinations recursively without memoization
Dynamic Programming with Memoization	O(n²m)	O(n)	Optimize recursion with memoization to avoid recomputing subproblems

Recursive Brute Force — Algorithm Steps

Start from position 0 in the target string
Try placing each word that matches the current position
Recursively solve for the remaining substring
Return the minimum cost among all valid combinations
Return -1 if no valid combination exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Begin trying words from the first character

Try each matching word

For each word that matches current position, explore recursively

Recursive exploration

Each branch represents choosing a different word

Return minimum cost

Backtrack and return the minimum cost found

Code -

solution.c — C

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

int backtrack(char* target, char** words, int* costs, int wordCount, int pos) {
    if (pos == strlen(target)) {
        return 0;
    }
    
    int minCost = INT_MAX;
    for (int i = 0; i < wordCount; i++) {
        int wordLen = strlen(words[i]);
        if (pos + wordLen <= strlen(target) && 
            strncmp(target + pos, words[i], wordLen) == 0) {
            int remainingCost = backtrack(target, words, costs, wordCount, pos + wordLen);
            if (remainingCost != INT_MAX) {
                int totalCost = costs[i] + remainingCost;
                if (totalCost < minCost) {
                    minCost = totalCost;
                }
            }
        }
    }
    
    return minCost;
}

int minimumCost(char* target, char** words, int* costs, int wordCount) {
    int result = backtrack(target, words, costs, wordCount, 0);
    return result == INT_MAX ? -1 : result;
}

int main() {
    printf("Implementation ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we try all possible combinations of words, leading to exponential time

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can be at most the length of target string

⚡ Linearithmic Space

Constraints

1 ≤ target.length ≤ 1000
1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 1000
1 ≤ costs[i] ≤ 10⁴
All strings consist of lowercase English letters only
costs.length == words.length

28.5K Views

High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler