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

# pre-calculate all pow(B, i, M) with linear time
B = 131
M = 212370440130137957
PBM = []
h = 1
for i in range(60_000):
    PBM.append(h)
    h = h * B % M

class Solution:
    def minValidStrings(self, words: List[str], target: str) -> int:
        # Calculate hash from left right right
        # Example: hash('abc') = (a * B ** 2 + b * B **1 + c * B ** 0) % M
        # Suffix hash: hash(s2) = (hash(s1 + s2) - hash(s1) * B ** len(s2)) % M
        valid_h = set()
        for w in words:
            h = 0
            for c in w:
                h = (h * B + ord(c)) % M
                valid_h.add(h)
        
        target_h = [0]  # Exclusive indexing: target_h[i] = hash(target[:i])
        h = 0
        for c in target:
            h = (h * B + ord(c)) % M
            target_h.append(h)
            
        def has_sub(l, r):  # test whether target[l:r] is valid
            return (target_h[r] - target_h[l] * PBM[r - l]) % M in valid_h

        left, right = 0, 1  # First str must start with target[0:1]
        for result in range(1, len(target)+1):
            new_right = right
            for i in range(left, right):
                while has_sub(i, new_right):
                    if new_right == len(target):
                        return result
                    new_right += 1
            if new_right == right:  # no update means failed
                return -1
            left, right = right, new_right

23886