字符串 学习笔记

第一章 字符串处理

存储字符串

字符数组

可以使用 char s[] 的形式存储一个字符串。比如我们需令 $s=\texttt{Hello}$，有两种定义方式：

1. char s[] = {'H', 'e', 'l', 'l', 'o', '\0'}。

2. char s[] = {"Hello"}。

注意无论是哪一种写法，字符串的最后一定都有一个特殊字符 \0，他代表着字符串的结束。所以如果你想存储一个长度为 $n$ 的字符串，请把字符数组开到 $n+1$，否则会产生数组越界。

这种 C 风格的字符串说白了就是和数组一样的，不过是存放的字符的数组。在头文件 cstring 里有一些函数可以辅助我们进行字符串的操作。

注意：不可以使用 char a[100]; a = b; 这样的形式来对一个字符串赋值。

在 C 中，有两个特殊的函数 sscanf 和 sprintf，他们相当于是以字符数组为输入、输出到字符串的 scanf 和 printf。用法如下：

sscanf(s, "%d", &n); // 从 s 中读取一个整数存储到 n
sprintf(s, "%d", n); // 把 n 输出到字符串 s 中

注意 $s$ 的下标要从 $0$ 开始。

char c;
c = getchar(); // 读取一个字符
scanf("%c", &c); // 与 getchar 一样 这两种方法都会读取到空格
cin >> c; // 这种方法不会读取到空格

char s[1000];
cin >> s; // 读取一个字符串
scanf("%s", s); // 与 cin 相同，注意没有取址符 &
gets(s); // 读取一行字符串，包括空格，但是不建议这么做，因为在 C++14 中会 CE.
int i = 0; while ((s[i] = getchar()) != '\n') ++i;// 这么做也可以读取一行字符串，推荐使用这个

String 类型

string 类型是 C++ 风格的字符串，它对 OI 选手更加友好，速度与字符数组基本持平，且不需要提前制定数组大小。但是当你需要卡常数的时候，string 类型动态分配内存的特性很可能会带来比较大的常数。

string str; // 定义一个空的字符串
string str("Hello, world"); // 定义一个 str 为 Hello, world
string str(n, 'h'); // 定义 str 为 n 个 h

注意，string 类型不以 \0 结尾。

string 类型的输出输入可以使用 cin, cout，或者可以自定义输入/输出函数。当使用 cin 函数读取字符串的时候，注意遇到空格或者换行符就会停止。string 类型的长度可以认为是任意长度的，前提是不超过计算机的内存限制。

有时，程序需要读取一行字符串（包括空格），那么可以使用 C++ 提供的 getline() 函数，可以使用 getline(cin, str) 读取一行字符串到 str 里。

string 类型可以方便的进行字符串的拼接，如 str = str1 + str2，此时 str 就为 str1 在前、str2 在后的一个字符串，注意，其中 str1 和 str2 至少有一个是 string 类型，str = "ni" + "hao" 这种写法是会编译错误的。

字符串的长度

对于 C 风格字符串，可以使用 strlen(str) 来获取字符串的长度。但是注意，这种方法的时间复杂度根据编译器的优化而定，最差为 $O(n)$。请不要在正式比赛中把你的命运交给编译器决定。

对于 C++ 风格的字符串，可以使用 str.length() 或 str.size() 来获取字符串的长度，这两种方法都是 $O(1)$。

字符串比较

字符串的比较基于字典序，字符串的字典序是指，以第 $i$ 个字符作为第 $i$ 关键字进行大小比较，空字符小于字符集内任何字符。

C 风格的字符串可以使用 strcmp(str1, str2) 函数来比较 str1, str2 两个字符串的大小关系，若 $\text{str1}=\text{str2}$，那么返回 $0$，如果 $\text{str1}<\text{str2}$ 返回负数，否则返回正数。

对于 C++ 风格的字符串，可以直接使用 > >= < <= == 等运算符进行比较，也可以使用 str1.compare(str2) 这样的方式来比较，返回值的含义与 strcmp() 函数一样。

习题

例题1 生日相同
在一个大班级中，存在两个人生日相同的概率非常大，现给出每个学生的名字，出生月日。试找出所有生日相同的学生，$1\le n\le 10^5$。

简单题，由于最多只有 $12\times 31=372$ 个日子，直接开 vector 存下每个生日对应着谁即可。

vector<string> y[13][32];
string str;
int n, mm, dd;

bool cmp(string a, string b) {
    if (a.size() == b.size()) return a < b;
    else return a.size() < b.size();
}

int main(void) {
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> str >> mm >> dd;
        y[mm][dd].push_back(str);
    }
    for (int i = 1; i <= 12; ++i) { //枚举月
        for (int j = 1; j <= 31; ++j) { //枚举日
            if (y[i][j].size() > 1) {
                sort(y[i][j].begin(), y[i][j].end(), cmp);
                cout << i << ' ' << j << ' ';
                for (string s : y[i][j])
                    cout << s << ' ';
                cout << endl;
            }
        }
    }
    return 0;
}

例题2 生日排序
给出 $n$ 个人的生日，要求按照生日大到小的顺序依次输出名称。对于生日相同的两个人，按照字典序从大到小排序。

字典序裸题，自定义一个 cmp 比较函数即可。

struct PERSON{
    int yyyy, mm, dd;
    string name;
    bool operator < (const PERSON b) const {
        if (yyyy != b.yyyy) return yyyy < b.yyyy;
        if (mm != b.mm) return mm < b.mm;
        if (dd != b.dd) return dd < b.dd;
        return name > b.name;
    }
} a[105];

int n;

int main(void) {
    cin >> n;
    for (int i = 1; i <= n; ++i)
        cin >> a[i].name >> a[i].yyyy >> a[i].mm >> a[i].dd;
    sort(a + 1, a + 1 + n);
    for (int i = 1; i <= n; ++i) 
        cout << a[i].name << endl;
    return 0;
}

第二章 哈希

本章的代码量较大，许多代码都是 @SSL_ZZL 大佬写的。在这里谢谢这位大佬。

例题1 出现次数

给定两个字符串 $x,y$，问 $x$ 在 $y$ 中出现了多少次，$1\le |x|,|y| \le 10^6$。

设 $|x|=n,|y|=m$。那么我们可以枚举 $i$，判断 $y[i\cdots (i+m-1)]$ 是否等于 $x$。可是这样的时间复杂度为 $O(nm)$，无法接受。

考虑优化，我们发现，如果能找到一个快速判断两个字符串是否相等的方法，就能将时间复杂度优化为 $O(n)$。如何优化？这里就要引入一个新算法，字符串哈希。

定义

字符串哈希的作用就是，把一个字符串映射到一个整数，并且这个整数可以被方便的表示出来。

我们定义一个函数把字符串映射到整数的函数 $f$，称之为哈希函数。具体来说，我们希望 $f$ 实现以下功能：

1. 当输入的字符串 $s$ 不同时，$f(s)$ 也互不相同。

2. 当输入的 $s$ 相同时，$f(s)$ 始终相同。

但是，由于字符串的个数远大于可以被方便表示出的整数的个数，所以我们退一步讲，希望第一条尽可能成立。当输入的 $s$ 不同、返回的 $f(s)$ 却相同的情况，我们称之为哈希碰撞。

这里估计已经有读者想到，对于任意一个只包含小写字母的字符串 $s$，其相当于一个 $26$ 进制数。于是，我们可以把这个 $26$ 进制数转换为一个 $10$ 进制数，返回这个 $10$ 进制数。

这种方法很好，也有效的从根本上杜绝了哈希碰撞的可能。但是 long long 的表示范围为 $2^{63} \approx 10^{19}$，而 $26^{14} \approx 7\times 10^{19}$，也就是说，如果使用上述方法，最大也就能表示一个长度为 $13$ 的字符串。

问题的根本在于，当 $n\ge 14$ 的时候，返回的 $f(s)$ 的值会过大。所以我们只需要 $f(s)$ 保持在一个可以接受的范围即可。对于这种需求，可以将最后的返回值 $\bmod M$，其中 $M$ 是一个大数。

也就是说，我们可以令 $f(s) = b^{n-1}s_1 + b^{n-2}s_2 + \cdots + s_n$。我们约定，令 $f_i(s) = f(s[1\cdots i])$，那么有 $f_i(s) = f_{i-1}(s) \times b + s_i$

那么，我们现在可以 $O(n)$ 的求出一个字符串的前缀 Hash，那么如何在 $O(1)$ 的时间内求出字符串的某一个字串的哈希值呢？

若我们要求出 $f(s[l\cdots l+k])$，根据上面的定义，也就是 $b^{k-1}s_l + b^{k-2}s_{l+1} + \cdots + s_{l+k}$。

观察一下这个式子，考虑如何用前缀哈希表示出来，发现有如下式子。

$$f(s[l\cdots l+k]) = f_{l+k}(s) - f_l(s) \times b^k$$

改进

发现若使用这种哈希方法，当 $M=10^9+7$，碰撞率 $\dfrac 1M$，那么当 $n=10^6$，碰撞率就高达 $\dfrac 1{1000}$。这个碰撞率显然在 OI 中是致命的。所以我们需要将碰撞率降低。我们可以另外再选择一个素数 $P$，定义一个字符串的哈希值 1 为 $f(s) \bmod M$，哈希值 2 为 $f(s) \bmod P$。这样我们成功将碰撞率降低到了 $\dfrac1{M\times P}$。

回到上面的问题。

给定两个字符串 $x,y$，问 $x$ 在 $y$ 中出现了多少次，$1\le |x|,|y| \le 10^6$。

如何解决这个问题？首先求出 $f(x)$，接下来枚举 $i$，判断 $f(y[i\cdots i+|x|])$ 是否等于 $x$ 即可。由于这里计算哈希值为 $O(1)$ 的，总时间复杂度为 $O(n+m)$。

typedef unsigned long long ull;

const int MAXN = 1e6 + 5;

ull f[MAXN], n, m, b = 256, xhash, bpow = 0;
char x[MAXN], y[MAXN];

int main(void) {
    scanf("%s %s", x + 1, y + 1);
    n = strlen(x + 1), m = strlen(y + 1);
    for (int i = 1; i <= m; ++i) // 处理出前缀哈希值
        f[i] = f[i - 1] * b + y[i]; // 由于 f 是 Unsigned long long 所以相当于自然 mod 2^64
    bpow = 1;
    for (int i = n; i >= 1; --i) 
        {xhash += x[i] * bpow; bpow *= b;}
    int ans = 0;
    for (int i = 0; i <= m - n; ++i) 
        if (xhash == f[i + n] - f[i] * bpow) 
            ++ans;
    printf("%d\n", ans);
    return 0;
}

例题2 字符串哈希

给定 $n\;(1\le n\le 10^4)$ 个字符串（第 $i$ 个字符串长度为 $m_i\;(m_i\approx 1000)$，字符串内包含数字、大小写英文字母），请求出 $n$ 个字符串中共有多少个不同的字符串。

简单题。只需要要 $O(nm)$ 计算每个字符串的哈希值，然后判断即可。

string s, hash[P + 10];
int n, ans;

bool demo(string s) {
  int sum = 0;
  for (int i = 0; i < s.size(); i++)
    sum = (sum * 123 + s[i]) % P;  //算出字符串的hash值
  int seat = 0;
  while (hash[(sum + seat) % P] != "" && hash[(sum + seat) % P] != s)  //寻找hash值的位置
    seat++;
  if (hash[(sum + seat) % P] == "") {  //没有出现过，将hash值放进hash表里
    hash[(sum + seat) % P] = s;
    return 1;
  }
  return 0;
}

int main(void) {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    cin >> s;
    if (demo(s))
      ans++;
  }
  printf("%d", ans);
}

例题3 回文子串

给定一个长度为 $n\;(n\le 10^6)$ 的字符串 $s$，求他的最长回文子串的长度是多少。有多组数据，$T\le 30$。

思考：如何判断一个字符串是否为一个回文串？设字符串 $s$ 的中心为 $k$，长度为 $n$，那么当且仅当 $f(s[1\cdots k])=f(s[k\cdots n])$ 的时候，$s$ 为一个回文串。

考虑枚举中点 $p$，在 $p$ 确定的情况下，我们想知道，使得 $s[p-k \cdots p] = s[p\cdots p+k]$ 的 $k$ 最大是多少。

自然可以暴力枚举一个 $k$。可是这样的做法是 $O(n^2)$，会超时。考虑能不能将这个寻找 $k$ 的过程压缩到 $O(n)$ 以下。

观察一下，发现 $k$ 具有单调性：即若 $k_1\le k_2$，而 $s[p-k_1 \cdots p] \ne s[p\cdots p+k_1]$，那么 $k_2$ 也肯定不能使 $s[p-k_2 \cdots p] = s[p\cdots p+k_2]$。

所以我们可以二分 $k$，将寻找 $k$ 的时间复杂度降到 $O(\log n)$。

总时间复杂度：$O(n\log n)$。

typedef unsigned long long ull;

ull p = 131;
ull a[1000010], base[1000010], b[1000010];
int n, ans, cnt;
string s;

bool check()
{
    if (s[0] == 'E' && s[1] == 'N' && s[2] == 'D')
        return 1;
    return 0;
}

void hash()
{
    memset(base, 0, sizeof(base));
    memset(a, 0, sizeof(a));
    memset(b, 0, sizeof(b));
    base[0] = 1ull;
    for (int i = 0; i < n; i++)
    {
        base[i + 1] = base[i] * p;
        a[i + 1] = a[i] * p + (s[i] - 'a'); //正序字符串哈希
    }
    for (int i = n - 1; i >= 0; i--)
        b[i + 1] = b[i + 2] * p + (s[i] - 'a'); //倒序字符串哈希
}

void work()
{
    for (int i = 1; i <= n; i++)
    { //找中心
        int mid = 0, l = 0, r = n;
        while (l <= r)
        { //长度奇数
            mid = (l + r) >> 1;
            if (i - mid < 1 || i + mid > n)
            {
                r = mid - 1;
                continue;
            }
            if (a[i] - a[i - mid - 1] * base[mid + 1] == b[i] - b[i + mid + 1] * base[mid + 1])
            {
                ans = max(ans, mid * 2 + 1);
                l = mid + 1;
            }
            else
                r = mid - 1;
        }
        mid = 0, l = 0, r = n;
        while (l <= r)
        { //长度偶数
            mid = (l + r) >> 1;
            if (i - mid + 1 < 1 || i + mid > n)
            {
                r = mid - 1;
                continue;
            }
            if (a[i] - a[i - mid] * base[mid] == b[i + 1] - b[i + mid + 1] * base[mid])
            {
                ans = max(ans, mid * 2);
                l = mid + 1;
            }
            else
                r = mid - 1;
        }
    }
}
int main()
{
    cin >> s;
    n = s.size();
    while (!check())
    {
        cnt++;
        ans = 1;
        hash();
        work();
        printf("Case %d: %d\n", cnt, ans);
        cin >> s;
        n = s.size();
    }
}

例题4 对称正方形

给定一个 $n\;(n \le 10^3)$ 行 $m\;(m\le 10^3)$ 列的矩阵。求矩阵中上下对称且左右对称的正方形子矩阵的个数。

二维哈希。不过多解释，因为算法部分与基本一致。直接上代码。

typedef unsigned long long ull;

ull p1 = 131, p2 = 313;
ull g[1010][1010], xturn[1010][1010], yturn[1010][1010];
int ans, n, m, a[1010][1010];

struct c {
    ull x, y;
} base[1010];

void yu() {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) xturn[n - i + 1][j] = yturn[i][m - j + 1] = a[i][j];
    }
}

void hash()  //二维Hash
{
    base[0].x = 1, base[0].y = 1;
    for (int i = 1; i <= max(n, m); i++) {
        base[i].x = base[i - 1].x * p1;
        base[i].y = base[i - 1].y * p2;
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            a[i][j] += a[i - 1][j] * p1;
            xturn[i][j] += xturn[i - 1][j] * p1;
            yturn[i][j] += yturn[i - 1][j] * p1;
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            a[i][j] += a[i][j - 1] * p2;
            xturn[i][j] += xturn[i][j - 1] * p2;
            yturn[i][j] += yturn[i][j - 1] * p2;
        }
    }
}

bool check(int x, int y, int len) {
    int v1, v2, v3, y1, x1;
    if (x < len || x > n || y < len || y > m)
        return 0;
    v1 = a[x][y] - a[x - len][y] * base[len].x - a[x][y - len] * base[len].y +
         a[x - len][y - len] * base[len].y * base[len].x;
    x1 = n - (x - len);  //上下翻转
    v2 = xturn[x1][y] - xturn[x1 - len][y] * base[len].x - xturn[x1][y - len] * base[len].y +
         xturn[x1 - len][y - len] * base[len].y * base[len].x;
    y1 = m - (y - len);  //左右翻转
    v3 = yturn[x][y1] - yturn[x - len][y1] * base[len].x - yturn[x][y1 - len] * base[len].y +
         yturn[x - len][y1 - len] * base[len].y * base[len].x;
    if (v1 == v2 && v2 == v3)
        return 1;
    else
        return 0;
}
void work() {
    int t = 0, l = 0, r = max(n, m) + 1, mid = 0, x, y;
    //长度为奇数
    for (int i = 1; i < n; i++) {  //枚举中心点
        for (int j = 1; j < m; j++) {
            t = 0, l = 0, r = max(n, m) + 1, mid = 0;
            while (l < r) {  //二分边长
                mid = (l + r + 1) >> 1;
                x = mid + i, y = mid + j;  //右下角
                if (check(x, y, mid * 2)) {
                    t = mid;
                    l = mid;
                } else
                    r = mid - 1;
            }
            ans += t;
        }
    }
    //长度为奇数
    for (int i = 1; i <= n; i++) {  //枚举中心点
        for (int j = 1; j <= m; j++) {
            t = 0, l = 0, r = max(n, m) + 1, mid = 0;
            while (l < r) {
                mid = (l + r + 1) >> 1;    //二分边长
                x = mid + i, y = mid + j;  //右下角
                if (check(x, y, mid * 2 + 1)) {
                    t = mid;
                    l = mid;
                } else
                    r = mid - 1;
            }
            ans += t;
        }
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
    yu();
    hash();
    work();
    ans += m * n;
    printf("%d", ans);
}

例题5 单词背诵

灵梦有 $n\;(n\le 10^3)$ 个单词想要背，文章由 $m\;(m\le 10^5)$ 个单词构成，她想在文章中找出连续的一段，其中包含最多的她想要背的单词（重复的只算一个）。在背诵的单词量尽量多的情况下，使选出的文章段落尽量短。
你需要求出 文章中最多包含的要背的单词数 与 文章中包含最多要背单词的最短的连续段的长度。

首先第一个问题很好解决，直接排序后二分查找每个想背的单词是否出现即可。

第二个问题需要用到双指针 (two-pointers) 法。对于一个首先令 $l=r=1$，然后让 $r$ 逐步向右扩大。每次当 $l\cdots r$ 之间包含了所有单词的时候，并让 $l$ 逐步往右扩大，直到 $l\cdots r$ 之间不再包含所有单词时，记录下移动前的 $r-l+1$ 的值。最后取 $r-l+1$ 的最小值即可。

struct DT {
    int num;
    ull s;
} hash[1010];
int n, m, ans1, wdn, ans2, r, atcp[100010], v[1010];
string con, atc;
ull atcs;

bool cmp(const DT& k, const DT& l) { return k.s < l.s; };

int find(ull s) {  //二分查找单词编号
    int l = 1, r = n, mid;
    while (l <= r) {
        mid = (l + r) / 2;
        if (hash[mid].s < s)
            l = mid + 1;
        else if (hash[mid].s > s)
            r = mid - 1;
        else
            return hash[mid].num;
    }
    return -1;
}

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        cin >> con;
        hash[i].num = i;  //每个单词的标号
        for (int j = 0; j < con.size(); j++) hash[i].s = hash[i].s * 131ull + (con[j] - 'a' + 1);  // hash处理
    }
    sort(hash + 1, hash + 1 + n, cmp);  //以hash值排序
    scanf("%d", &m);
    for (int i = 1; i <= m; i++) {
        cin >> atc;
        atcs = 0;
        for (int j = 0; j < atc.size(); j++) atcs = atcs * 131ull + (atc[j] - 'a' + 1);
        int pit = find(atcs);  // pit就是当前文章中的单词是背诵单词中的哪一个编号
        if (pit > 0) {         //当前单词需背诵
            if (!v[pit])
                ans1++;
            ++v[pit];
        }
        atcp[i] = pit;  //记录编号
    }
    memset(v, 0, sizeof(v));  //记录单词在l~r中出现次数
    r = 1, ans2 = 2147483647;
    for (int l = 1; l <= m; l++) {      //枚举左边界
        while (wdn < ans1 && r <= m) {  //直到找到所有要背的单词 或 r出界了
            if (atcp[r] >= 0) {         //有编号（单词需背）
                if (v[atcp[r]] == 0)
                    wdn++;     //第一次出现记录答案
                ++v[atcp[r]];  //当前单词出现次数累计
            }
            r++;
        }
        if (wdn == ans1)              //找到了所有要背的单词
            ans2 = min(ans2, r - l);  //取最短的长度
        if (atcp[l] >= 0) {  //对l位置上的单词做处理，r就不需要重新从l开始更新了
            --v[atcp[l]];    // l位置上的单词 的出现次数-1
            if (!v[atcp[l]])
                wdn--;
            //如果这个位置上的单词是l~r中只出现过一次，那么l向右枚举时，l~r中将没有这个词，答案-1
        }
    }
    printf("%d\n%d", ans1, ans2);
}

习题

习题1 子正方形
给出两个 $n\times n\;(1\le n\le 50)$ 的正整数矩阵，求这两个矩阵的最大公共子正方形矩阵的边长。

习题2 特殊数列
有一个数列 $a$，$a_0=1$，$a_{i+1}=(A\times a_i + a_i \bmod B) \bmod C\;(-10^9\le A,B,C \le 10^9)$，要求这个数列第一次出现重复的项的标号。

习题3 求好元素
如果在一个由 $n (1\le n\le 5000)$ 个整数组成的数列 $a$ 中，存在 $a_m+a_n+a_p=a_i\;(1\le n,m,p < i)$（$n,m,p$ 可以相同）的话，$a_i$ 就是一个“好元素”。问“好元素”的个数。

习题4 上课点名
一个老师喜欢上课前先点名，小明发现自己被点到了两次，于是小明开始质疑老师的点名是否有重复或误报为其他班同学。当然小明可不想一个个比较，所以他把这个任务交给了你，小明会提供班上人数 $n\;(1\le n\le 10^4)$ 和他们的名字，同时小明也会记下老师报的名字与他们的个数 $m\;(1\le m\le 5\times 10^5)$。

习题5 最大分离度
对于任意两人，他们的分离度是联系两个人需要经过的最小的关系数。对于一个关系网络，最大分离度是网络中任意两个的分离度的最大值。如果一个网络有两个人没有通过关系链连接起来，这个网络是不连通的。请你判断一个网络是否联通。
数据范围：人数 $P\le 50$，关系数 $R\le P^2$。

习题6 回文分区
给出一个只包含小写字母字符串 $s$，长度为 $n\;(1\le n\le 10^6)$，要求你将它划分成尽可能多的小块，使得这些小块构成回文串。多组数据，数据数 $T\le 10$。

第三章 字符串匹配 (KMP Algorithm)

由于网络上相同内容很多，本章的内容可以前往 OI-Wiki 上查看。

第四章 字典树

定义

字典树 Trie 是一个可以很方便的处理字符串问题的数据结构。将若干个字符串建成一颗字典树，其中的每个节点代表从根走到当前位置的一个字符子串。

如图，这就是一棵字典树，其中这条 $1\to 2 \to 5$ 的路径表示了一个字符串 $\text{aa}$，而路径 $1\to 4\to 8\to 12\to 15$ 这条路径表示了字符串 $\text{caaa}$。

trie 的结构非常好懂，我们用 $\delta(u,c)$ 表示结点 $u$ 的 $c$ 字符指向的下一个结点，或着说是结点 $u$ 代表的字符串后面添加一个字符 $c$ 形成的字符串的结点。（$c$ 的取值范围和字符集大小有关，不一定是 $0\sim 26$。）

有时需要标记插入进 trie 的是哪些字符串，每次插入完成时在这个字符串所代表的节点处打上标记即可。

字典树的实现非常简单，如下，就是一个封装好的字典树。

// C++ Version
struct trie {
    int nex[100000][26], cnt;
    bool exist[100000]; // 该结点结尾的字符串是否存在

    void insert(char *s, int l) { // 插入字符串
        int p = 0;
        for (int i = 0; i < l; i++) {
            int c = s[i] - 'a';
            if (!nex[p][c])
                nex[p][c] = ++cnt; // 如果没有，就添加结点
            p = nex[p][c];
        }
        exist[p] = 1;
    }
    bool find(char *s, int l) { // 查找字符串
        int p = 0;
        for (int i = 0; i < l; i++) {
            int c = s[i] - 'a';
            if (!nex[p][c])
                return 0;
            p = nex[p][c];
        }
        return exist[p];
    }
};

例题1 前缀统计

给定 $n(n\le 10^6)$ 个字符串 $s_1,s_2,\cdots,s_n$，接下来进行 $m$ 次询问，每次询问给定一个字符串 $t$，求 $s_1\sim s_n$ 中有多少个字符串是 $t$ 的前缀。

这个题目似乎是字典树的模板题，我们只需要先将这 $n$ 个字符串插入字典树，然后对于每一个 $t$，查询路径上有多少个结束标记即可。

#include <cstdio>
#include <cstring>
using namespace std;

const int MAXN = 1e6 + 5, MAXL = 26;

struct Trie {
    int nex[MAXN][MAXL], cnt, exist[MAXN];
    
    void insert(char *s, int len) {
        int p = 0;
        for (int i = 0; i < len; ++i) {
            int q = s[i] - 'a';
            if (nex[p][q] == 0) nex[p][q] = ++cnt;
            p = nex[p][q];
        }
        exist[p]++;
    }
    int query(char *t, int len) {
        int p = 0, ret = 0;
        for (int i = 0; i < len; ++i) {
            int q = t[i] - 'a';
            if (nex[p][q] == 0) break;
            p = nex[p][q];
            ret += exist[p];
        }
        return ret; // t 为某个 s 的前缀，注意有可能 s = t
    }
} T;

char s[MAXN], t[MAXN];

int main(void) {
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) {
        scanf("%s", s);
        T.insert(s, strlen(s));
    }
    while (m--) {
        scanf("%s", t);
        printf("%d\n", T.query(t, strlen(t)));
    }
    return 0;
}

例题2 最大异或对

给定的 $n(n\le 10^5)$ 个整数 $a_1,a_2,\cdots,a_n(a_i< 2^{31})$，选出两个数进行 xor（异或）运算，求得到的结果的最大值。

本题需要学习字典树的一种特殊形式，01Trie。为什么说这是一种特殊的字典树？因为 01Trie 是一棵储存 0/1 字符串的字典树。

那他与本题有什么关系？我们知道，高位的数字大的数字越大，而不用考虑低位上的数字的大小。也就是说，我们有一种贪心策略，即优先使高位异或后的结果为 $1$。

如上面这棵字典树，就是我们插入了三个 0/1 串（$00,10,11$）的结果。如果此时我们要查询这三个串中与 $01$ 异或最大的值，我们可以这样做。

首先令指针 $p=1$，发现 $01$ 的第一位为 $0$，也就是我们第一位要尽量往 $1$ 走。我们发现节点 $1$ 有这条 $1$ 边，所以令 $p=2$。同理，接下来应该往 $0$ 走，所以令 $p=5$。

那么本题的做法显然，首先将 $n$ 个字符串插入 01Trie 中，接下来对于每个字符串 $s$，我们查找一个尽量大的异或值，最后取最大值即可。

注意在本题中，有可能这些 01 字符串的长度不一样，我们只需要高位补 0 即可，如上。

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;

const int MAXN = 1e7 + 5, MAXL = 4;

struct Trie {
    int nex[MAXN][MAXL], cnt, exist[MAXN];
    
    void insert(int x) {
        int p = 0;
        for (int i = 30; i >= 0; --i) { //题目保证了x<2^31，所以可以直接强制把所有字符串都补到30位
            int q = (x >> i) & 1; //取出x的第i位
            if (nex[p][q] == 0) nex[p][q] = ++cnt;
            p = nex[p][q];
        }
    }
    int query(int x) {
        int p = 0, ret = 0;
        for (int i = 30; i >= 0; --i) {
            int q = (x >> i) & 1;
            if (nex[p][!q]) {
                ret += (1 << i);
                q = !q;
            }
            p = nex[p][q];
        }
        return ret;
    }
} T;

int n, a[MAXN];

int main(void) {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &a[i]);
        T.insert(a[i]);
    }
    int ans = 0;
    for (int i = 1; i <= n; ++i) {
        ans = max(ans, T.query(a[i]));
    }
    printf("%d", ans);
    return 0;
}

例题3 最长异或路径

给定 $n(n\le 10^5)$ 个节点的树，每个节点有一个权值 $w(w<2^{31})$，求出一条路径，使得在这条路径上的所有点的权值异或最大。

本题和上一题有点相像。本题需要使用到树上差分的思想。那么，树上差分的思想是什么呢？我们知道，异或有个奇妙的性质，即 $a \oplus a = 0, a \oplus 0 = a$，这意味着，异或具有反运算，且异或的反运算为他自己。

知道了这个性质，我们就可以做出这道题目了，我们设 $f(x,y)$ 表示 $x\to y$ 路径上的异或值，那么显然有 $f(x,y)=f(x,\operatorname{LCA}(x,y)) \oplus f(\operatorname{LCA}(x,y),y)$。

那么，我们需要 $\Theta(\log n)$计算 $\operatorname{LCA}$吗？显然不用。因为我们提到了异或的另一个性质，也就异或的自反性。我们其实不需要知道 $\operatorname{LCA}(x,y)$ 到底等于多少，因为设 $\operatorname{LCA}(x,y)=p,\text{root}=r$，有如下公式。

$$f(x,y)=f(x,p)\oplus f(p,y)=f(x,r)\oplus f(r,y)$$

也就是说，我们只需要 $\forall 1\le i\le n, f(i,r)$ 即可，设 $f(i,r)=d_i$，那么我们只需要找到两个 $i,j$ 使得 $d_i\oplus d_j$ 最大即可，这就回到了上面的问题，可以使用上面的方法解决。

#include <iostream>
#include <cstdio>
#include <iomanip>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;

int n, k, s[3200010], trie[3200010][2], h[200010], tot = 1, u, v, w, ans;

struct c {
    int x, next, w;
} a[200010];

void add(int x, int y, int w) {
    k++;
    a[k].x = y;
    a[k].next = h[x];
    a[k].w = w;
    h[x] = k;
}

void dfs(int x, int fa) { //求出所有的s[i]
    int v;
    for (int i = h[x]; i; i = a[i].next) {
        v = a[i].x;
        if (v == fa) continue;
        s[v] = s[x] ^ a[i].w;
        dfs(v, x);
    }
}

int get(int x) {
    int p = 1, ans = 0, c;
    for (int i = 31; i >= 0; i--) {
        if (((x >> i) & 1) == 1) c = 0;
        else c = 1;
        if (trie[p][c]) ans += (1 << i);
        else c = (x >> i) & 1;
        p = trie[p][c];
    }
    return ans;
}

void insert(int x) {
    int p = 1, c;
    for (int i = 31; i >= 0; i--) {
        c = (x >> i) & 1;
        if (!trie[p][c]) trie[p][c] = ++tot;
        p = trie[p][c];
    }
}

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n - 1; i++) {
        scanf("%d%d%d", &u, &v, &w);
        add(u, v, w);
        add(v, u, w);
    }
    dfs(1, 0);
    //后面的就跟上一题（最大异或对）一样了
    for (int i = 1; i <= n; i++) insert(s[i]);
    for (int i = 1; i <= n; i++) ans = max(ans, get(s[i]));
    printf("%d", ans);
}

例题4 阅读理解

有 $n(1\le 10^3)$ 篇阅读理解，每篇有许多生词，指定一个生词 $s$，询问 $s$ 在哪些阅读理解里出现。

对于每一个生词 $s$，往包含他的阅读理解建条边。

查询的时候直接输出即可。

#include <iostream>
#include <map>
#include <vector>

using namespace std;

map<string, vector<int>> a;
int n, m, l;
string s;

int main(void) {
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> l;
        for (int j = 1; j <= l; ++j) {
            cin >> s;
            if (a[s].size() == 0 || a[s][a[s].size() - 1] != i)
                a[s].push_back(i);
        }
    }
    cin >> m;
    for (int i = 1; i <= m; ++i) {
        cin >> s;
        for (auto x : a[s]) {
            cout << x << ' ';
        }
        cout << endl;
    }
    return 0;
}

例题5 单词拼接

给定由一些单词组成的词典，单词数 $\le 5\times 10^3$。一个单词是特殊的，当且仅当它能由词典里的两个单词拼接而成。求词典里特殊的单词数。

我们知道，若一个字符串 $a$ 为特殊的字符串，那么我们必定能找到两个字符串 $s,t$，$s$ 为 $a$ 的前缀且 $t$ 为 $a$ 的后缀，并且 $|s|+|t| = |a|$。

我们发现，若设 $\operatorname{rev}(a) = r$，那么 $t$ 为 $a$ 的后缀也就相当于是 $r$ 的前缀。

这样，我们就将原先的判定操作转换成了两个前缀的判定操作，而我们知道，字典树可以很方便的进行这个操作，所以我们可以使用字典树来优化这个操作。

时间复杂度 $\Theta(n^2 \operatorname{strlen}(s))$

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int INF = 0x3f3f3f3f, N = 50010;
int n, tot = 1;
char s[N][33];
int trie[N << 5][30], ans, ed[N << 5];
void insert(int id) {
    int p = 1, len = strlen(s[id] + 1);
    for (int i = 1; i <= len; i++) {
        int ch = s[id][i] - 'a';
        if (!trie[p][ch])
            trie[p][ch] = ++tot;
        p = trie[p][ch];
    }
    ed[p]++;
}
int find(int id, int l, int r) {
    int p = 1;
    for (int i = l; i <= r; i++) {
        int ch = s[id][i] - 'a';
        if (!trie[p][ch])
            return 0;
        p = trie[p][ch];
    }
    return ed[p];
}
int main() {
    int now = 1;
    while (scanf("%s", s[now] + 1) != EOF) {
        insert(now);
        now++;
    }
    for (int i = 1; i <= now - 1; i++) {
        int len = strlen(s[i] + 1);
        for (int k = 1; k < len; k++)
            if (find(i, 1, k) && find(i, k + 1, len)) {
                printf("%s\n", s[i] + 1);
                break;
            }
    }
    return 0;
}

例题6 最短前缀

有 $n(n\le 10^3)$ 个单词，保证互不相同，对于每个单词 $s$ 寻找 $s$ 的一个前缀 $p$ 使得 $p$ 在这 $n$ 个单词中仅为 $s$ 的前缀。

这个题目也是比较简单的题目，建出这 $n$ 个单词的字典树，对于每个单词 $s$ 遍历一遍这个字典树，若发现从当前节点往下没有任何分支了，那么说明到现在的字符串肯定为一个独一无二的前缀了。

如上面这个字典树，若我们想找到 $\text{cat}$ 的最长独立前缀，我们从 $0$ 节点开始遍历：

1. 进入 $1$ 节点，$\text{ans = c}$；
2. 发现 $1$ 节点儿子数大于 $1$，$\text{ans = ca}$；
3. 进入 $3$ 节点。
4. 发现节点 $3$ 儿子数大于 $1$，$\text{ans = cat}$；
5. 进入节点 $5$。
6. 发现节点 $5$ 为叶子节点，$\text{ans = cat}$。

#define mod 1000000007
#define eps 1e-6
#define ll long long
#define INF 0x3f3f3f3f
#define ME0(x) memset(x, 0, sizeof(x))
using namespace std;
string s[1005];
int main() {
    int n = 0;
    while (cin >> s[++n]);
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= s[i].size(); ++j) {
            string ss = s[i].substr(0, j);
            int flag = 1;
            for (int k = 1; k <= n; ++k) {
                if (k != i && s[k].substr(0, j) == ss) {
                    flag = 0;
                    break;
                }
            }
            if (flag || j == s[i].size()) {
                cout << s[i] << " " << ss << endl;
                break;
            }
        }
    }
}

例题7 lowbit 求和

给定长度为 $n(n\le 10^5)$ 的序列 $a(a_i\le 2^{60}-1)$，求 $\sum^n_{i=1}\sum^n_{j=1}\operatorname{lowbit}(a_i~\operatorname{xor}a_j)$。

我们知道，$\operatorname{lowbit}(x)$ 表示 $x$ 的最后一位 $1$ 所对应的值。建一棵 01Trie 即可。

#include <iostream>
#include <cstdio>

using namespace std;

unsigned long long mod = 199907210507;
long long n, tot = 1ll;
long long a[6010101];
long long trie[6010101][2], b[60101010];

void add(long long x) {
    long long now = 1;
    for (int i = 0; i <= 61ll; i++) {
        int j = (x >> i) & 1ll;
        if (!trie[now][j])
            trie[now][j] = ++tot;
        now = trie[now][j];
        b[now]++;
    }
}

unsigned long long query(long long x) {
    unsigned long long sum = 0;
    long long now = 1;
    for (int i = 0; i <= 61; i++) {
        int j = (x >> i) & 1;
        if (trie[now][j ^ 1])
            sum = (sum + b[trie[now][j ^ 1]] % mod * (1ll << i) % mod) % mod;
        now = trie[now][j];
    }
    return sum;
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        add(a[i]);
    }
    unsigned long long ans = 0;
    for (int i = 1; i <= n; i++) ans = (ans + query(a[i])) % mod;
    cout << ans;
    return 0;
}