第十五周总结（字符串）

字符串哈希

把字符串转化成一个数字（相当于k进制转化）
为了省事和降低冲突率可以用unsigned long long类型，使其自然溢出（模2⁶⁴），就无需担心出现负值问题了。其次，为了最大限度地降低冲突率且对复杂度不造成太大影响，可以采用双哈希，即用两种进制打两个哈希表，如果有一个表中出现了不符合的情况，那么这两个区间肯定不同，可以进一步降低冲突率。
这里给出单哈希表的模板

//单哈希表
typedef unsigned long long ull;
const ull base = 131;
ull hs[maxn];
ull p[maxn];
void hash_init(char s[])
{
    p[0] = 1;
    int len = strlen(s);
    for (int i = 1; i <= len; i++)
    {
        hs[i] = hs[i - 1] * base + s[i] - 'a' + 1;
        p[i] = p[i - 1] * base;
    }
}
inline int get(int l, int r)
{
    return hs[r] - hs[l - 1] * p[r - l + 1];
}

字符串哈希模板题

//P3370AC代码
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
const ull base = 131;
ull gethash(char s[])
{
    int len = strlen(s);
    ull res = 0;
    for (int i = 0; i < len; i++)
        res = res * base + s[i];
    return res;
}

int main()
{
    int n, cnt = 1;
    ull record[10005];
    char s[1505];
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        scanf("%s", s);
        record[i] = gethash(s);
    }
    sort(record, record + n);
    for (int i = 1; i < n; i++)
        if (record[i] != record[i - 1]) cnt++;
    printf("%d", cnt);
    return 0;
}

KMP算法

看毛片算法

给定一个长度为m的字符串s1和一个长度为n的子串s2，在O(m+n)的复杂度下找到s2在s1中出现的位置。
主要思想是去除冗余的比较。游标i在s1上移动，游标j在s2上移动，当比较失败时无需移动i，只需移动j到合适的位置即可（这个合适的位置需要对s2进行预处理）。
下面是我之前写过介绍KMP算法的博客，直接在这里引用了。
KMP算法中对P数组的预处理（或称next数组）+ 简单介绍
事实上按照KMP算法的思想，next数组应该叫pre数组更好，因为保存的是上一个相同的字符位置，不过next数组似乎已经成了一种约定，为了便于阅读，这里也都用next数组。

Manacher（马拉车算法）

用于线性找一个字符串中最长回文串的长度
马拉车算法有一个巧妙的点，可以将奇数长度和偶数长度的子串一起处理，做法就是在首位和每个字符间插入一个在该字符串中未出现过的字符。
比如abcd处理后就是#a#b#c#d#
这个算法的思想就是利用之前求出来的长度和回文串的对称性质。

下面来讲一讲这个算法的具体实现：
从左往右计算以每个字符为中心的回文串长度len[]，并且记录回文串右端到达的最远处P。注意不是长度，是最右端位置。
假设当前到了位置为i的字符：

1. 如果i<=P，那么将i关于P对应的那个中心点po对称过去得到j，如果那么len[i]>=min(len[j],P-i+1) 因为len[j]的左侧关于中心点po对称后可能会超过P，所以要取二者中较小的。
2. 如果i>P，那么就只能老老实实算了，一边算一边更新P的值
   
   借用一张另一个博主的图片，这里放上链接
   另一个博主关于马拉车算法的介绍

char s[maxn];
int length, len[maxn], P, Po; // len[i]保存的是从i到回文右端的长度（i也算在内）
void input() //读入字符串同时预处理
{
    char c;
    s[0] = '~';
    s[1] = '#';
    length = 1;
    while ((c = getchar()) != '\n')
    {
        s[++length] = c;
        s[++length] = '#';
    }
    s[length + 1] = '\0';
}

int manacher()
{
    int res = 0;
    P = 0;
    for (int i = 1; i <= length; i++)
    {
        if (i < P) //如果i在P的左侧，先更新len[i]
        {
            int j = 2 * Po - i;
            len[i] = min(len[j], P - i + 1);
        }
        while (s[len[i] + i] == s[i - len[i]]) //由于进行了预处理，无需担心越界问题
            ++len[i];
        if (len[i] + i - 1 > P) //更新P的位置
        {
            P = len[i] + i - 1;
            Po = i;
        }
        if (len[i] > res) res = len[i];
    }
    return res - 1; //将res-1就是原来串中回文串的长度
}

Trie树

用一张图来解释，可以用来查找一个字符是否是另一个字符的前缀。

数据量比较大的时候建议用静态树，动态申请空间容易超时，比如下面这道例题。
POJ3630

AC代码

#include <cstdio>
#include <cstring>
#define N 100005
#define mem(a, v) memset(a, v, sizeof(a))
#define fre(f) freopen(f ".in", "r", stdin)
using namespace std;

int next[N][10], sz;
bool sign[N]; //记录是否是一个字符串的最后位置

int main()
{
    int T, n;
    char s[20];
    scanf("%d", &T);
    while (T--)
    {
        mem(next, 0);
        mem(sign, 0);
        sz = 0;
        scanf("%d", &n);
        bool flag = 1;
        while (n--)
        {
            scanf("%s", s);
            if (flag)
            {
                int len = strlen(s), it = 0;
                bool tmp = 0;
                for (int i = 0; i < len; i++)
                {
                    char c = s[i];
                    if (next[it][c - '0'] == 0)
                    {
                        tmp = 1;
                        next[it][c - '0'] = ++sz;
                    }
                    it = next[it][c - '0'];
                    if (sign[it]) flag = 0;
                }
                sign[it] = 1;
                if (!tmp) flag = 0;
            }
        }
        if (flag)
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}