经典算法：Z算法（z algorithm）

• 经典算法：Z算法（z algorithm）
  • 1. 算法简介
  • 2. 算法原理
  • 3. 代码实现
  • 4. 推广应用
  • 5. 参考链接

1. 算法简介

Z algorithm是我今天做leetcode的时候偶然得知的一个用于字符串匹配的经典算法，我说怎么一个我几乎毫无解题思路的题目别人人均2分钟搞定，也是把我惊到了……

Anyway，能学到点东西倒也确实是个好事，至少以后知道这个套路了，LOL……

Z algorithm具体来说是用来求解字符串前序匹配的，具体而言，对于一个长度为n的输入字符串s，z algorithm返回一个长度为n的数组，其中对于每一个元素z[i]，对应的含义就是子串s[i:]于s的最长公共前缀序列prefix的长度。

Leetcode第2223题（2223. Sum of Scores of Built Strings）就是上述算法的一个典型应用。

实现这个功能，最为直接的方法就是一个二次循环进行匹配，不过这样的话显然算法复杂度是非常高的，但是Z algorithm的巧妙之处就在于其可以在$O(N)$的算法复杂度范围内对上述功能进行实现。

2. 算法原理

z算法的核心算法原理就是尽可能地重用之前已经匹配过的结果。

具体实现而言，我们维护一个滑动窗口$[L,R]$，这个滑动窗口表示当前最接近的且已经匹配过的与开头的前缀字符串最长的匹配字符。即：

• S[L:R+1] == S[:R-L+1]
• S[L:R+2] != S[:R-L+2]

然后，我们来考察每一个位置i上面的z[i]的值：

1. 如果i>R，那么我们之前从来没有匹配过从第i个位置开始的字符串，那么，我们将L更新为i，然后逐一对R进行考察，找到最长的子串S[L:R+1]使得S[L:R+1] == S[:R-L+1]，此时z[i] = R-L+1;
2. 如果i<=R，那么我们一定在之前已经在窗口中见过了S[i]，一定有S[i] == S[i-L]，定义k=i-L，那么我们同样可以进行分类讨论：
   1. 如果z[k] < R-i+1，那么i+z[k] <= R，说明S[i:i+z[k]+1]同样已经之前在窗口中已经匹配过了，是从S[k]开始匹配的最长的前缀子串，即S[i:i+z[k]+1] == S[k:k+z[k]+1] == S[:z[k]+1]，因此我们可以直接复用之前的结果，即z[i] = z[k]，而滑动窗口无需进行变动；
   2. 如果z[k] >= R-i+1，那么i+z[k] > R，说明S[i:R+1] == S[k:k+R-i+1] == S[:R-i+1]，那么我们可以更新滑动窗口的左侧边界L=i，然后继续对右侧窗口进行匹配，直到找到新的右侧窗口匹配边界R'。

综上，我们即可得到除了第一个字符之外的所有的位置上的z[i]的值，而对于第一个位置上的z[0]，显然这个值就是字符串的长度n。

由此，全命题解毕。

另外，关于上述算法的算法复杂度，由于这里的滑动窗口的有边界R的移动是单向的，因此，整体的算法复杂度一定是$O(N)$的。

3. 代码实现

我们根据上述原理分析就可以快速地给出一个Z algorithm的python代码实现如下：

def z_algorithm(s):
    n = len(s)
    z = [0 for _ in range(n)]
    l, r = -1, -1
    for i in range(1, n):
        if i > r:
            l, r = i, i
            while r < n and s[r-l] == s[r]:
                r += 1
            z[i] = r-l
            r -= 1
        else:
            k = i - l
            if z[k] < r - i + 1:
                z[i] = z[k]
            else:
                l = i
                while r < n and s[r-l] == s[r]:
                    r += 1
                z[i] = r-l
                r -= 1
    z[0] = n
    return z

4. 推广应用

z algorithm的另一个常见的应用就是用于字符串匹配。

典型的问题就是：

给出一个待匹配字符串s和一个模式字符串pattern，问字符串s当中是否存在pattern以及存在多少pattern的个数。

最trivial的方法同样可以使用一个二重循环，不过算法复杂度就是$O(nm)$。

不过，借用Z algorithm的思路，我们可以将其算法复杂度压缩到$O(n+m)$，具体来说，我们只需要将pattern拼接到待匹配字符串s之前，然后求一下z算法之后移除掉前方的pattern，然后看一下剩下的z值当中是否有长度不小于m的存在即可。

给出python代码实现如下：

def have_pattern(s, pattern):
    t = pattern + s
    z = z_algorithm(t)
    z = z[len(pattern):]

    return any(x >= len(pattern) for x in z)

5. 参考链接

1. https://www.geeksforgeeks.org/z-algorithm-linear-time-pattern-searching-algorithm/
2. https://www.hackerearth.com/practice/algorithms/string-algorithm/z-algorithm/tutorial/