<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 Solution:
    def minValidStrings(self, words: List[str], target: str) -> int:
        t = Trie(words)
        l = len(target)
        dp = [inf] * (l+1)
        dp[l] = 0
        for i in range(len(target)-1,-1,-1):
            trie = t.root
            for j in range(i, len(target)):
                letter = target[j]
                if letter not in trie.children:
                    break
                trie = trie.children[letter]
                dp[i] = min(dp[i], dp[j + 1] + 1)
        return dp[0] if dp[0] != inf else -1

class Node:
    def __init__(self):
        self.children = defaultdict(Node)
        self.cnt = 0
        self.word = None

class Trie:
    def __init__(self, words=None):
        self.root = Node()
        if not words:
            words = []
        for word in words:
            self.add(word)

    def add(self, word):
        cur = self.root
        for letter in word:
            cur = cur.children[letter]
        cur.cnt += 1
        cur.word = word

    def __contains__(self, word):
        cur = self.root
        for letter in word:
            if letter not in cur.children:
                return False
            cur = cur.children[letter]
        return cur.cnt > 0

    def matchall(self, word):
        cur = self.root
        for idx, letter in enumerate(word):
            if letter not in cur.children:
                return
            cur = cur.children[letter]
            if cur.cnt:
                yield idx + 1

    def __getitem__(self, word):
        cur = self.root
        for letter in word:
            if letter not in cur.children:
                return 0
            cur = cur.children[letter]
        return cur.cnt

    def delete(self, word, all=False):
        stack = []
        cur = self.root
        for letter in word:
            if letter not in cur.children:
                return
            stack.append((cur, letter))
            cur = cur.children[letter]
        if all:
            cur.cnt = 0
        else:
            cur.cnt -= 1
        if cur.cnt <= 0:
            cur.word = None
        if cur.cnt > 0 or cur.children:
            return
        while stack:
            parent, letter = stack.pop()
            del parent.children[letter]
            if parent.cnt > 0 or parent.children:
                break
36105