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

pw = 131
mod = int(10**19) + 7
pws = [1]
for _ in range(10**5):
    pws.append((pws[-1]*pw)%mod)

class Solution:
    def minValidStrings(self, words, target):
        n = len(target)
        vis = set()
        for word in words:
            h = 0
            for c in word:
                h = (h*pw + ord(c)-ord('a')+1)%mod
                vis.add(h)
        acc = [0]
        for c in target:
            acc.append((acc[-1]*pw + ord(c)-ord('a')+1)%mod)
        l, r, cnt = 0, 0, 0
        while r < n:
            nr = r
            for i in range(l, r+1):
                left, right = i, n-1
                while left <= right:
                    mid = (left + right)//2
                    h = (acc[mid+1]-(acc[i]*pws[mid+1-i])%mod+mod)%mod
                    if h in vis:
                        left = mid + 1
                    else:
                        right = mid - 1
                if right + 1 > nr:
                    nr = right + 1
                mid = right
            if nr == r: return -1
            l, r = r+1, nr
            cnt += 1
        return cnt


        '''
        children = [{}]
        failure = [0]
        output = [0]
        for word in words:
            node = 0
            for i, c in enumerate(word):
                if c not in children[node]:
                    children.append({})
                    failure.append(0)
                    output.append(0)
                    children[node][c] = len(children) - 1
                node = children[node][c]
                output[node] = max(output[node], i + 1)
        queue = deque()
        for c in children[0]:
            child = children[0][c]
            failure[child] = 0
            queue.append(child)
        while queue:
            current = queue.popleft()
            for c, child in children[current].items():
                f = failure[current]
                while c not in children[f] and f != 0:
                    f = failure[f]
                failure[child] = children[f].get(c, 0)
                output[child] = max(output[child], output[failure[child]])
                queue.append(child)
        N = len(target)
        dp = [float('inf')] * (N + 1)
        dp[0] = 0
        node = 0
        for i in range(1, N + 1):
            c = target[i - 1]
            while c not in children[node] and node != 0:
                node = failure[node]
            node = children[node].get(c, 0)
            if output[node]:
                l = output[node]
                if i - l >= 0:
                    dp[i] = min(dp[i], dp[i - l] + 1)
        return dp[N] if dp[N] != float('inf') else -1
        '''
31181