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

import heapq

ord_a = ord('a')

def to_index(c):
    return ord(c) - ord_a

class TrieNode:
    def __init__(self):
        self.child_nodes = [None] * 26
        self.can_terminate = False
    def add_substring(self, w):
        if len(w) == 0:
            self.can_terminate = True
        else:
            first_char = w[0]
            first_index = to_index(first_char)
            if self.child_nodes[first_index] == None:
                self.child_nodes[first_index] = w[1:]
            elif type(self.child_nodes[first_index]) == type(''):
                new_node = TrieNode()
                new_node.add_substring(self.child_nodes[first_index])
                new_node.add_substring(w[1:])
                self.child_nodes[first_index] = new_node
            else:
                self.child_nodes[first_index].add_substring(w[1:])

    def get_length(self, w):
        l = 0
        node = self
        for i,c in enumerate(w):
            c_index = to_index(c)
            child_node = node.child_nodes[c_index]

            if child_node == None:
                break
            elif type(child_node) == type(''):
                l += 1
                for child_node_index, word_index in zip(range(0, len(child_node)), range(i+1, len(w))):
                    if child_node[child_node_index] == w[word_index]: 
                        l += 1
                    else:
                        break
                break
            else:
                node = child_node
                l += 1
        return l

class Solution:
    def minValidStrings(self, words: list[str], target: str) -> int:
        root_node = TrieNode()
        for w in words:
            root_node.add_substring(w)

        included = [False] * len(target)
        q = [(0, 0)]
        while(q):
            cost, negative_index = heapq.heappop(q)
            index = 0 - negative_index
            l = root_node.get_length(target[index:])
            if l == len(target) - index:
                return cost + 1
            for j in range(index+1, index+1+l):
                if included[j]:
                    continue
                included[j] = True
                heapq.heappush(q, (cost + 1, 0 - j))
        return -1

44414