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


def get_lps(s: str) -> list[int]:
    result = [0] * len(s)
    l = 0
    i = 1
    while i < len(s):
        if s[l] == s[i]:
            l += 1
            result[i] = l
            i += 1
        elif l > 0:
            l = result[l-1]
        else:
            result[i] = 0
            i += 1
    return result

def get_backward_lengths_naive(target, word):
    backward_lengths = [0] * len(target)
    for start_index in range(len(target)):
        for word_index in range(len(word)):
            target_index = start_index + word_index
            if target_index >= len(target):
                break
            if word[word_index] != target[target_index]:
                break
            backward_lengths[target_index] = max(backward_lengths[target_index], word_index + 1)
    return backward_lengths

def get_backward_lengths_kmp(target, w):
    backward_lengths = [0] * len(target)
    lps = get_lps(w)
    w_index = -1
    i = 0
    while i < len(target):
        if w_index == len(w) - 1:
            w_index = lps[w_index] - 1
        elif target[i] == w[w_index+1]:
            w_index += 1
            backward_lengths[i] = max(backward_lengths[i], w_index + 1)
            i += 1
        elif (w_index != -1):
            w_index = lps[w_index] - 1
        else:
            i += 1
    return backward_lengths


class Solution:
    def minValidStrings(self, words: list[str], target: str) -> int:
        backward_lengths = [0] * len(target)
        for w in words:
            bw_2 = get_backward_lengths_kmp(target, w)
            #bw_3 = get_backward_lengths_naive(target, w)
            #if (bw_2 != bw_3):
            #    raise Exception(f"Failed on word '{w}'")
            backward_lengths = [max(l, r) for l,r in zip(backward_lengths, bw_2)]
        count = 0
        index = len(backward_lengths) - 1
        while(index >= 0):
            if backward_lengths[index] == 0:
                return -1
            index -= backward_lengths[index]
            count += 1
        return count

18021