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

_mod = 344555666677777
_base = 37
_inv = pow(_base, _mod-2, _mod)
_p_pref, _inv_pref = [1], [1]

class PrefixHash:
    #Input a string encoded as an array (e.g. numbers bounded from 0-26)
    #Initialization is O(n)
    def __init__(self, arr):
        self.mod = _mod
        self.pref = pref = [0]
        hsh = 0
        for i, x in enumerate(arr):
            #Extend global modular prefix if needed
            if len(_p_pref) <= i+1:
                _p_pref.append((_p_pref[-1]*_base)%_mod)
                _inv_pref.append((_inv_pref[-1]*_inv)%_mod)
            hsh = (hsh+x*_p_pref[i+1])%_mod
            pref.append(hsh)
    #Obtain the hash of a substring [l, ... r] in O(1)
    #Inclusive of l and r
    def query(self, l, r):
        return (self.pref[r+1]-self.pref[l])*_inv_pref[l]%self.mod
        
class Solution:
    def minValidStrings(self, words: List[str], target: str) -> int:
        m, n = len(words), len(target)
        enc = lambda c: ord(c)-96
        seen = set()
        for w in words:
            for hsh in PrefixHash(map(enc, w)).pref[1:]:
                seen.add(hsh)
        # hshs = list(map(PrefixHash, [map(enc, w) for w in words]))
        pref = PrefixHash(map(enc, target))
        dp = [inf]*n + [0]
        def alike(i):
            l, r = i-1, n
            while r-l>1:
                m = l+(r-l)//2
                if pref.query(i, m) in seen:
                    l = m
                else:
                    r = m
            return l
        for i in range(n-1, -1, -1):
            #Furthest up
            idx = alike(i)+1
            for j in range(i, idx):
                if dp[j]<=dp[idx]+1: break
                dp[j] = dp[idx]+1
        return dp[0] if dp[0] != inf else -1
22420