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

    def __init__(self, is_word = False):
        self.children = defaultdict(TrieNode)
        self.is_word = is_word

class Trie:

    def __init__(self):
        self.root = TrieNode()

    def insert(self, word: str) -> None:
        curr_node = self.root
        for letter in word:
            if letter not in curr_node.children:
                curr_node.children[letter] = TrieNode()
            curr_node = curr_node.children[letter]
        curr_node.is_word = True

    def searchPrefix(self, word:str) -> bool:
        curr_node = self.root
        for letter in word:
            if letter not in curr_node.children:
                return None
            curr_node = curr_node.children[letter]
        return curr_node

    def search(self, word: str) -> bool:
        curr_node = self.searchPrefix(word)
        return curr_node is not None

    def find_valid(self, word):
        curr_node = self.root
        ans = []
        for i in range(len(word)):
            if word[i] in curr_node.children:
                ans.append(i)
                curr_node = curr_node.children[word[i]]
            else:
                break
        return ans

        
    def startsWith(self, prefix: str) -> bool:
        curr_node = self.searchPrefix(prefix)
        return curr_node is not None

class Solution:
    def minValidStrings(self, words: List[str], target: str) -> int:
        prefixes = set()
        trie = Trie()
        for word in words:
            trie.insert(word)

        q = [(0, 0)] # store curr_string, num_valid_strings_so_far
        heapq.heapify(q)
        dist = defaultdict(lambda: float("inf"))

        while q:
            num_moves, curr_index = heapq.heappop(q)
            #print(curr_index)

            if curr_index == len(target):
                return num_moves

            if dist[curr_index] < num_moves:
                continue

            lengths = trie.find_valid(target[curr_index:len(target)])

            for length in lengths:
                if dist[curr_index + length] > num_moves + 1:
                    dist[curr_index + length] = num_moves + 1
                    heapq.heappush(q, (num_moves + 1, curr_index + length + 1))
        return -1


35128