Construct String with Minimum Cost - Practice Coding Problems

Construct String with Minimum Cost - Problem

You're tasked with building a target string using a collection of word building blocks, where each block has an associated cost. Think of it like constructing a sentence using pre-made word cards, but you want to spend the least amount of money possible!

The Challenge: Given a target string, an array of available words, and their corresponding costs, find the minimum cost to construct the target string by concatenating words from your collection. You can use each word multiple times, and the order matters!

Input:

target: The string you need to build
words: Array of available word building blocks
costs: Array of costs for each corresponding word

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

Example: If target = "abcdef", words = ["abdef", "abc", "def"], and costs = [100, 1, 1], you could use "abc" + "def" for a total cost of 2, rather than using "abdef" alone which would cost 100.

Input & Output

example_1.py — Basic Case

$ Input: target = "abcdef", words = ["abdef", "abc", "def"], costs = [100, 1, 1]

› Output: 2

💡 Note: The optimal solution is to use "abc" (cost 1) + "def" (cost 1) = total cost 2, rather than using "abdef" alone which would cost 100.

example_2.py — Impossible Case

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

› Output: 4

💡 Note: The optimal solution is to use "a" four times (4 × 1 = 4), which is cheaper than "aa" + "aa" (4 + 4 = 8) or "aaa" + "a" (8 + 1 = 9).

example_3.py — No Solution

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

› Output: -1

💡 Note: It's impossible to construct "abcd" because we're missing a word that contains 'c' in the right position. We can make "ab" but can't continue to make "abcd".

Constraints

1 ≤ target.length ≤ 5 × 10⁴
1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 50
1 ≤ costs[i] ≤ 10⁴
target and words[i] consist only of lowercase English letters
words.length == costs.length

Visualization

Tap to expand

Understanding the Visualization

Setup Factory

Initialize conveyor belt with cost trackers at each position

Start Assembly

Begin with empty string (cost = 0) at position 0

Try Word Tiles

At each position, test all word tiles that could fit

Update Costs

Calculate total cost and update if it's better than current minimum

Final Product

The cost at the final position is our answer

Key Takeaway

🎯 Key Insight: By breaking down the problem into subproblems (minimum cost to reach each position), we can build the optimal solution incrementally, ensuring we never miss a better combination.

Asked in

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

This problem is optimally solved using Dynamic Programming with O(n×m×L) time complexity. The key insight is to build the solution incrementally: for each position in the target string, try all words that could end at that position and track the minimum cost. The dp[i] represents the minimum cost to construct the first i characters, making this an efficient bottom-up approach that avoids redundant recursive calls.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive Exploration)	O(2^n)	O(n)	Recursively try all possible word combinations to build the target string
Dynamic Programming (Optimal)	O(n * m * L)	O(n)	Build solution incrementally using DP table to track minimum costs at each position

Brute Force (Recursive Exploration) — Algorithm Steps

Start from the beginning of the target string
For each position, try all words that match the current prefix
Recursively solve for the remaining substring after using each word
Return the minimum cost among all valid combinations
Use memoization to avoid recomputing the same subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin at index 0 of target string

Try Each Word

Test each word that matches current position

Recurse Forward

Move to next position and repeat process

Backtrack

Return minimum cost found in subtree

Memoize

Store result to avoid recomputation

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MAX_WORDS 100

int memo[MAX_LEN];
char target[MAX_LEN];
char words[MAX_WORDS][MAX_LEN];
int costs[MAX_WORDS];
int numWords;

int dfs(int index) {
    if (index == strlen(target)) return 0;
    if (memo[index] != -1) return memo[index];
    
    int minCost = INT_MAX;
    for (int i = 0; i < numWords; i++) {
        int wordLen = strlen(words[i]);
        if (index + wordLen <= strlen(target) && 
            strncmp(target + index, words[i], wordLen) == 0) {
            int remainingCost = dfs(index + wordLen);
            if (remainingCost != INT_MAX) {
                if (costs[i] + remainingCost < minCost) {
                    minCost = costs[i] + remainingCost;
                }
            }
        }
    }
    
    return memo[index] = minCost;
}

int minimumCost() {
    memset(memo, -1, sizeof(memo));
    int result = dfs(0);
    return result == INT_MAX ? -1 : result;
}

int main() {
    // Parse input and call solution
    printf("Solution ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Without memoization, we explore all possible combinations. With memoization, it becomes O(n * m * L) where n is target length, m is number of words, L is average word length

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and memoization table size proportional to target string length

⚡ Linearithmic Space

43.6K Views

High Frequency

~25 min Avg. Time

1.8K 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 Exploration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler