[THUWC 2018] 字胡串

洛谷 & 博客园

20251014 更新：修正了 Z 函数的实现；用更严谨的方法证明了关键结论；新增了关于如何在正确的复杂度下进行排序预处理的说明。

只需要使用 Z 函数的单 \(\log\) 解法，不依赖于字符集大小。

考虑固定 \(B\)，比较从 \(x, y\) 插入谁更优（\(x < y\)）。删除掉公共的前后缀可知等价于比较 \(B + A_{x + 1 \sim y}\) 和 \(A_{x + 1 \sim y} + B\) 的字典序。

有一个经典结论：比较 \(A + B\) 和 \(B + A\) 的字典序，等价于比较 \(A^{+\infty}\) 和 \(B^{+\infty}\) 的字典序。

证明：考虑用生成函数表示字符串。设 \(A + B\) 对应的生成函数为 \(F(x) = A(x) + x^{|A|} B(x)\)，\(B + A\) 对应的生成函数为 \(G(x) = B(x) + x^{|B|} A(x)\)。则：

\[\begin{aligned} F(x) - G(x) &= A(x) + x^{|A|} B(x) - B(x) - x^{|B|} A(x) \\ &= A(x) (1 - x^{|B|}) - B(x) (1 - x^{|A|}) \\ &= (1 - x^{|A|}) (1 - x^{|B|}) (\frac {A(x)} {1 - x^{|A|}} - \frac {B(x)} {1 - x^{|B|}}) \end{aligned} \]

因为 \((1 - x^{|A|}) (1 - x^{|B|})\) 的常数项等于 \(1\)，所以 \(F(x) - G(x)\) 的最低次非 \(0\) 项系数等于 \(\frac {A(x)} {1 - x^{|A|}} - \frac {B(x)} {1 - x^{|B|}}\) 的最低次非 \(0\) 项系数。所以，比较 \(A + B\) 和 \(B + A\) 对应的字典序，等价于比较 \(\frac {A(x)} {1 - x^{|A|}}\) 对应的字符串和 \(\frac {B(x)} {1 - x^{|B|}}\) 对应的字符串的字典序，即比较 \(A^{+\infty}\) 和 \(B^{+\infty}\) 的字典序。

所以，\(x\) 比 \(y\) 优当且仅当 \(B^{+\infty} \leq A_{x + 1 \sim y}^{+\infty}\)。

考虑如果对 \(B^{+\infty}\) 扫描线，则答案单调不降。考虑先把询问按照 \(B^{+\infty}\) 排序，再决策单调性分治。问题转化为求单组询问的答案。如果可以 \(\mathcal O(|A| + |B|)\) 解决单组询问，那整个问题的复杂度就是单 \(\log\)。

考虑如何高效地比较 \(B + A_{x + 1 \sim y}\) 和 \(A_{x + 1 \sim y} + B\) 的字典序。如果 \(y - x < |B|\)，那么问题比较容易解决：先比较 \(B_{1 \sim y - x}\) 和 \(A_{x + 1 \sim y}\)，预处理 \(B + \texttt{\#} + A\) 的 Z 函数后可以 \(\mathcal O(1)\) 判断；如果相等，再比较 \(B_{y - x + 1 \sim |B|}\) 和 \(B_{1 \sim |B| - (y - x)}\)，同样可以 \(\mathcal O(1)\) 判断；如果还相等，最后比较 \(A_{x + 1 \sim y} = B_{1 \sim y - x}\) 和 \(B_{|B| - (y - x) + 1 \sim |B|}\)，仍然可以 \(\mathcal O(1)\) 判断。

如果 \(y - x \geq |B|\)，设 \(A_{x + 1 \sim y} = B^k + C\)，其中 \(B\) 不是 \(C\) 的前缀，则问题等价于比较 \(B + C\) 和 \(C + B\) 的字典序，仍然可以使用 \(y - x < |B|\) 的情况的方法解决。至于如何求出 \(k\)，双指针即可。

还剩下最后一个问题：如何高效地把询问按照 \(B^{+\infty}\) 排序。这个问题的解决办法并不简单，因为比较 \(A^{+\infty}\) 和 \(B^{+\infty}\) 的字典序的复杂度是 \(\mathcal O(|A| + |B|)\)。为了方便描述复杂度，设 \(L\) 表示询问串的长度之和。有两种常用的解决办法（感谢 skip2004 的指导）：

• 严格 \(\mathcal O(L \log n)\)：因为 \(\mathcal O(|A| + |B|) = \mathcal O(\max(|A|, |B|))\)，考虑把询问串按照长度从小到大插入到平衡树中，插入一个串时需要与 \(\mathcal O(\log n)\) 个短串比较，所以复杂度是 \(\mathcal O(L \log n)\)。可以用 multiset 实现。
• 期望 \(\mathcal O(L \log n)\)：直接归并排序复杂度不对的原因是一个元素可能与多个元素进行比较，如果这个元素恰好是一个长串，那复杂度就退化成了 \(\mathcal O(Ln)\)。但是我们可以通过随机化来避免出现这种极端情况，先随机打乱再归并排序即可。可以用 stable_sort 实现。
  • 注：还有另外一种期望 \(\mathcal O(L \log n)\) 的算法，即直接快速排序，在排序过程中随机选 pivot。这样做虽然期望复杂度正确，但是复杂度方差很大，容易被卡，不建议使用。

在本题的测试数据下，期望 \(\mathcal O(L \log n)\) 的算法常数更小。下面是一份可能的代码实现：

#include <bits/stdc++.h>
using namespace std;

#define rep(i, a, b) for(int i = (a); i <= (b); ++i)
#define sz(x) (int)(x).size()
using ll = long long;

const int N = 1e6 + 10;
int n, q;
string a;
pair<string, int> qry[N];
int ans[N];

int z[2 * N];

void get_z(const string &s) {
  int l, r = 1;
  rep(i, 2, sz(s) - 1) {
    if(i <= r && z[i - l + 1] <= r - i) {
      z[i] = z[i - l + 1];
      continue;
    }
    z[i] = max(0, r - i + 1);
    while(s[z[i] + 1] == s[z[i] + i]) ++z[i];
    l = i, r = i + z[i] - 1;
  }
}

bool cmp(const string &b, int lo, int x, int y) {
  int len = sz(b) - 1;
  int t = z[sz(b) + x - lo + 1];
  if(t < min(y - x, len)) return b[t + 1] < a[x + t + 1];
  assert(y - x < len);
  t = z[y - x + 1];
  if(t < len - (y - x)) return b[y - x + t + 1] < b[t + 1];
  t = z[len - (y - x) + 1];
  if(t < y - x) return b[t + 1] < b[len - (y - x) + t + 1];
  return true;
}

void solve(int l, int r, int lo, int hi) {
  if(l > r) return;
  int mid = (l + r) >> 1;
  string b = " " + qry[mid].first;
  get_z(b + "#" + a.substr(lo + 1, hi - lo));
  int len = sz(b) - 1;
  int res = lo, j = lo;
  rep(i, lo + 1, hi) {
    if(i - j >= len && z[sz(b) - lo + j + 1] >= len) j += len;
    if(j < i && !cmp(b, lo, j, i)) res = j = i;
  }
  ans[qry[mid].second] = res;
  solve(l, mid - 1, lo, res);
  solve(mid + 1, r, res, hi);
}

mt19937_64 rng;

int main() {
  cin.tie(0)->sync_with_stdio(0);
  cin >> n >> q >> a, a = " " + a;
  rep(i, 1, q) {
    cin >> qry[i].first;
    qry[i].second = i;
  }
  shuffle(qry + 1, qry + q + 1, rng);
  stable_sort(qry + 1, qry + q + 1, [&](const auto &x, const auto &y) -> bool {
    return x.first + y.first < y.first + x.first;
  });
  solve(1, q, 0, n);
  rep(i, 1, q) cout << ans[i] << "\n";
}