Z Algorithm（扩展KMP）算法笔记

假设给定一个s长度为的n字符串。那么这个字符串的 z-function （“zet-function”）是一个长度为 的数组，其中的 -th 元素等于最大字符数，从 position i开始，i与字符串的第一个字符n重合。

换句话说，z[i]它是s字符串及其i-th 后缀的最大通用前缀。

注意：在本文中，为了避免歧义，我们将字符串视为0索引，即字符串的第一个字符具有索引0，最后一个n-1字符是。

z 函数的第一个元素通常z[0]被认为等于零。

本文描述了一种计算z函数的O (n）算法，以及该算法的各种应用。

例子

下面是针对多个计算的 z 函数的示例：

• aaaaa

z[0] = 0，
z[1] = 4，
z[2] = 3，
z[3] = 2，
z[4] = 1。

• aaabaaab

z[0] = 0，
z[1] = 2，
z[2] = 1，
z[3] = 0，
z[4] = 2，
z[5] = 1，
z[6] = 0。

• abacbaa

z[0] = 0，
z[1] = 0，
z[2] = 1，
z[3] = 0，
z[4] = 3，
z[5] = 0，
z[6] = 1。

朴素算法

以下算法基本实现时间复杂度O （n^2）：

    public static int[] zFunction(String s){
        int n=s.length();
        char[]sa=s.toCharArray();
        int[] z=new int[n];
        for(int i=1;i<n;i++){
            while(i+z[i]<n&&sa[z[i]]==sa[i+z[i]]){
                ++z[i];
            }
        }
        return z;
    }

对于每个位置i，我们只需从零开始迭代它的z[i]答案，直到我们发现不匹配或到达线的末尾。

计算 z 函数的有效算法

为了获得有效的算法，我们将逐个计算值，从i=1到，同时在计算下一个值时，我们将尝试n-1充分利用已经计算出的值z[i]。

为简洁起见s，我们将与字符串前缀匹配的子字符串称为匹配栏。例如，您要查找的z函数z[i]的值是从position开始（并将在positioni,i+z[i]-1结束）的最长匹配段。

为此，我们将保持重合最[左;r]右边段的坐标，即我们将存储在所有检测到的段的右侧结束的坐标。从某种意义上说，索引r是算法已经扫描了我们的字符串的边界，其他一切都还不知道。

然后，如果我们要计算z函数的下一个值的当前索引是i，我们有以下两个选项之一：

• i>r—换句话说，目前的情况超出了我们已经处理的情况。
  然后我们将使用一个简单的算法进行搜索z[i]，即只尝试、等的值z[i]=0。请注意，最后，如果z[i]结果是，z[i]=1那么我们将不得不更新最右边段[左;r]的坐标——因为它i+z[i]-1保证>0大r于。

• i≤r—即当前位置位于重合段[左;r]内。
  在这种情况下，我们可以使用已经计算出的z函数的先前值来初始化值，而不是用零，而是用一些可能更高的数字来初始化值z[i]。

为此，请注意子字符串s[l…r]重合s[0…r-l]。这意味着作为初始近似值，z[i]我们可以从直线中获取相应的值，即s[0…r-l]值z[i-l]。

但是，该值z[i-l]可能太大，以至于当应用于某个位置我时，它会“爬出”边界r。这是不允许的，因为我们对右边的符号一无所知，而且它们可能与所需的符号r不同。

让我们举一个这种情况的例子，使用以下行作为示例：

aaaabaa

当我们到达最后一个位置i=6时，当前最右边的行是[5:6]。考虑到此段，该位置将对应6,6-5=1于答案等于z[1]=3的位置。显然，你不能用这样的值初始化z[6]，这是完全不正确的。我们可以初始化的最大值是，因为它是1不超过[左;r]行的最大值。

因此，仅z[i]采用以下表达式作为初始近似值是安全的：

z_0[i]=min(r-i+1，z[i-l])。

使用z[i]这样的值初始化后，我们再次使用一个简单的算法，因为在边界之后，一般来说，可以找到z_0[i]线段的延续r，这是我们无法仅用z函数的先前值来预测的巧合。

因此，整个算法由两种情况组成，实际上仅在初始值上有所不同：在第一种情况下，假设它等于零，在第二种情况下，它由根据z[i]指定公式的先前值确定。之后，算法的两个分支都简化为执行一个从指定的初始值立即开始的简单算法。

事实证明，该算法非常简单。尽管他们每个人都我以一种或另一种方式执行一个微不足道的算法，但我们通过获得一种在线性时间内工作的算法取得了重大进展。为什么会这样，在我们介绍算法的实现之后，我们将在下面考虑。

实现

    public static int[] zFunction(String s){
        int n=s.length();
        char[]sa=s.toCharArray();
        int[] z=new int[n];
        int left=0,right=0;
        for(int i=1;i<n;i++){
            if (i<=right){
                z[i]=Math.min(right-i+1,z[i-left]);
            }
            while(i+z[i]<n&&sa[z[i]]==sa[i+z[i]]){
                ++z[i];
            }
            if (i+z[i]-1>right){
                left=i;
                right=i+z[i]-1;
            }
        }
        return z;
    }

数组最初填充为z为0。假设当前最右边的重合部分等于[0;0]，即一个故意的小部分，其中不会落i下

在循环中，我们首先使用上述算法来确定初始值z[i]——它要么保持为零，要么根据给定的i=1…n-1公式计算。

之后，执行一个简单的算法，试图尽可能地增加该值z[i]。

最后，如果需要[左;r]此更新，则更新匹配的当前最右边部分，即ifi+z[i]-1>r