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

import types

from typing import List
from collections import defaultdict
import time
# from atcoder.lazysegtree import LazySegTree
class Solution:
    def minValidStrings(self, words: List[str], target: str) -> int:
        z = 131
        MOD = 212370440130137957
        startt = time.time()
        powZ = [1]
        ts = list(map(ord, target))
        for _ in ts:
            powZ.append(powZ[-1] * z % MOD)

        pre = [0]
        for x in ts:
            pre.append((pre[-1] * z + x) % MOD)
        l2prep = [set([0])]
        for w in words:
            w = list(map(ord, w))
            h = 0
            for l in range(1, len(w) + 1):
                h = (h * z + w[l - 1]) % MOD
                if len(l2prep) <= l:
                    l2prep.append(set())
                l2prep[l].add(h)
        #print(f'diff={time.time() - startt}')
        #print(f'l2pre={l2prep}, pre={pre}')
        n = len(target)
        f, t, ans = 0, 0, 0
        while t < n:
            #print(f'f={f}, t={t}, ans={ans}')
            newt = t
            for i in range(f, t + 1):
                ok, ng = i, n + 1
                while ok + 1 < ng:
                    cen = (ok + ng) // 2
                    h = (pre[cen] + MOD - pre[i] * powZ[cen - i] % MOD) % MOD
                    if cen - i < len(l2prep) and h in l2prep[cen - i]:
                        ok = cen
                    else:
                        ng = cen
                #print(f'i={i}, ok={ok},newt={newt}, ans={ans}, n={n}')
                newt = max(newt, ok)
            if newt == t:
                return -1
            f, t = t, newt
            ans += 1
        #print(f'diff={time.time() - startt}')
        return ans

34536