<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 Node:
    def __init__(self):
        self.next = [None]*26
    def insert(self,word,root):
        temp = root
        for c in word:
            idx = ord(c)-ord('a')
            if (temp.next[idx] is None):
                temp.next[idx]=Node()
            temp=temp.next[idx]

class Solution:
    def __init__(self):
        self.n=0
        self.target=""
        self.dp=[]
        
    
    def solve(self ,root, idx):
        if(idx==self.n):
            return 0
        if(self.dp[idx]!=-1):
            return self.dp[idx]
        temp = root
        ans = float('inf')
        for i in range(idx,self.n):
            nextIndex = ord(self.target[i])-ord('a')
            if(temp.next[nextIndex] is None):
                break
            else:
                temp=temp.next[nextIndex]
                t=self.solve(root,i+1)
                if(t!=float('inf')):
                    ans=min(ans,1+t)
        self.dp[idx] = ans
        return ans



    def minValidStrings(self, words: List[str], target: str) -> int:
        root = Node()
        for word in words:
            root.insert(word,root)
        # self.dp = [-1]*len(target)
        # self.n=len(target)
        # self.target = target
        # ans = self.solve(root,0)
        # if(ans==float('inf')):
        #     return -1
        # else:
        #     return ans
        n = len(target)
        dp = [float('inf')] * (n + 1)
        dp[0] = 0  # No word is needed to form an empty string
        
        # Iterate over each position in the target string
        for i in range(n):
            if dp[i] == float('inf'):
                continue  # Skip if this position is unreachable

            # Start from the current position i and try to form valid words
            temp = root
            for j in range(i, n):
                nextIndex = ord(target[j]) - ord('a')
                if temp.next[nextIndex] is None:
                    break  # No valid word starts with this prefix
                temp = temp.next[nextIndex]
                
                # If we reach position j+1, it means we have found a valid word
                dp[j + 1] = min(dp[j + 1], dp[i] + 1)
        
        # If dp[n] is still infinity, it means we couldn't form the target string
        return dp[n] if dp[n] != float('inf') else -1

39038