Construct String with Minimum Cost (Easy)

Construct String with Minimum Cost (Easy) - 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 — Basic Case

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

› Output: 7

💡 Note: The minimum cost is achieved by: "abc" (cost 1) + "d" (cost 1) + "ef" (cost 5) = 7

Example 2 — Impossible Case

$ Input: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]

› Output: -1

💡 Note: It's impossible to construct "aaaa" using words that only contain 'z'

Example 3 — Single Word Match

$ Input: target = "abc", words = ["abc"], costs = [5]

› Output: 5

💡 Note: Use the single word "abc" with cost 5 to match the entire target

Constraints

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

Visualization

Tap to expand

Asked in

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

This problem requires finding the minimum cost to construct a target string by concatenating words. The key insight is using dynamic programming where dp[i] represents the minimum cost to build target[0:i]. For each position, we try all words that can extend from that position. Time: O(n × m × k), Space: O(n).

Common Approaches

✓ Recursive with Memoization

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

For each position in target, try every word that matches as prefix and recursively solve for remaining substring. Use memoization to avoid recomputing same subproblems.

1D Dynamic Programming

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

Create a DP array where dp[i] represents minimum cost to construct target[0:i]. For each position, try all words that can end at that position.

Recursive with Memoization — Algorithm Steps

Check if current position equals target length (base case)
Try each word as potential prefix match
Recursively solve for remaining substring
Return minimum cost among all valid options

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at position 0 of target string

Try Words

For each position, try all words that match as prefix

Recurse

Recursively solve for remaining substring

Code -

solution.c — C

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

#define MAX_SIZE 50

typedef struct {
    int r, c;
} Point;

typedef struct {
    Point points[MAX_SIZE * MAX_SIZE];
    int size;
} PointList;

int solution(int isInfected[][MAX_SIZE], int m, int n) {
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    int totalWalls = 0;
    
    while (true) {
        bool visited[MAX_SIZE][MAX_SIZE] = {false};
        PointList regions[MAX_SIZE];
        PointList threatened[MAX_SIZE];
        int regionCount = 0;
        
        // Find all infected regions
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (isInfected[i][j] == 1 && !visited[i][j]) {
                    regions[regionCount].size = 0;
                    threatened[regionCount].size = 0;
                    
                    // BFS to find region
                    Point queue[MAX_SIZE * MAX_SIZE];
                    int front = 0, rear = 0;
                    queue[rear++] = (Point){i, j};
                    visited[i][j] = true;
                    
                    bool threatenedSet[MAX_SIZE][MAX_SIZE] = {false};
                    
                    while (front < rear) {
                        Point curr = queue[front++];
                        regions[regionCount].points[regions[regionCount].size++] = curr;
                        
                        for (int d = 0; d < 4; d++) {
                            int nr = curr.r + directions[d][0];
                            int nc = curr.c + directions[d][1];
                            
                            if (nr >= 0 && nr < m && nc >= 0 && nc < n) {
                                if (isInfected[nr][nc] == 1 && !visited[nr][nc]) {
                                    visited[nr][nc] = true;
                                    queue[rear++] = (Point){nr, nc};
                                } else if (isInfected[nr][nc] == 0 && !threatenedSet[nr][nc]) {
                                    threatenedSet[nr][nc] = true;
                                    threatened[regionCount].points[threatened[regionCount].size++] = (Point){nr, nc};
                                }
                            }
                        }
                    }
                    
                    regionCount++;
                }
            }
        }
        
        if (regionCount == 0) break;
        
        // Find region threatening most cells
        int maxThreat = 0, containIdx = 0;
        for (int i = 0; i < regionCount; i++) {
            if (threatened[i].size > maxThreat) {
                maxThreat = threatened[i].size;
                containIdx = i;
            }
        }
        
        // Count walls needed
        int wallsNeeded = 0;
        for (int i = 0; i < regions[containIdx].size; i++) {
            Point p = regions[containIdx].points[i];
            for (int d = 0; d < 4; d++) {
                int nr = p.r + directions[d][0];
                int nc = p.c + directions[d][1];
                if (nr >= 0 && nr < m && nc >= 0 && nc < n && isInfected[nr][nc] == 0) {
                    wallsNeeded++;
                }
            }
        }
        
        totalWalls += wallsNeeded;
        
        // Contain the region
        for (int i = 0; i < regions[containIdx].size; i++) {
            Point p = regions[containIdx].points[i];
            isInfected[p.r][p.c] = -1;
        }
        
        // Spread other regions
        for (int i = 0; i < regionCount; i++) {
            if (i != containIdx) {
                for (int j = 0; j < threatened[i].size; j++) {
                    Point p = threatened[i].points[j];
                    isInfected[p.r][p.c] = 1;
                }
            }
        }
    }
    
    return totalWalls;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int isInfected[MAX_SIZE][MAX_SIZE];
    int m = 0, n = 0;
    
    // Parse 2D array - simplified parsing
    char* ptr = line + 1; // Skip first '['
    char* rowStart;
    
    while ((rowStart = strchr(ptr, '[')) != NULL) {
        rowStart++; // Skip '['
        char* rowEnd = strchr(rowStart, ']');
        *rowEnd = '\0';
        
        n = 0;
        char* token = strtok(rowStart, ",");
        while (token != NULL) {
            isInfected[m][n++] = atoi(token);
            token = strtok(NULL, ",");
        }
        
        m++;
        ptr = rowEnd + 1;
        if (*ptr == ']') break;
    }
    
    printf("%d\n", solution(isInfected, m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

n is target length, m is number of words, k is average word length for string matching

✓ Linear Growth

Space Complexity

O(n)

Memoization table stores results for each position in target string

⚡ Linearithmic Space

34.6K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Recursive with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler