<p>You are given an array of strings <code>words</code> and a string <code>target</code>.</p>

<p>A string <code>x</code> is called <strong>valid</strong> if <code>x</code> is a <span data-keyword="string-prefix">prefix</span> of <strong>any</strong> string in <code>words</code>.</p>

<p>Return the <strong>minimum</strong> number of <strong>valid</strong> strings that can be <em>concatenated</em> to form <code>target</code>. If it is <strong>not</strong> possible to form <code>target</code>, return <code>-1</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">words = [&quot;abc&quot;,&quot;aaaaa&quot;,&quot;bcdef&quot;], target = &quot;aabcdabc&quot;</span></p>

<p><strong>Output:</strong> <span class="example-io">3</span></p>

<p><strong>Explanation:</strong></p>

<p>The target string can be formed by concatenating:</p>

<ul>
	<li>Prefix of length 2 of <code>words[1]</code>, i.e. <code>&quot;aa&quot;</code>.</li>
	<li>Prefix of length 3 of <code>words[2]</code>, i.e. <code>&quot;bcd&quot;</code>.</li>
	<li>Prefix of length 3 of <code>words[0]</code>, i.e. <code>&quot;abc&quot;</code>.</li>
</ul>
</div>

<p><strong class="example">Example 2:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">words = [&quot;abababab&quot;,&quot;ab&quot;], target = &quot;ababaababa&quot;</span></p>

<p><strong>Output:</strong> <span class="example-io">2</span></p>

<p><strong>Explanation:</strong></p>

<p>The target string can be formed by concatenating:</p>

<ul>
	<li>Prefix of length 5 of <code>words[0]</code>, i.e. <code>&quot;ababa&quot;</code>.</li>
	<li>Prefix of length 5 of <code>words[0]</code>, i.e. <code>&quot;ababa&quot;</code>.</li>
</ul>
</div>

<p><strong class="example">Example 3:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">words = [&quot;abcdef&quot;], target = &quot;xyz&quot;</span></p>

<p><strong>Output:</strong> <span class="example-io">-1</span></p>
</div>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= words.length &lt;= 100</code></li>
	<li><code>1 &lt;= words[i].length &lt;= 5 * 10<sup>3</sup></code></li>
	<li>The input is generated such that <code>sum(words[i].length) &lt;= 10<sup>5</sup></code>.</li>
	<li><code>words[i]</code> consists only of lowercase English letters.</li>
	<li><code>1 &lt;= target.length &lt;= 5 * 10<sup>3</sup></code></li>
	<li><code>target</code> consists only of lowercase English letters.</li>
</ul>


'''class Trie:
    def __init__(self, *words):
        self.root = {}
        for word in words:
            self.add(word)

    def add(self, word):
        current_dict = self.root
        for letter in word:
            current_dict = current_dict.setdefault(letter, {})
        current_dict["_end_"] = True

    def __contains__(self, word):
        current_dict = self.root
        for letter in word:
            if letter not in current_dict:
                return False
            current_dict = current_dict[letter]
        return "_end_" in current_dict

    def __delitem__(self, word):
        current_dict = self.root
        nodes = [current_dict]
        for letter in word:
            current_dict = current_dict[letter]
            nodes.append(current_dict)
        del current_dict["_end_"]
'''

class Node:
    def __init__(self, ):
        self.children = {}
        self.is_word = False

class Trie:
    def __init__(self):
        self.root = Node()
        self.result = []

    def insert(self, word: str):
        node = self.root
        for w in word:
            if w not in node.children:
                node.children[w] = Node()
            node = node.children[w]
        node.is_word = True

class Solution:
    def minValidStrings(self, words: List[str], target: str) -> int:
        
        '''
        pos = set()
        
        for w in words:
            for i in range(1,len(w)+1):
                pos.add(w[:i])
        
        #print(pos)
        N = len(target)
        @cache
        def dp(i):
            
            if i == N:
                return 0
            
            res = inf
            
            #node = trie.root

            for j in range(N, i-1, -1 ) :
                
                sub = target[i:j]
                #print(sub, i, j)
                
                if sub in pos and dp(j) != inf:
                    #print(i,j, sub)
                    #return 1 + dp( j )
                    res = min( res,  1 + dp(j ) )
                #letter = target[j]

                #if letter not in node.children:
                #    break

                #if dp(j + 1) != inf:  
                #    res = min( res,  1 + dp(j + 1) )

                #node = node.children[letter]
            
            return res
        
        
        res = dp(0)
        
        return res if res != inf else -1
        
        
        trie = Trie()
        
        for w in words:
            trie.insert(w)

        N = len(target)

        
        @cache
        def dp(i):
            
            if i == N:
                return 0
            
            res = inf
            
            node = trie.root

            for j in range(i , N ) :

                letter = target[j]

                if letter not in node.children:
                    break

                if dp(j + 1) != inf:  
                    res = min( res,  1 + dp(j + 1) )

                node = node.children[letter]
            
            return res
        
        
        res = dp(0)
        
        return res if res != inf else -1
    
        
        
        trie = Trie()
        
        for w in words:
            trie.insert(w)

        N = len(target)

        
        @cache
        def dfs(i ):
            
            if i == N:
                return 0
            
            res = inf
            
            node = trie.root

            j = 0
            for j in range(i , N ) :

                letter = target[j]

                if letter not in node.children:
                    
                    return 1 + dfs(j)

                #if dp(j + 1) != inf:  
                #    res = min( res,  1 + dp(j + 1) )

                node = node.children[letter]
            
            return 1 + dfs(j)
        
        
        res = dfs(0)
        
        return res if res != inf else -1
        '''
        
        trie = Trie()
        
        #for w in words:
        #    for i in range(1,len(w)+1):
        #        pos.add(w[:i:][::-1])
        for w in words:
            trie.insert(w)

        N = len(target)

        
        @cache
        def dp(i):
            
            if i == N:
                return 0
            
            res = inf
            
            node = trie.root
            
            vals = []

            for j in range(i , N ) :

                letter = target[j]

                if letter not in node.children:
                    break

                #if dp(j + 1) != inf:  
                vals.append(j + 1)
                #res = min( res,  1 + dp(j + 1) )

                node = node.children[letter]
            
            #print(i,i,i)
            ccc = 0
            for v in vals[::-1]:
                if dp(v) != inf:
                    #print(1+dp(v))
                    res = min(res, 1 + dp(v))
                    #return 1 + dp(v)
                    ccc += 1
                if ccc == 100:
                    break
            
            return res
        
        
        res = dp(0)
        
        return res if res != inf else -1
46369