<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:
        hbase, hmod = 43, 1027439813
        
        lmax = max(len(word) for word in words)
        hashes = [set() for _ in range(lmax)]
        hpow = [1]
        for i in range(lmax):
            hpow.append((hpow[-1] * hbase) % hmod)
        
        for word in words:
            h = 0
            for i, c in enumerate(word):
                h = (h + (ord(c) - ord('a')) * hpow[i]) % hmod
                hashes[i].add(h)
        
        base, n = 1, len(target)
        while base <= n:
            base <<= 1
        
        seg = [n + 1] * 2 * base
        
        def query(node, l, r, L, R):
            if l == L and r == R:
                return seg[node]
            M = (L + R) >> 1
            if r <= M:
                return query(node << 1, l, r, L, M)
            elif l > M:
                return query((node << 1) | 1, l, r, M + 1, R)
            else:
                return min(query(node << 1, l, M, L, M), query((node << 1) | 1, M + 1, r, M + 1, R))
        
        def insert(node, x):
            seg[node] = x
            while node > 1:
                seg[node >> 1] = min(seg[node], seg[node ^ 1])
                node >>= 1

        insert(base + n, 0)
        hash = [0]
        for i in range(n - 1, -1, -1):
            hash.append((hash[-1] * hbase + ord(target[i]) - ord('a')) % hmod)
            start, end = 0, min(lmax, n - i) + 1
            while end - start > 1:
                mid = (start + end) >> 1
                if (hash[-1] + hmod - (hash[-mid - 1] * hpow[mid]) % hmod) %  hmod in hashes[mid - 1]:
                    start = mid
                else:
                    end = mid

            if start:
                best = query(1, i + 1, i + start, 0, base - 1)
                insert(base + i, best + 1)
        
        return seg[base] if seg[base] <= n else -1
39568