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

class Solution:
    def minValidStrings(self, words: List[str], target: str) -> int:
        p, mod = 26, (1<<31)-1
        pInv = pow(p, mod-2, mod)
        mxLen = max(len(w) for w in words)
        hSets = [set() for _ in range(mxLen)]

        for word in words:
            h = 0
            for i,c in enumerate(word):
                h = (h*p + ord(c)-97) % mod
                hSets[i].add(h)
        
        h, length, power, dp = 0, 0, 1, [0]
        for i,c in enumerate(target):
            h = (h*p + ord(c)-97) % mod
            while length >= 0 and (length == mxLen or h not in hSets[length]):
                h = (h - (ord(target[i-length])-97)*power) % mod
                power = power * pInv % mod
                length -= 1
            if length < 0:   return -1
            power = power * p % mod
            dp.append(dp[i-length]+1)
            length += 1
        return dp[-1]

        n, m = len(words), len(target)
        kmps = [[0] for _ in range(n)]

        for i in range(n):
            ptr = 0
            for c in words[i][1:]:
                while ptr and words[i][ptr] != c:   ptr = kmps[i][ptr-1]
                if words[i][ptr] == c:  ptr += 1
                kmps[i].append(ptr)
            words[i] += '*'
            kmps[i].append(0 if ptr < 1 else ptr-1)
            
        
        # for kmp in kmps:
        #     print(kmp)

        ptrs, dp = [0]*n, [inf]*m + [0]
        for i in range(m):
            for j in range(n):
                while ptrs[j] and words[j][ptrs[j]] != target[i]:   ptrs[j] = kmps[j][ptrs[j]-1]
                if words[j][ptrs[j]] == target[i]:  ptrs[j] += 1
                if dp[i-ptrs[j]] + 1 < dp[i]:   dp[i] = dp[i-ptrs[j]]+1
            if dp[i] == inf:
                return -1
                
        return dp[-2]

32858