<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 random
from typing import List

# Set up base value and modulo for polynomial rolling hash
base = random.randint(100, 200)  # base for hashing
mod = random.getrandbits(40)     # large prime-like mod to avoid collisions

# Precompute powers of base modulo mod
powers = [1]
for _ in range(10**5):
    powers.append(powers[-1] * base % mod)

class Solution:
    def minValidStrings(self, words: List[str], target: str) -> int:
        n = len(target)

        # Step 1: Precompute hash values for all prefixes of words
        word_hash_set = set()
        for word in words:
            h = 0
            for c in word:
                h = (h * base + ord(c)) % mod
                word_hash_set.add(h)

        # Step 2: Precompute prefix hashes for the target string
        target_hash = [0]
        for c in target:
            target_hash.append((target_hash[-1] * base + ord(c)) % mod)

        # Step 3: Greedily split the target string into valid substrings
        l = r = 0
        splits = 0
        
        while r < n:
            max_r = r  # Track the farthest valid match for the current substring
            
            for i in range(l, r + 1):
                low, high = i, n - 1
                
                # Binary search to find the farthest valid substring starting at i
                while low <= high:
                    mid = (low + high) // 2
                    h = (target_hash[mid + 1] - target_hash[i] * powers[mid + 1 - i] % mod) % mod
                    
                    if h in word_hash_set:
                        low = mid + 1  # Try to extend the match
                    else:
                        high = mid - 1  # Shrink the window
                
                max_r = max(max_r, high + 1)  # Update max right for valid match

            if max_r == r:
                return -1  # If no valid extension is found, return -1
            
            # Move window to the next unmatched part of target
            l, r = r + 1, max_r
            splits += 1  # One valid substring used
        
        return splits
27826