Minimum Number of Valid Strings to Form Target I - Problem

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

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 — Basic Valid Formation

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

› Output: 2

💡 Note: We can form "abcab" using "abc" + "ab" = 2 valid strings, or "ab" + "c" + "ab" = 3 strings. The minimum is 2.

Example 2 — Impossible Formation

$ Input: words = ["abc","aaaa","bcdef"], target = "aabcdabc"

› Output: -1

💡 Note: Cannot form "aabcdabc" because no word has prefix "aa". The target cannot be formed with available prefixes.

Example 3 — Single Character Prefixes

$ Input: words = ["a","aa","aaa"], target = "aaaaaaa"

› Output: 3

💡 Note: Optimal way is "aaa" + "aaa" + "a" = 3 valid strings to form 7 characters total.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 8 a Amazon 5 M Microsoft 4

The key insight is to use dynamic programming where each position represents the minimum valid strings needed to form the target up to that point. The optimal approach combines a trie data structure with DP for efficient prefix matching, achieving O(n×L) time complexity instead of O(n×m×k).

Common Approaches

✓ Brute Force with Recursion

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

For each position in target, try all possible prefixes from words that match and recursively solve for the remaining substring. Use memoization to avoid recomputing the same subproblems.

Dynamic Programming (Bottom-up)

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

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

Trie + Dynamic Programming

⏱️ Time: O(n × L) Space: O(T + n)

Build a trie from all words, then use DP where for each position we traverse the trie to find all valid prefixes starting at that position. This eliminates redundant string comparisons.

Brute Force with Recursion — Algorithm Steps

For each position i in target, try all words
Check if word is a prefix starting at position i
If yes, recursively solve for remaining substring
Return minimum count among all valid splits

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at position 0 of target

Try Prefixes

For each word, check if it matches as prefix

Recurse

If match found, recursively solve remaining substring

Memoize

Store result for each position to avoid recomputation

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MAX_WORDS 100

char words[MAX_WORDS][MAX_LEN];
int wordCount = 0;
char target[MAX_LEN];
int memo[MAX_LEN];
int memoValid[MAX_LEN];

int dfs(int pos) {
    if (pos == strlen(target)) return 0;
    if (memoValid[pos]) return memo[pos];
    
    int result = 1000000; // Large number
    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 subResult = dfs(pos + wordLen);
            if (subResult != -1 && 1 + subResult < result) {
                result = 1 + subResult;
            }
        }
    }
    
    memo[pos] = (result == 1000000) ? -1 : result;
    memoValid[pos] = 1;
    return memo[pos];
}

int solution() {
    memset(memoValid, 0, sizeof(memoValid));
    return dfs(0);
}

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 line[2000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    char* p = strchr(line, '[') + 1;
    char* end = strrchr(line, ']');
    *end = '\0';
    
    char* token = strtok(p, ",");
    while (token != NULL && wordCount < MAX_WORDS) {
        // Remove quotes and spaces
        while (*token == ' ' || *token == '"') token++;
        int len = strlen(token);
        while (len > 0 && (token[len-1] == ' ' || token[len-1] == '"')) {
            token[len-1] = '\0';
            len--;
        }
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, ",");
    }
    
    fgets(target, sizeof(target), stdin);
    target[strcspn(target, "\n")] = 0;
    
    int result = solution();
    printf("%d\n", result);
    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 prefix matching

✓ Linear Growth

Space Complexity

O(n)

Memoization array stores results for each position in target

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

287 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 I - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler