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

    def __init__(self):
        self.children = [None]*26
        self.is_end = False

class Trie:

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

    def exist(self, node, char):
        return node.children[ord(char) - 97] is not None

    def insert(self, word):
        curr_node = self.root
        for char in word:
            if not self.exist(curr_node, char):
                curr_node.children[ord(char) - 97] = TreeNode()

            curr_node = curr_node.children[ord(char) - 97]

        curr_node.is_end = True


    # def search(self, word, idx):
    #     curr_node = self.root
    #     for i in range(idx, len(word)):
    #         char = word[i]
    #         if not self.exist(curr_node, char):
    #             return i
    #         else:
    #             curr_node = curr_node.children[ord(char) - 97]

    #     return i+1

class Solution:
    def minValidStrings(self, words: List[str], target: str) -> int:
        '''
        Trie used for prefix search
        Greedy wont work; check this examples -> ["b","ccacc","a"], target = "cccaaaacba", output -> 8
        We will need to use DP on trie.
        '''
        trie = Trie()
        for word in words:
            trie.insert(word)
        
        n = len(target)
        dp = [None]*n # store min valid strings after this point
        def recurse_minValidStrings(i):
            # base cases
            if i==n:
                return 0

            # core logic
            if dp[i]!=None:
                return dp[i]

            curr_node = trie.root
            ans = float('inf')
            for x in range(i, n):
                char = target[x]
                if not trie.exist(curr_node, char):
                    break
                # case don't include the next in prefix
                curr = 1 + recurse_minValidStrings(x+1)
                ans = min(ans, curr)
                curr_node = curr_node.children[ord(char) - 97] # in the next call we will include the prefix; as x also increases and curr_node also moves

            dp[i] = ans
            return dp[i]

        def tabulate_minValidStrings():
            dp = [None]*(n+1)
            dp[n] = 0 # base case

            for i in range(n-1, -1, -1):
                curr_node = trie.root
                ans = float('inf')
                for x in range(i, n):
                    char = target[x]
                    if not trie.exist(curr_node, char):
                        break
                    curr = 1 + dp[x+1]
                    ans = min(ans, curr)
                    curr_node = curr_node.children[ord(char) - 97] 
                dp[i] = ans
            return dp[i]

        # ans = recurse_minValidStrings(0)
        ans = tabulate_minValidStrings()
        return -1 if ans == float('inf') else int(ans)
44903