Minimum Number of Valid Strings to Form Target II

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

Imagine you're building words by combining prefix blocks from a dictionary! You have an array of strings words and need to form a target string using the minimum number of valid prefix pieces.

A string is valid if it's a prefix of any word in your dictionary. For example, if words = ["abc", "def"], then "a", "ab", "abc", "d", "de", and "def" are all valid strings.

Your goal is to find the minimum number of these valid prefix strings that can be concatenated together to form the target string. If it's impossible to form the target, return -1.

Example: If words = ["abc", "aaaaa", "bcdef"] and target = "aabcdabc", you could form it as "a" + "abcd" + "abc" = 3 pieces (where "a" is prefix of "abc", "abcd" is prefix of "abcdef" - wait, that's not in words... let me recalculate properly in the examples section!).

Input & Output

example_1.py — Basic case with multiple valid combinations

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

› Output: 3

💡 Note: We can form the target as "aa" + "bcd" + "abc" = 3 pieces. Here "aa" is a prefix of "aaaaa", "bcd" is a prefix of "bcdef", and "abc" is a prefix of "abc".

example_2.py — Impossible case

$ Input: words = ["abc", "def"], target = "xyz"

› Output: -1

💡 Note: No valid prefixes can be found to form "xyz" since none of the characters 'x', 'y', 'z' appear as the first character of any word in the dictionary.

example_3.py — Single word can form target

$ Input: words = ["abcdef"], target = "abc"

› Output: 1

💡 Note: The target "abc" is a prefix of "abcdef", so we need only 1 piece to form it.

Visualization

Tap to expand

Understanding the Visualization

Dictionary Analysis

Extract all possible prefix blocks from dictionary words ["abc", "aaaaa", "bcdef"] → prefixes: {"a", "aa", "aaa", "aaaa", "aaaaa", "ab", "abc", "b", "bc", "bcd", "bcde", "bcdef"}

DP Initialization

Create DP array where dp[i] = minimum blocks to build target[0:i]. Start with dp[0] = 0 (empty string needs 0 blocks)

Position Processing

For each position i, use trie to efficiently find all valid prefixes starting at i, then update dp values for reachable positions

Optimal Solution

dp[target.length] gives the minimum blocks needed. For "aabcdabc": "aa" + "bcd" + "abc" = 3 blocks

Key Takeaway

🎯 Key Insight: The trie data structure transforms an exponential problem into a polynomial one by providing efficient prefix matching, combined with DP to avoid recomputing subproblems.

Time & Space Complexity

Time Complexity

⏱️

O(n² + mk)

n² for DP iterations with trie lookups, mk to build trie (m words, k max length)

⚠ Quadratic Growth

Space Complexity

O(mk + n)

mk for trie nodes, n for DP array

⚡ 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
Time limit: 2 seconds

Asked in

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

The optimal solution uses a trie data structure combined with dynamic programming. Build a trie from all dictionary words to enable efficient prefix matching, then use DP where dp[i] represents the minimum pieces needed to form target[0:i]. For each position, traverse the trie to find all valid prefixes and update reachable positions. Time complexity: O(n² + mk), space: O(mk + n).

Common Approaches

Approach	Time	Space	Notes
✓ Trie + Dynamic Programming (Optimal)	O(n² + mk)	O(mk + n)	Use trie for efficient prefix matching with DP for optimal piece counting
Dynamic Programming with Prefix Set	O(n² + mk²)	O(mk + n)	Build set of all valid prefixes, then use DP to find minimum pieces needed
Brute Force (Recursive Backtracking)	O(2^n * m * k)	O(n)	Try every possible way to split target string and check if each piece is a valid prefix

Trie + Dynamic Programming (Optimal) — Algorithm Steps

Build a trie from all words in the dictionary
Initialize DP array where dp[i] = minimum pieces to form target[0:i]
For each position, use trie to efficiently find all valid prefixes starting there
Update DP values for positions reachable by valid prefixes
Return dp[target.length] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Build trie

Insert all dictionary words into trie structure

Initialize DP

Set dp[0] = 0, others to infinity

Process each position

Use trie to find all valid prefixes efficiently

Update reachable positions

For each valid prefix, update dp[end_position]

Code -

solution.c — C

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

#define ALPHABET_SIZE 26

typedef struct TrieNode {
    struct TrieNode* children[ALPHABET_SIZE];
    int isEnd;
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)calloc(1, sizeof(TrieNode));
    node->isEnd = 0;
    return node;
}

void insert(TrieNode* root, const char* word) {
    TrieNode* node = root;
    for (int i = 0; word[i]; i++) {
        int index = word[i] - 'a';
        if (!node->children[index]) {
            node->children[index] = createNode();
        }
        node = node->children[index];
    }
    node->isEnd = 1;
}

int minValidStrings(char** words, int wordsSize, char* target) {
    // Build trie from all words
    TrieNode* root = createNode();
    for (int i = 0; i < wordsSize; i++) {
        insert(root, words[i]);
    }
    
    int n = strlen(target);
    // dp[i] = minimum pieces to form target[0:i]
    int* dp = malloc((n + 1) * sizeof(int));
    for (int i = 0; i <= n; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int i = 0; i < n; i++) {
        if (dp[i] == INT_MAX) continue;
        
        // Find all valid prefixes starting at position i
        TrieNode* node = root;
        for (int j = i; j < n; j++) {
            int index = target[j] - 'a';
            if (!node->children[index]) break;
            node = node->children[index];
            // Any path in trie represents a valid prefix
            if (dp[i] + 1 < dp[j + 1]) {
                dp[j + 1] = dp[i] + 1;
            }
        }
    }
    
    int result = dp[n] == INT_MAX ? -1 : dp[n];
    free(dp);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n² + mk)

n² for DP iterations with trie lookups, mk to build trie (m words, k max length)

⚠ Quadratic Growth

Space Complexity

O(mk + n)

mk for trie nodes, n for DP array

⚡ 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
Time limit: 2 seconds

58.0K Views

High Frequency

~25 min Avg. Time

1.3K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Trie + Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler