Minimum Number of Valid Strings to Form Target I

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

Imagine you're building words from a collection of building blocks! You have an array of strings called words and a target string you want to construct.

Here's the twist: you can only use prefixes of the words in your collection. A string x is valid if it matches the beginning of any word in words.

Your mission: Find the minimum number of valid strings that can be concatenated together to form the exact target string. If it's impossible to construct the target, return -1.

Example: If words = ["abc", "aaaaa", "bcdef"] and target = "aabcdabc", you could use prefixes like "aa" (from "aaaaa"), "bcd" (from "bcdef"), and "abc" (from "abc") to build your target efficiently!

Input & Output

example_1.py — Basic Example

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

› Output: 3

💡 Note: We can form the target using 3 valid strings: "aa" (prefix of "aaaaa") + "bcd" (prefix of "bcdef") + "abc" (prefix of "abc"). This gives us "aabcdabc".

example_2.py — Impossible Case

$ Input: words = ["abababab", "ab"], target = "aaabccababa"

› Output: -1

💡 Note: It's impossible to form the target because we need the character 'c' which doesn't appear at the start of any word in the array.

example_3.py — Single Character

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

› Output: 2

💡 Note: We can form "aaaa" using "aa" + "aa" (both are prefixes of words in the array). We could also use "aaa" + "a", but both solutions use 2 prefixes.

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we might try all possible ways to split the target string, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to the length of target string

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 5 × 10³
1 ≤ target.length ≤ 5 × 10³
words[i] and target consist only of lowercase English letters
The input is guaranteed that at least one valid prefix exists for each character in target

Asked in

This problem requires finding the minimum number of valid prefixes to construct a target string. The optimal approach uses a Trie data structure combined with dynamic programming. Build a Trie containing all possible prefixes from the input words, then use DP working backwards from the target string's end. For each position, traverse the Trie to efficiently find all valid prefixes and update the DP array with the minimum count. Time complexity is O(n × L) where n is target length and L is maximum word length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive Backtracking)	O(2^n)	O(n)	Try all possible ways to split the target using valid prefixes recursively
Dynamic Programming with Prefix Set	O(n² × m)	O(P + n)	Build a set of all valid prefixes, then use DP to find minimum splits
Trie + Dynamic Programming (Optimal)	O(n × L)	O(T + n)	Use Trie for efficient prefix matching with DP for optimal substructure

Brute Force (Recursive Backtracking) — Algorithm Steps

Generate all possible prefixes from the words array
Use recursive function to try forming target from each position
For each position, try all valid prefixes that match the current substring
Recursively solve for the remaining part and track minimum count
Use memoization to avoid recalculating the same subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Begin trying to form the target from the beginning

Try each valid prefix

For each position, attempt all prefixes that match the current substring

Recurse on remainder

After using a prefix, recursively solve for the remaining part

Backtrack and try next

If a path doesn't work, backtrack and try the next option

Return minimum count

Among all successful paths, return the one with minimum prefix count

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_LEN 1000

typedef struct {
    char prefixes[MAX_WORDS * MAX_LEN][MAX_LEN];
    int count;
} PrefixSet;

int memo[MAX_LEN];
int memoSet[MAX_LEN];

int containsPrefix(PrefixSet* set, char* str) {
    for (int i = 0; i < set->count; i++) {
        if (strcmp(set->prefixes[i], str) == 0) {
            return 1;
        }
    }
    return 0;
}

int dfs(int pos, char* target, PrefixSet* prefixes) {
    int targetLen = strlen(target);
    
    if (pos == targetLen) {
        return 0;
    }
    
    if (memoSet[pos]) {
        return memo[pos];
    }
    
    int result = INT_MAX;
    char substring[MAX_LEN];
    
    // Try all possible prefixes starting from current position
    for (int i = pos + 1; i <= targetLen; i++) {
        strncpy(substring, target + pos, i - pos);
        substring[i - pos] = '\0';
        
        if (containsPrefix(prefixes, substring)) {
            int subResult = dfs(i, target, prefixes);
            if (subResult != INT_MAX) {
                if (1 + subResult < result) {
                    result = 1 + subResult;
                }
            }
        }
    }
    
    memo[pos] = result;
    memoSet[pos] = 1;
    return result;
}

int minValidStrings(char words[][MAX_LEN], int wordsSize, char* target) {
    // Initialize memo
    memset(memoSet, 0, sizeof(memoSet));
    
    // Generate all possible prefixes
    PrefixSet prefixes;
    prefixes.count = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        int wordLen = strlen(words[i]);
        for (int j = 1; j <= wordLen; j++) {
            strncpy(prefixes.prefixes[prefixes.count], words[i], j);
            prefixes.prefixes[prefixes.count][j] = '\0';
            prefixes.count++;
        }
    }
    
    int ans = dfs(0, target, &prefixes);
    return ans == INT_MAX ? -1 : ans;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we might try all possible ways to split the target string, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to the length of target string

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 5 × 10³
1 ≤ target.length ≤ 5 × 10³
words[i] and target consist only of lowercase English letters
The input is guaranteed that at least one valid prefix exists for each character in target

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Recursive Backtracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler