<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:
        # def zAlgorithm(s):
        #     n = len(s)
        #     if n == 0:
        #         return []
        #     if n == 1:
        #         return [-1]
            
        #     z = [0]*n; z[0] = -1

        #     l,r = 0,0
        #     for j in range(1,n):
        #         if j>r:
        #             l,r = j,j
        #             while r < n:
        #                 if s[r] == s[r-j]:
        #                     z[j] += 1
        #                     r += 1
        #                 else:
        #                     break
        #             r -= 1
        #         else:
        #             if r-j+1 >= z[j-l]:
        #                 z[j] = z[j-l]
        #             else:
        #                 z[j] = r-j+1
        #                 l,r = j,r+1
        #                 while r < n:
        #                     if s[r] == s[r-j]:
        #                         z[j] += 1
        #                         r += 1
        #                     else:
        #                         break
        #                 r-=1
        #         print(j,l,r,z[j])
        #     return z
        def zAlgorithm(s):
            Z = [len(s)]+[0]*(len(s)-1)
            l,r = 0,0
            for i in range(1,len(s)):
                if i > r:
                    j = i
                    while j < len(s) and s[j-i] == s[j]:
                        j+=1
                    Z[i] = j-i
                    l,r = i,j-1
                else:
                    j = i+min(Z[i-l],r-i+1)
                    if j <= r:
                        Z[i] = j-i
                    else:
                        while j<len(s) and s[j-i] == s[j]:
                            j+=1
                        Z[i] = j-i
                        l,r = i,j-1
            return Z
        
        n = len(target)
        zArr = [zAlgorithm(word+"_"+target)[-n:] for word in words]

        zArrMax = []
        for i in range(n):
            zArrMax.append(max([zArr[j][i] for j in range(len(words))]))
        
        # print(zArr)
        iStep = 1
        if zArrMax[0] == 0:
            return -1
        visitedByLastStepBegin,visitedByLastStepEnd = 0,zArrMax[0]-1
        while visitedByLastStepEnd < n-1:
            iStep += 1
            visitedByThisStepBegin = visitedByLastStepEnd + 1
            visitedByThisStepEnd = visitedByLastStepEnd
            for i in range(visitedByLastStepBegin+1,visitedByLastStepEnd+2):
                if visitedByThisStepEnd < (i+zArrMax[i]-1):
                    visitedByThisStepEnd = i+zArrMax[i]-1
            # print(iStep,visitedByThisStepBegin,visitedByThisStepEnd)
            if visitedByThisStepEnd < visitedByThisStepBegin:
                return -1
            visitedByLastStepBegin = visitedByThisStepBegin
            visitedByLastStepEnd   = visitedByThisStepEnd
            
        return iStep

        

        iVisited = -1

                
                    
            
            

58021