<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>4</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>4</sup></code></li>
	<li><code>target</code> consists only of lowercase English letters.</li>
</ul>

from sortedcontainers import SortedList

class TrieNode:
    def __init__(self):
        self.children = {}
        self.len = 0
        self.next = None
    
class Trie:
    def __init__(self):
        self.root = TrieNode()
        self.root.next = self.root

    def add_word(self, word):
        cur = self.root
        for idx, c in enumerate(word):
            if c not in cur.children:
                cur.children[c] = TrieNode()
            cur = cur.children[c]
            cur.len  = idx + 1
            cur.next = self.root
    
def bfs(my_trie):
    q = collections.deque([])
    for _, child_node  in my_trie.root.children.items():
        q.append(child_node)
    
    while q:
        cur = q.popleft()
        for c, child_node in cur.children.items():
            tmp = cur.next
            while tmp != my_trie.root and c not in tmp.children:
                tmp = tmp.next

            if c in tmp.children:
                child_node.next = tmp.children[c]
            
            q.append(child_node)
        

class Solution:
    def minValidStrings(self, words: List[str], target: str) -> int:
        my_trie = Trie()
        for w in words:
            my_trie.add_word(w)

        bfs(my_trie)

        maxlen = [None] * len(target)

        cur_start = 0
        cur_end = 0
        cur_node = my_trie.root

        while cur_start < len(target):
            while cur_end < len(target) and target[cur_end] in cur_node.children:
                cur_node = cur_node.children[target[cur_end]]
                cur_end += 1
            maxlen[cur_start] = cur_end - cur_start
            
            if cur_node == my_trie.root:
                cur_start += 1
                cur_end = cur_start
            else:
                cur_node = cur_node.next
                cur_start = cur_end - cur_node.len
        
        dp = [0] * (len(target) + 1)
        q = collections.deque([])
        for i in range(len(target)):
            if maxlen[i]:
                q.append((i, i + maxlen[i]))
            
            while q:
                if q[0][1] <= i:
                    q.popleft()
                else:
                    break
            
            if not q:
                return -1
            
            dp[i + 1] = dp[q[0][0]] + 1

        return dp[-1] 


                

        


        
49633