【字符串】【P5830】 【模板】失配树

【字符串】【P5830】 【模板】失配树

Description

给定一个长度为 \(n\) 的字符串 \(S\)，有 \(m\) 次询问，每次询问给定 \(S\) 的两个前缀，求它们的最长公共 border 的长度。

最长公共 border 的含义为，对于一个字符串 \(T\)，设其 Border 集合为所有既是 \(S\) 的前缀子串又是 \(S\) 的后缀子串的集合，两个字符串的最长公共 border 为两个字符串的 Border 集合的交集中长度最长的字符串。

Limitations

\(1 \leq n \leq 10^6\)

\(1 \leq m \leq 10^5\)

Solution

注意，这篇题解不是这个模板的标准做法，也不是最简单的做法。

两个前缀的最长公共 border 即为他们在 border 树上的 LCA

因为刚起床就被 fa姐姐 拉来验题，脑袋昏昏忘记了这个结论，只能再口胡一个铁憨憨做法。

注意到所求的 border 一定既是第一个字符串的后缀，又是第二个字符串的后缀，因此一定是两个字符串的公共后缀 ，同时注意到由于这两个字符串的前缀是相同的，所以如果一个字符串 \(T\) 既是其中任意一个串的 border，又是两个串的公共后缀，那么它一定是两个串的公共 border。并且这个条件显然也是必要条件，因此我们在求出两串的 lcp 以后只需要在其中任意一个串上找到其最长的长度不超过 lcp 长度的 border，那么该串即为两串的最长公共 border。

假设我们已经求出了两串的 lcp 长度，那么问题就只剩下对一个字符串求其最长的长度不超过某数的 border。

我们考虑对每个前缀，将它向它的最长 border 连一条边，那么显然这个图有 \((n + 1)\) 个节点， \(n\) 条边，又因为这个图是联通的，根据树的判定定理，这个图是一棵树，若规定 \(0\) 是这棵树的根，数学归纳可得每个节点的父节点为该节点所代表的前缀的最长 border。因为一个节点的 border 显然比该节点的长度小，所以任何一个节点到根所在的链上，若将节点按深度从小到大排列，则其所代表的前缀长度一定是单调递增的。因此我们只需要对整棵树进行 dfs，同时用一个栈维护当前节点到根的链，然后在栈里二分即可找到所求的串。

求 border 的方法见 【P3375】KMP字符串匹配。

而求两个前缀的 lcp，可以对原串建立一个 SAM，两个前缀在 parent 树上所对应节点的 LCA 即为他们的 lcp。也可以将原串反过来，转化为求两个后缀的最长公共前缀，求出 SA 后用 height 数组解决。

但是扶苏既不愿意将原串反过来求 SA 在写个 ST，也担心毒瘤出题人卡了空间以后 SAM 建出来会爆空间，因此扶苏选择了 二分+hash 求出其 lcp。

显然公共后缀的长度满足二分性，因此只要选择一个满足前缀可减性的 hash 函数就可以 \(O(1)\) check 了。

考虑时间复杂度：二分求 lcp 的复杂度是 \(O(m \log n)\)，在 border 树上二分的复杂度是 \(O(m \log n)\)，因此总时间复杂度 \(O(n + m \log n)\)。

Code

本来扶苏写了个四模数 hash，然后被卡常了就尝试减少模数个数，最后发现单模数就可以了（雾

#include <cstdio>
#include <vector>
#include <algorithm>

const int maxh = 4;
const int maxm = 100005;
const int maxn = 1000005;

const int MOD[] = {998244353, 1000000007, 1000000009, 1145141};

int n, m, top = -1;
char S[maxn];
int border[maxn], ans[maxm], stk[maxn];
std::vector<int> son[maxn], query[maxn];

struct HASH {
  int md;
  ll hash[maxn], inv[maxn];

  ll mpow(const int a, int d, const int p) {
    ll ret = 1, tmp = a;
    while (d) {
      if (d & 1) {
        (ret *= tmp) %= p;
      }
      (tmp *= tmp) %= p;
      d >>= 1;
    }
    return ret;
  }

  void build(const int x) {
    md = x;
    ll tmp = 1, iv = mpow(100, x - 2, x);
    inv[0] = 1;
    for (int i = 1; i <= n; ++i) {
      hash[i] = (hash[i - 1] + (S[i] - 'a') * tmp) % md;
      inv[i] = inv[i - 1] * iv % md;
      (tmp *= 100) %= md;
    }
  }

  bool check(const int x, const int y, const int len) {
    ll h1 = (hash[x] - hash[x - len]) * inv[x - len] % md, h2 = (hash[y] - hash[y - len]) * inv[y - len] % md;
    if (h1 < 0) h1 += md;
    if (h2 < 0) h2 += md;
    if (h1 != h2) {
      return false;
    } else {
      return true;
    }
  }
};
HASH h[maxh];

int ReadStr(char *p);
void dfs(const int u);

int main() {
  freopen("1.in", "r", stdin);
  n = ReadStr(S);
  for (int i = 0; i < maxh; ++i) {
    h[i].build(MOD[i]);
  }
  for (int i = 2, j = 0; i <= n; ++i) {
    while (j && (S[j + 1] != S[i])) {
      j = border[j];
    }
    if (S[j + 1] == S[i]) {
      ++j;
    }
    son[border[i] = j].push_back(i);
  }
  son[0].push_back(1);
  qr(m);
  for (int p, q, Ans, i = 1; i <= m; ++i) {
    p = q = Ans = 0; qr(p); qr(q);
    for (int l = 1, r = std::min(p, q) - 1, mid = (l + r) >> 1; l <= r; mid = (l + r) >> 1) {
      bool flag = true;
      for (int i = 0; i < maxh; ++i) if ((flag = h[i].check(p, q, mid)) == false) {
        break;
      }
      if (flag) {
        l = (Ans = mid) + 1;
      } else {
        r = mid - 1;
      }
    }
    ans[i] = Ans;
    query[std::min(p, q)].push_back(i);
  }
  dfs(0);
  for (int i = 1; i <= m; ++i) {
    qw(ans[i], '\n', true);
  }
  return 0;
}

int ReadStr(char *p) {
  auto beg = p;
  do *(++p) = IPT::GetChar(); while ((*p >= 'a') && (*p <= 'z'));
  *p = 0;
  return p - beg - 1;
}

void dfs(const int u) {
  stk[++top] = u;
  for (auto v : query[u]) {
    int w = ans[v]; ans[v] = 0;
    for (int l = 1, r = top, mid = (l + r) >> 1; l <= r; mid = (l + r) >> 1) if (stk[mid] <= w) {
      ans[v] = stk[mid];
      l = mid + 1;
    } else {
      r = mid - 1;
    }
  }
  for (auto v : son[u]) {
    dfs(v);
  }
  --top;
}