<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:
        
        mod = 10**9 + 7
        base = 53
                
        lt = len(target)
        dq = deque(list(range(1, lt + 1)))
        
        rh = [0]
        mem = defaultdict(set)
        reach = []
        power = [1]
        
        for c in target:
            lv = rh[-1]
            cv = (lv * base + ord(c) - 96) % mod
            rh.append(cv)
            power.append((power[-1] * base) % mod)
            
        for w in words:
            cur = 0
            for i,c in enumerate(w):
                cur = (cur * base + ord(c) - 96) % mod
                mem[i + 1].add(cur)

                
        
        for i in range(lt - 1, -1, -1):
            cl = lt - i
            if cl not in mem:
                break
            pv = rh[i]
            cv = (pv * power[cl]) % mod
            cv2 = (rh[-1] - cv) % mod
            if cv2 in mem[cl]:
                reach.append(i)
                
        if not reach:
            return -1
        
        if reach[-1] == 0:
            return 1
        
        stack = [0]
        step = 0
        
        while stack:
            ll = len(stack)
            for _ in range(ll):
                
                cur = stack.pop(0)
                
                if cur == lt:
                    return step
                
                while dq and dq[0] <= cur:
                    dq.popleft()
                
                while dq:
                    cl = dq[0] - cur
                    if cl not in mem:
                        break
                    cv = rh[dq[0]]
                    pv = (rh[cur] * power[cl]) % mod
                    cv2 = (cv - pv) % mod
                    
                    if cv2 not in mem[cl]:
                        break
                    else:
                        stack.append(dq.popleft())
            step += 1
            
                        
        return -1
        
            
44601