Minimum Number of Valid Strings to Form Target II - Problem

Array String Binary Search Dynamic Programming Segment Tree Rolling Hash String Matching Hash Function Hard

You are given an array of strings words and a string target.

A string x is called valid if x is a prefix of any string in words.

Return the minimum number of valid strings that can be concatenated to form target. If it is not possible to form target, return -1.

Input & Output

Example 1 — Multiple Valid Prefixes

$ Input: words = ["abc","ab","bc"], target = "abc"

› Output: 1

💡 Note: The target "abc" can be formed using just the single word "abc" which is a valid prefix of itself. This gives us the minimum count of 1.

Example 2 — Need Multiple Pieces

$ Input: words = ["ab","bc"], target = "abc"

› Output: -1

💡 Note: Target "abc" cannot be formed. We can use "ab" to cover positions 0-1, but then we need a valid prefix to cover "c" at position 2. However, "bc" doesn't match "c" (it would need to match starting from position 2). Since no word in the dictionary is a prefix that matches "c", it's impossible to form the target.

Example 3 — Impossible Case

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

› Output: -1

💡 Note: No word in the dictionary starts with 'e', so it's impossible to form target "ef" using any valid prefixes.

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 26
1 ≤ target.length ≤ 5000
words[i] and target consist of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15 f Meta 12

This problem requires finding the minimum number of valid prefixes to form a target string. The key insight is to use dynamic programming where dp[i] represents the minimum strings needed to form target[0:i]. The optimal approach combines DP with a Trie data structure for efficient prefix matching. Time: O(n·L + W·M), Space: O(W·M + n).

Common Approaches

✓ DP with Trie Optimization

⏱️ Time: O(n·L + W·M) Space: O(W·M + n)

Build a Trie from all words to enable efficient prefix matching. For each position in target, traverse the Trie to find all possible prefix matches in O(L) time where L is the length of longest match, rather than checking each word separately.

Dynamic Programming

⏱️ Time: O(n²m) Space: O(n)

Create a DP array where dp[i] represents the minimum number of valid strings needed to form target[0:i]. For each position, try all words as potential matches and update the DP array accordingly.

Recursive Backtracking

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

For each position in target, try every word from words and check if it matches as a prefix. Recursively solve for the remaining substring. Use memoization to avoid recomputing same subproblems.

DP with Trie Optimization — Algorithm Steps

Build Trie from all words in the dictionary
Initialize DP array with dp[0] = 0
For each position, use Trie to find all valid prefix matches
Update DP values for reachable positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie

Create Trie structure from word dictionary

DP with Trie

Use Trie to quickly find all prefix matches

Optimize

Each position checked in O(L) time instead of O(W)

Code -

solution.c — C

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

#define MAX_CHILDREN 26
#define MAX_WORDS 1000
#define MAX_LEN 1000

typedef struct TrieNode {
    struct TrieNode* children[MAX_CHILDREN];
    int isWord;
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)calloc(1, sizeof(TrieNode));
    return node;
}

char words[MAX_WORDS][MAX_LEN];
char target[MAX_LEN];
int dp[MAX_LEN + 1];
int word_count;
int target_len;

int solution() {
    // Build Trie
    TrieNode* root = createNode();
    for (int i = 0; i < word_count; i++) {
        TrieNode* node = root;
        for (int j = 0; words[i][j]; j++) {
            int idx = words[i][j] - 'a';
            if (!node->children[idx]) {
                node->children[idx] = createNode();
            }
            node = node->children[idx];
        }
        node->isWord = 1;
    }
    
    for (int i = 0; i <= target_len; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int i = 0; i < target_len; i++) {
        if (dp[i] == INT_MAX) continue;
        
        TrieNode* node = root;
        for (int j = i; j < target_len; j++) {
            int idx = target[j] - 'a';
            if (!node->children[idx]) break;
            node = node->children[idx];
            if (node->isWord) {
                if (dp[i] + 1 < dp[j + 1]) {
                    dp[j + 1] = dp[i] + 1;
                }
            }
        }
    }
    
    return dp[target_len] == INT_MAX ? -1 : dp[target_len];
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse words array
    word_count = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        while (*token == ' ' || *token == '"') token++;
        char* end = token + strlen(token) - 1;
        while (end > token && (*end == ' ' || *end == '"' || *end == '\n')) {
            *end = '\0';
            end--;
        }
        strcpy(words[word_count], token);
        word_count++;
        token = strtok(NULL, ",]");
    }
    
    fgets(target, sizeof(target), stdin);
    target[strcspn(target, "\n")] = 0;
    target_len = strlen(target);
    
    int result = solution();
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n·L + W·M)

n positions × L max word length for DP, plus W words × M avg length for Trie construction

✓ Linear Growth

Space Complexity

O(W·M + n)

Trie uses W words × M average length, plus DP array of size n

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

450 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

Minimum Number of Valid Strings to Form Target II - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

DP with Trie Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler