C++博客-Mato is No.1-随笔分类-字符串匹配

【AHOI2013复仇】SCOI2003 字符串折叠

Mato_No1 — Wed, 24 Oct 2012 07:11:00 GMT

原题地址
本沙茶在2009年1月曾经在RQNOJ上捉过这题，那时候是很难的题，现在就很水了囧……（当然，本沙茶那个时候不会exKMP，是用暴力的，可是时间复杂度仍能是O(N³)）。

F[i][j]=min{F[i][k]+F[k+1][j]，min{((j-i+1)/(k-i+1)的十进制位数)+2+F[i][k]，k-i+1}, i<=k（加上k-i+1是因为对于以下三种重叠字符串，不压缩比压缩要短：AA型、AAA型、ABAB型）
边界：F[i][i]=1；

问题是在上述方程的第二项里如何求出可行的k。显然，只需要对[i..j]这一段作exKMP，求出nx，然后k可行当且仅当满足：（1）nx[k+1]=j-k；（2）(k-i+1)|(j-i+1)；

不过，本题在写exKMP的过程中会出现很囧的问题……由于下标不是从0开始，而是从i开始，所以很多地方关于下标的计算都要改掉，非常不方便，而且很容易疵掉。与其这样，还不如把[i..j]这一段复制到一个新字符串里，下标从0开始。对于其它的某些字符串算法和数据结构，或许也是这样囧……

代码：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 110, INF = ~0U >> 2;
int n, F[MAXN][MAXN], nx[MAXN], res;
char ss[MAXN + 1], ss0[MAXN + 1];
void init()
{
    scanf("%s", ss); n = strlen(ss);
}
int sol0(int l, int r)
{
    int W = r - l + 1; re3(i, l, r) ss0[i - l] = ss[i];
    nx[0] = W; nx[1] = nx[0] - 1; re(i, W) if (ss0[i] != ss0[i + 1]) {nx[1] = i; break;}
    int k = 1, len, p = k + nx[k] - 1, x, y;
    re2(i, 2, W) {
        len = nx[i - k];
        if (i + len <= p) nx[i] = len; else {
            x = p + 1; y = p - i + 1; if (y < 0) {x++; y = 0;}
            for (; x<=W && ss0[x]==ss0[y]; x++, y++) ;
            nx[i] = y; k = i; p = i + y - 1;
        }
    }
    int res0 = INF, tmp, V;
    re2(i, 1, W) if (!(W % i) && nx[i] == W - i) {
        V = F[l][l + i - 1] + 2; tmp = W / i; while (tmp) {tmp /= 10; V++;}
        if (W < V) V = W;
        if (V < res0) res0 = V;
    }
    return res0;
}
void solve()
{
    re(i, n) F[i][i] = 1;
    int j, tmp;
    re2(x, 1, n) re(i, n-x) {
        j = i + x; F[i][j] = sol0(i, j);
        re2(k, i, j) {tmp = F[i][k] + F[k + 1][j]; if (tmp < F[i][j]) F[i][j] = tmp;}
    }
    res = F[0][n - 1];
}
void pri()
{
    printf("%d\n", res);
}
int main()
{
    init();
    solve();
    pri();
    return 0;
}

Mato_No1 2012-10-24 15:11 发表评论

COCI 2011～2012 #5 后两题题解

Mato_No1 — Wed, 18 Apr 2012 12:26:00 GMT

相关链接
今天在回顾以前的题目的时候，秃然发现COCI 2011～2012 #5的后两题并非神犇题（至少一般人可以捉的）……是我当时想傻掉了囧……

blokovi：
首先很容易发现最优方案必然是从顶到底，先尽量往右边放，放到某一个转折点处再尽量往左边放……
然后就是枚举这个转折点，乱算一下就行了，暴力O(N²)的可以过7个点（本沙茶现场赛时就是用这个的）……
优化：可以从上到下依次枚举转折点，设目前的转折点为i，则在下一次枚举时（(i+1)为转折点），把(i+1)往右平移2单位，然后根据那个重心计算公式可以得出，第(i+2)个及以后的必然是整体向右平移(2*m2)/(m1+m2)，其中m1为前i个的质量和，m2为第(i+1)个的质量……在此基础上维护转折点前重心位置、转折点的重心的横坐标（相对于最上面的那个）以及最下面的那个的重心的横坐标（相对于最上面的那个）就行了（注意转折点是第一个或最后一个的特殊情况要单独处理），时间复杂度O(N)。

poplocavanje：
其实这题只要用AC自动机随便乱搞一下就行了……Trie上的每个结点维护一个KK，表示该结点所代表的字符串的后缀的最大匹配长度（当然前提条件是该结点是危险的），则：（1）若该结点本来就代表一个待匹配的子串，则KK值为子串长度；（2）若该结点是通过失败指针上溯到一个危险结点的，则该结点的KK就是上溯到的那个危险结点的KK。然后做一次匹配，记下所有的匹配区间，再求出未被区间覆盖的总长度（排序+扫描即可，不需任何数据结构）就行了。

注意几个易疵的地方：
（1）Trie的大小要开到4M才能过（不过再大就要MLE了囧……）；
（2）在建自动机计算KK的时候，如果一个结点本来就是危险的（即上述第1种结点），此过程中又发现它是上述第2种结点，则不能重新计算KK；
（3）最后求未被区间覆盖总长度的方法：先记下所有的区间，按照先左端点递增序后右端点递增序排序，当中去掉被别的区间覆盖的区间，然后先看一下排序后的第一个区间和最后一个区间，得出第一个区间之前与最后一个区间之后的未被覆盖的部分，中间的扫描求解时，如果某区间的左端点大于(前一区间的右端点+1)，则计入中间的空当……不过还有一种方法就是不去掉被别的覆盖的区间，而是在扫描过程中维护右端点最大值maxr，然后把上面方法中的所有右端点改为maxr即可。

代码：
blokovi poplocavanje

Mato_No1 2012-04-18 20:26 发表评论

KMP、AC自动机在字符串匹配类动态规划问题中的应用

Mato_No1 — Sun, 30 Oct 2011 03:22:00 GMT

有一类动态规划（其中也包含递推）问题，要求满足一些限制条件的字符串，这些限制条件是“需要含有某个子串”或“不能含有某个子串”，那么KMP、AC自动机等就有大用了。

【例1】HDU3689
题意：字符集中有一些字符，给出每个字符的出现概率（它们的和保证为1），再给出一个子串B，求：任给一个长度为N的字符串A（只能包含字符集中的字符），使得S是A的子串的概率。

求解这类问题首先要进行补集转化。因为子串可能有重叠（比如"ababa"中就出现了两个"aba"），所以先转化为“求任给一个长度为N的字符串A（只能包含字符集中的字符），使得B不是A的子串的概率”，然后再用1减去这个概率即为结果。
设F[i][j]为“在所有长度为i的不出现B的字符串中，后缀与B的前缀匹配长度为j（即该字符串的后缀与B的前缀的最大匹配长度为j）的概率”，很显然，F是由递推得到了，关键是如何进行状态转移？或者说，在递推过程中，哪些状态可能成为F[i][j]的前趋状态？
假设F[i-1][k]是F[i][j]的前趋状态，也就是说，在字符集中至少存在一个字符c，使得主串的第i位（最后一位）取c时，能够从F[i-1][k]转移到F[i][j]。这就需要求一个值S[k][c]，表示当主串的后缀与B的前缀的（最大）匹配长度为k时，在主串后再加上一个字符c，其匹配长度会变成什么。举例：设目前主串A'="abasab"，B="asabs"，其匹配长度为4，若在A'后加上一个字符's'，则匹配长度变为5，所以S[4]['s']=5，而若在A'后加上一个字符'a'，则匹配长度会变成1，所以S[4]['a']=1。显然S值和A前面的哪些字符是没有关系的。
那么这个S值如何计算？其实可以发现，S和KMP算法中的nx数组神似，因此完全可以按照计算nx数组的办法来计算S。具体来说，先要对B作KMP自身匹配，求出其nx数组，然后，在求S[k][c]的时候，尝试在B的第k位（由于B的下标从0开始所以B[k-1]）后加上字符c，看看会“回退”到哪里即可。代码：

     int j = 0; nx[0] = 0;
     re2(i, 1, m) {
            while (j && A[i] != A[j]) j = nx[j - 1];
            if (A[i] == A[j]) j++;
            nx[i] = j;
     }
     re(i, m) re(k, SZ) {
           j = i;
           while (j && A[j] != k + 97) j = nx[j - 1];
           if (A[j] == k + 97) S[i][k] = ++j; else S[i][k] = 0;
     }

这里m是B的长度。注意，当i=m时，S[i][j]是无意义的，因为前面已经说过了不能出现B。
在求出S值后就能求出F值了。对于状态F[i][j]，若存在一个字符c使得x=S[i][c]（满足0<=x最终结果为1-∑F[N][0..m-1]。

代码

【例2】PKU1625（URAL1158）
题意：给出一些子串，求长度为N，各个字符都属于给定的字符集的所有字符串中，不包含任何一个给出的子串的字符串个数（需要使用压9位的高精度）。

本题显然是【例1】的多子串形式，而用来解决多个字符串同时匹配的只有AC自动机，那么如何在本题中使用AC自动机求解呢？
观察【例1】中的F[i][j]，可以想象一下，一个图中有m个顶点，分别表示匹配长度为0..(m-1)，然后不断新加入的字符让这些状态在这些结点间不断转移（状态转移就是图中的边），这样，F[i][j]就表示“阶段i到达结点j上”。而AC自动机是基于Trie（树）的，其中有现成的结点，这就揭示了本题的状态：
F[i][j]表示长度为i的合法的字符串（就是满足字符集限制且不包含任何一个给定子串）中，在匹配到最后一位（第i位）后，刚好到达结点j的字符串的个数。
同样，S[k][c]表示“目前到达结点k，接下来的一个字符是c的时候，会到达哪个结点。在对所有的子串建立了自动机之后，S值只要类似地搞就能求出来了。然后F的转移也就搞定了。
不过，本题要万分注意AC自动机的一个BUG：在建立了自动机以后，需要把所有本身不危险（如果一个结点代表的字符串刚好是某一个给出的不能出现的子串，则该结点是危险结点），但通过失败指针不断上溯能够到达一个危险结点的结点，也标记为危险结点，比如两个子串是"abcde"和"bc"，则代表"abcd"的那个结点由于包含了"bc"所以也是危险的。
此外，本题的输入要注意，字符集的ASCII码范围是-128~127，所以必须用char而不是unsigned char，且由于可能包含空格所以必须用gets()而不是scanf()输入，又因为C/C++中木有负数下标，因此在输入之后还要转化一下（加128）。

代码

【例3】PKU3691
题意：给出一些子串和一个字符串A（其每个字符均属于字符集{'A', 'C', 'G', 'T'}），求至少要改动A的几个字符（不能改成不属于字符集的字符），使得它不包含任何一个给出的子串，若不管怎么改都不行，则结果为-1。

这就是真正的DP了。设F[i][j]为前i位，到达的结点为j，最少改动的字符个数，则转移方程为
F[i][j] = min{F[i-1][x] + (A[i] != c)}，c∈{'A', 'C', 'G', 'T'}，S[x][c]=j。边界：F[0][root]=0，其余的F[0][]=+∞，A的实际下标从1开始。
求S数组的方法见【例2】

代码

【例4】PKU3208
题意：含有连续的三个数字6的正整数，称为"beastly number"，求第P个（1<=P<=50000000）"beastly number"（其位数不会超过15位）。
（这题是本沙茶在PKU上至今为止，自己想出算法的AC人数最少的题）
本题其实是用不着KMP的，因为"666"这样简单的子串……

思路：由于位数不会超过15位（后来发现最多只有10位），所以每个"beastly number"都可以看成一个长度为15，字符集为['0'..'9']的字符串（注意是可以有前导0的，因为位数可能不足15位）A，整个过程也就是从高位（第0位）向低位（第14位）求出A的各位。

预处理：求出F[i][j]，表示若A的前i位已经确定（其中不含"666"，准确来说是非末尾不含"666"），且前i位的末尾刚好有j个'6'（j的范围是0到3）时，有多少个"beastly number"（注意，前i位既然已经确定，就不可更改了，能够决定的只有第i位的后面）。
显然先要求出F0[i][j]表示有多少个不是"beastly number"。其递推方程不好写，见代码（其实也是很好理解的）。然后F[i][j]=10^14-i - F0[i][j]。

然后就是不断调整边界来构造了。准确来说，设前i-1位已经确定，现在要确定第i位，则枚举第i位是0~9中的哪个值，然后求出满足条件的最小的"beastly number"和最大的"beastly number"的名次（注意，名次是从1开始的），看看P在不在其中，这样就能确定了。严重注意：如果已确定的位数中已经出现了"666"，接下来的就不用枚举了，直接在后面接上P-L就行了，L为左边界。

但是，为什么要把本题放在KMP的专题里面呢囧？因为如果这个子串不是"666"而是一些结构复杂的东东比如"123131"这样的，只有借助KMP算法了。这时，F[i][j]就表示 A的前i位已经确定（非末尾不含这个子串），且其后缀与这个子串的前缀匹配长度为j，有多少个"beastly number" ，转移方程与前几个例子类似。

代码

总结：
KMP算法和AC自动机的状态转移性质决定了它们在字符串匹配类DP问题中的巨大作用。在实际应用中，要注意灵活使用它们。此外，AC自动机的那个BUG是一定要注意的。

Mato_No1 2011-10-30 11:22 发表评论

后缀数组

Mato_No1 — Sun, 23 Oct 2011 08:51:00 GMT

【后缀数组真难懂啊啊……就20+行的代码搞了几天才理解……不知是不是我太沙茶了】

【1】一些定义：
字符串：广义的字符串是指“元素类型有序，且元素值有一定范围的序列”，其元素不一定非要是字符，可以是数字等，因此整数、二进制数等也是字符串；
字符集：字符串的元素值的范围称为字符集，其大小记为SZ。
字符串的长度：字符串中元素的个数，一般记为N，长度为N的字符串A第一次提到时一般用A[0..N-1]来表示；
前缀：字符串A[0..N-1]的从A[0]开始的若干个连续的字符组成的字符串称为A的前缀，以下“前缀i”或者“编号为i的前缀”指的都是A[0..i]；
后缀：字符串A[0..N-1]的到A[N-1]终止的若干个连续的字符组成的字符串称为A的后缀，以下“后缀i”或者“编号为i的后缀”指的都是A[i..N-1];

对于一个长度为N的字符串，将其N个后缀按字典序大小进行排序，得到两个数组sa[i]和rank[i]，sa[i]为排在第i位的后缀的编号（也就是一般说的ord[i]），rank[i]为排在后缀i排在的位置（称为后缀i的名次）。sa、rank值的范围均为[0..N-1]。sa和rank互逆，即sa[i]=j等价于rank[j]=i，或者说成sa[rank[i]]=rank[sa[i]]=i。这里，sa称为后缀数组，rank称为名次数组。

【2】用倍增算法求后缀数组：
在论文里，后缀数组有两种求法：倍增算法和DC3算法，前者的时间复杂度为O(NlogN)，但常数较小，后者的时间复杂度为O(N)，但常数较大，在实际应用中，两者的总时间相差不大，且后者比前者难理解得多（本沙茶理解前者都用了几天时间……后者就木敢看了）。这里就总结一下倍增算法吧囧……
首先，贴一下本沙茶的用倍增算法求后缀数组的模板：

void suffix_array()
{
    int p, v0, v1, v00, v01;
    re(i, SZ) S[i] = 0;
    re(i, n) rank[i] = A[i];
    re(i, n) S[A[i]]++;
    re2(i, 1, SZ) S[i] += S[i - 1];
    rre(i, n) sa[--S[A[i]]] = i;
    for (int j=1; j<n; j<<=1) {
        p = 0; re2(i, n-j, n) tmp[p++] = i;
        re(i, n) if (sa[i] >= j) tmp[p++] = sa[i] - j;
        re(i, SZ) S[i] = 0;
        re(i, n) S[rank[i]]++;
        re2(i, 1, SZ) S[i] += S[i - 1];
        rre(i, n) sa[--S[rank[tmp[i]]]] = tmp[i];
        tmp[sa[0]] = p = 0;
        re2(i, 1, n) {
            v0 = sa[i - 1]; v1 = sa[i];
            if (v0 + j < n) v00 = rank[v0 + j]; else v00 = -1;
            if (v1 + j < n) v01 = rank[v1 + j]; else v01 = -1;
            if (rank[v0] == rank[v1] && v00 == v01) tmp[sa[i]] = p; else tmp[sa[i]] = ++p;
        }
        re(i, n) rank[i] = tmp[i];
        SZ = ++p;
    }
}

这里A是待求sa和rank的字符串。

<1>倍增算法的思想：
记R[i][j]为A[i..i+2^j-1]（如果越界，则后面用@填充）在A的所有长度为2^j的子串（越界则后面用@填充）中的名次（rank）值。倍增算法就是按阶段求出所有R[i][j]的值，直到2^j>N为止。首先，R[i][0]的就是字符A[i]在A[0..N-1]中的名次，是可以直接用计数排序来实现的。然后，若R[0..N-1][j-1]已知，则可以按照以下方法求出R[0..N-1][j]的值：对每个i（0<=ii, Y_i>，其中X_i=R[i][j-1]，Y_i=R[i+2^j][j-1]（若i+2^j>=N，则Y_i=-∞），然后对这N个二元组按照第一关键字为X，第二关键字为Y（若两者都相等则判定为相等）进行排序（可以用基数排序来实现），排序后，i, Y_i>的名次就是的R[i][j]的值。

<2>一开始，对A中的各个字符进行计数排序：

re(i, SZ) S[i] = 0;
re(i, n) rank[i] = A[i];
re(i, n) S[A[i]]++;
re2(i, 1, SZ) S[i] += S[i - 1];
rre(i, n) sa[--S[A[i]]] = i;

这个木有神马好说的，在搞懂了基数排序之后可以秒掉。唯一不同的是这里加了一句：rank[i]=A[i]，这里的rank[i]是初始的i的名次，MS不符合rank[i]的定义和sa与rank间的互逆性。这里就要解释一下了囧。因为在求sa的过程中，rank值可能不符合定义，因为长度为2^j的子串可能会有相等的，此时它们的rank值也要相等，而sa值由于有下标的限制所以不可能有相等的。因此，在过程中，rank其实是用来代替A的子串的，这样rank值只需要表示一个“相对顺序”就行了，也就是：rank[i0]>(=, <)rank[i1]，当且仅当A[i0..i0+2^j-1]>(=, <)A[i1..i1+2^j-1]。这样，可以直接将A[i]值作为初始的rank[i]值。

<3>j（代替2^j）的值从1开始不断倍增，对二元组进行基数排序求出新阶段的sa值：

for (int j=1; j<n; j<<=1) {
    p = 0; re2(i, n-j, n) tmp[p++] = i;
    re(i, n) if (sa[i] >= j) tmp[p++] = sa[i] - j;
    re(i, SZ) S[i] = 0;
    re(i, n) S[rank[i]]++;
    re2(i, 1, SZ) S[i] += S[i - 1];
    rre(i, n) sa[--S[rank[tmp[i]]]] = tmp[i];

注意这个基数排序的过程是很特别的。首先，它并不是对A在进行排序，而是对上一阶段求出的rank在进行排序。因为前面已经说过，在求sa的过程中，rank就是用来代替A的对应长度的子串的，由于不能直接对子串进行排序（那样的话时间开销很恐怖的），所以只能对rank进行排序。另外，这里在对二元组的第二关键字（y）进行排序的过程中加了优化：这些y其实就是把上一阶段的sa整体左移了j，右边空出的部分全部用@（空串）填充得到的，由于空串的字典序肯定最小，因此将右边的空串按照下标顺序先写入临时sa（代码中用tmp表示的就是临时sa，也就是对第二关键字y排序后的ord结果），然后，上一阶段的sa如果左移后还木有消失的（也就是sa值大于等于j的），再按顺序写入临时sa，就得到了排序结果。剩下的对x的排序结果就是上一阶段的sa，唯一不同的是对于x相同的，按照临时名次递增的顺序。

<4>求出新阶段的rank值：

tmp[sa[0]] = p = 0;
re2(i, 1, n) {
    v0 = sa[i - 1]; v1 = sa[i];
    if (v0 + j < n) v00 = rank[v0 + j]; else v00 = -1;
    if (v1 + j < n) v01 = rank[v1 + j]; else v01 = -1;
    if (rank[v0] == rank[v1] && v00 == v01) tmp[sa[i]] = p; else tmp[sa[i]] = ++p;
}
re(i, n) rank[i] = tmp[i];
SZ = ++p;

由于下一阶段需要使用本阶段的rank值，因此在求出了本阶段的sa值以后，需要求rank值。（代码中的tmp起了临时rank的作用，目的是节省空间）
因为sa值已经求出，因此只要依次扫描sa就可以得到rank值，唯一要做的工作就是找到哪些子串是相等的，它们的rank值应该相等，除此之外，rank值只要依次加1即可。判定相等的方法：只需判定rank[i]和rank[i+j]是否都对应相等即可。若rank[i+j]越界，用-∞（当然任何一个负数都行，代码中用了-1）来表示。
最后还有一个优化：由于本阶段的名次的范围只有[0..p]这么多，下一阶段的“字符集”（其实就是rank集）的大小SZ可以设为p+1，这样可以省一些时间。

这样后缀数组sa和名次数组rank就全部求完了。

以后还有一些更重要的东东就是AC自动机、后缀数组等的应用问题，算了，以后再搞吧囧。

Mato_No1 2011-10-23 16:51 发表评论

AC自动机模板题——HDU2222

Mato_No1 — Wed, 19 Oct 2011 11:47:00 GMT

具体题目见HDU2222，其实就是一个裸的多串匹配的问题（给出一个主串和N个子串，求出几个子串在主串中出现过）。

我真是太沙茶了……这么水的题目调了N久，找了N位神犇帮我看代码，最终才找出来BUG……

易疵点：
（1）本题的子串是可以相同的，此时Trie的每个结点要设一个mul值，表示该结点对应的字符串在所有子串中重复的次数，另外，不要为了省空间把mul定义成char型，有可能所有的字符串全相同，因此需要定义成int（事实证明不会爆空间），这是本沙茶被折磨了这么久的主要原因；
（2）Trie采用静态存储，0号结点作为空结点（NULL），因此真正的结点编号从1开始，另外root一般都是1号结点；
（3）注意在建立自动机以及匹配的时候，所有要沿fail上溯的地方，其边界都是0（NULL，注意不是root）或者找到一个有对应子结点的结点。注意到0还没有找到的处理方法：在建立自动机的时候，将T[j]置为root；在匹配的时候，将x置为root；

代码（模板）（那些标了Attention的地方都是易疵的）：

#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
using std::string;
#define re(i, n) for (int i=0; i
#define root 1
const int MAXN = 500001, MAXLEN = 1000001, SZ = 26, INF = ~0U >> 2;
struct node {
    int mul, ch[SZ], fail;    //Attention
} T[MAXN];
int N, Q[MAXN], res;
string s0, A;
char tmp[MAXLEN], tmp0[51];
void ins()
{
    int len = s0.length(), x = root, c;
    re(i, len) {
        c = s0[i] - 97;
        if (!T[x].ch[c]) {T[x].ch[c] = ++N; T[N].mul = 0; re(j, SZ) T[N].ch[j] = 0;}
        x = T[x].ch[c];
    }
    T[x].mul++;
}
void mkf()
{
    Q[0] = root; T[root].fail = 0;
    int i, j, x;
    for (int front=0, rear=0; front<=rear; front++) {
        i = Q[front];
        re(k, SZ) if (j = T[i].ch[k]) {
            x = T[i].fail;
            while (x && !T[x].ch[k]) x = T[x].fail;        //Attention
            if (x) T[j].fail = T[x].ch[k]; else T[j].fail = root;    //Attention
            Q[++rear] = j;
        }
    }
}
void solve()
{
    int len = A.length(), x = root, y, c; res = 0;
    re(i, len) {
        c = A[i] - 97;
        while (x && !T[x].ch[c]) x = T[x].fail;    //Attention
        if (!x) x = root; else x = T[x].ch[c];    //Attention
        y = x;
        while (y) {res += T[y].mul; T[y].mul = 0; y = T[y].fail;}      //Attention
    }
}
int main()
{
    int tests, n;
    scanf("%d", &tests);
    re(testno, tests) {
        N = 1; T[root].mul = 0; re(i, SZ) T[root].ch[i] = 0;
        scanf("%d", &n); getchar();
        re(i, n) {
            gets(tmp0);
            s0 = tmp0;
            ins();
        }
        gets(tmp);
        A = tmp;
        mkf();
        solve();
        printf("%d\n", res);
    }
    return 0;
}

【2011年10月19日】今天发现了匹配过程中的一个可优化的地方：对于一个点x以及它的所有返回结点（这里把所有沿着x的失败指针不断上溯直到root路径上的结点都称为返回结点），由于不可重复计数，可以将它们的mul值置为原来mul值的相反数（-mul），而不是0，表示该结点已经统计过。这样在下一次y的上溯过程中一旦发现一个mul值为负的点就不用继续上溯了，因为上面的点一定也已经统计过了。
当然，这仅限于单主串，如果是多主串则需要在每次匹配之前把Trie树中所有结点的mul值（如果是负数的的话）全部重新取反。为了节省时间，可以在匹配过程中把所有统计过的（mul值改为负数的）结点全部放进一个辅助的队列里，然后取反时只要处理队列中的结点就行了。

加入该优化后的代码（solve部分）：

void solve()
{
    int len = A.length(), x = root, y, c; res = 0;
    re(i, len) {
        c = A[i] - 97;
        while (x && !T[x].ch[c]) x = T[x].fail;
        if (!x) x = root; else x = T[x].ch[c];
        y = x;
        while (y && T[y].mul >= 0) {res += T[y].mul; T[y].mul = -T[y].mul; y = T[y].fail;}
    }
}

下面是优化的实测结果（第一个为优化后的，第二个为优化前的），可以看出，该优化的力度很大。

Mato_No1 2011-10-19 19:47 发表评论

环形串的最优断点问题

Mato_No1 — Sat, 23 Apr 2011 08:09:00 GMT

【问题描述】
给出一个环形的字符串S，长度为N，现在要找到一个断开点，使得从这里断开后的字符串字典序最小。或者说，对于长度为N的字符串S[0..N-1]，找到一个位置i，使得字符串S' = S[i..N-1] + S[0..i-1]的字典序最小。若存在多个这样的最优断点，则取最左边(i最小)的那个。
【Sample Input】
amandamanda
【Sample Output】
10
（从第10位断开后得到的字符串"aamandamand"的字典序是11个断开位置中最小的）

【分析】
首先将这个环形串拆开：只需将S[0..N-1]的后面再接上S[0..N-2]即可（如对于样例，可构造字符串T = "amandamandaamandamand"），则T的任意一个长度为N的子串T[i..i-N+1]就是S从第i位断开得到的字符串。此时问题就变成了：给出一个长度为(2N-1)的字符串，求出其所有长度为N的子串中字典序最小的。

设F[x]为T中所有起始位小于N的长度为x的子串中字典序最小的子串的起始位（若有多个则取最左边的），如对于T="abaabaaababaabaaa"，有F[0]=F[1]=0，F[2]=2，F[3]=F[4]=5……本题的目的就是求出F[N]的值。一开始已知的只有F[0]=0（长度为0的字符串都是空串，字典序都是最小的，取最左边的第0位）。

可以发现，F数组有很多重要的性质：
性质1 F[0..N]数组是单调递增的。
证明：用反证法。设存在一个值x(0<=xF[x+1]则根据定义，有T[F[x+1]..F[x+1]+x]<=T[F[x]..F[x]+x]（这里一定不会越界，即F[x]+x的值一定不大于(2N-1)，因为xT[F[x]..F[x]+x-1]（否则F[x]的值就应该等于F[x+1]的值了），矛盾，故在F[0..N]中不可能存在任何F[x]>F[x+1]的情况，也即F[0..N]数组是单调递增的（以下将F[0..N]数组简称为F数组）。
性质2 对于任意值x(0<=xF[x]+x。
证明：因为前面已经证明了F数组是单调递增的，这里只需证明对于任意x(0<=x这里同样用反证法。设存在一个值x(0<=xF[x]+x。

根据F数组的以上两个性质可以设计出本题的算法：
设目前已经求出了F[0..x-1]的值，且F[x-1]=i。首先将T[0..i-1]全部删去（因为F数组是单调递增的，F[x]的值一定不小于i），然后对T自身作扩展KMP（就是以T为模板串，T为子串的扩展KMP，相当于其预处理部分），一开始先将F[x]置为i，设第j位的匹配长度为next[j]，若next[j]=x-1且T[j+x-1]
时间复杂度：O(NÖN)，可以根据性质2得到。

Mato_No1 2011-04-23 16:09 发表评论

KMP和扩展KMP

Mato_No1 — Sun, 17 Apr 2011 11:11:00 GMT

KMP：给出两个字符串A（称为模板串）和B（称为子串），长度分别为lenA和lenB，要求在线性时间内，对于每个A[i]（0<=i【算法】
设next[i]为满足B[i-z+1..i]==B[0..z-1]的最大的z值（也就是B的自身匹配）。设目前next[0..lenB-1]与ex[0..i-1]均已求出，要用它们来求ex[i]的值。
根据ex的定义，有A[i-1-ex[i-1]+1..i-1]==B[0..ex[i-1]-1]，这时，若有A[i]==B[ex[i-1]]，则可以直接得到ex[i]=ex[i-1]+1（因为i-1-ex[i-1]+1即i-ex[i-1]，现在由于A[i]==B[ex[i-1]]，可得A[i-ex[i-1]..i]==B[0..ex[i-1]]，即A[i-ex[i-1]+1-1..i]==B[0..ex[i-1]+1-1]，所以ex[i]=ex[i-1]+1）。若A[i]!=B[ex[i-1]]？
设j=next[ex[i-1]-1]，则根据next定义得B[ex[i-1]-j..ex[i-1]-1]==B[0..j-1]，又因为A[i-ex[i-1]..i-1]==B[0..ex[i-1]-1]得A[i-j..i-1]==B[ex[i-1]-j..ex[i-1]-1]，这样有A[i-j..i-1]==B[0..j-1]！也就是此时只需再比较A[i]与B[j]的值是否相等即可，若相等，可得ex[i]=j+1，若仍不相等，则更新j为next[j-1]，继续比较A[i]与B[j]是否相等……直到A[i]与B[j]相等或直到j==0时，A[i]仍不等于B[j]，此时ex[i]=0。边界：求ex[0]时，初始j（用来代替ex[i-1]）为0。
现在还有一个问题，如何求next？显然next就是以B自身为模板串，B为子串的“自身匹配”，用类似的办法即可，唯一不同的是next[0]=lenB可以直接得到，求next[1]时，初始j（代替next[i-1]）为0。
【核心代码】

    lenA = strlen(A); lenB = strlen(B);
    next[0] = lenB;
    int j = 0;
    re2(i, 1, lenB) {
        while (j && B[i] != B[j]) j = next[j - 1];
        if (B[i] == B[j]) j++;
        next[i] = j;
    }
    j = 0;
    re(i, lenA) {
        while (j && A[i] != B[j]) j = next[j - 1];
        if (A[i] == B[j]) j++;
        ex[i] = j;
    }

扩展KMP：给出模板串A和子串B，长度分别为lenA和lenB，要求在线性时间内，对于每个A[i]（0<=i【算法】
设next[i]为满足B[i..i+z-1]==B[0..z-1]的最大的z值（也就是B的自身匹配）。设目前next[0..lenB-1]与ex[0..i-1]均已求出，要用它们来求ex[i]的值。
设p为目前A串中匹配到的最远位置，k为让其匹配到最远位置的值（或者说，k是在0<=i0根据ex的定义可得，A[k..p]==B[0..p-k]，因为i>k，所以又有A[i..p]==B[i-k..p-k]，设L=next[i-k]，则根据next的定义有B[0..L-1]==B[i-k..i-k+L-1]。考虑i-k+L-1与p-k的关系：
（1）i-k+L-1=L。又由于next的定义可得，A[i+L]必然不等于B[L]（否则A[i..i+L]==B[0..L]，因为i+L<=p，所以A[i..i+L]==B[i-k..i-k+L]，这样B[0..L]==B[i-k..i-k+L]，故next[i-k]的值应为L+1或更大），这样，可以直接得到ex[i]=L！
（2）i+k-L+1>=p-k，即i+L>p。这时，首先可以知道A[i..p]和B[0..p-i]是相等的（因为A[i..p]==B[i-k..p-k]，而i+k-L+1>=p-k，由B[0..L-1]==B[i-k..i-k+L-1]可得B[0..p-i]==B[i-k..p-k]，即A[i..p]==B[0..p-i]），然后，对于A[p+1]和B[p-i+1]是否相等，目前是不知道的（因为前面已经说过，p是目前A串中匹配到的最远位置，在p之后无法知道任何一位的匹配信息），因此，要从A[p+1]与B[p-i+1]开始往后继续匹配（设j为目前B的匹配位置的下标，一开始j=p-i+1，每次比较A[i+j]与B[j]是否相等，直到不相等或者越界为止，此时的j值就是ex[i]的值）。在这种情况下，p的值必然会得到延伸，因此更新k和p的值。
边界：ex[0]的值需要预先求出，然后将初始的k设为0，p设为ex[0]-1。
对于求next数组，也是“自身匹配”，类似KMP的方法处理即可。唯一的不同点也在边界上：可以直接知道next[0]=lenB，next[1]的值预先求出，然后初始k=1，p=ex[1]。

需要严重注意的是，在上述的情况（2）中，本该从A[p+1]与B[p-i+1]开始匹配，但是，若p+1

【核心代码】

lenA = strlen(A); lenB = strlen(B);
    next[0] = lenB; next[1] = lenB - 1;
    re(i, lenB-1) if (B[i] != B[i + 1]) {next[1] = i; break;}
    int j, k = 1, p, L;
    re2(i, 2, lenB) {
        p = k + next[k] - 1; L = next[i - k];
        if (i + L <= p) next[i] = L; else {
            j = p - i + 1;
            if (j < 0) j = 0;
            while (i + j < lenB && B[i + j] == B[j]) j++;
            next[i] = j; k = i;
        }
    }
    int minlen = lenA <= lenB ? lenA : lenB; ex[0] = minlen;
    re(i, minlen) if (A[i] != B[i]) {ex[0] = i; break;}
    k = 0;
    re2(i, 1, lenA) {
        p = k + ex[k] - 1; L = next[i - k];
        if (i + L <= p) ex[i] = L; else {
            j = p - i + 1;
            if (j < 0) j = 0;
            while (i + j < lenA && j < lenB && A[i + j] == B[j]) j++;
            ex[i] = j; k = i;
        }
    }

【时间复杂度分析】
在KMP和扩展KMP中，不管是A串还是B串，其匹配位置都是单调递增的，故总时间复杂度是线性的，都为O(lenA + lenB)（只是扩展KMP比KMP的常数更大一些）。
【应用】
KMP和扩展KMP在解决字符串问题中有大用。很多看上去很猥琐的字符串问题，都可以归结到这两种算法之中。另外，这里的“字符串”可以延伸为一切类型的数组，而不仅仅是字符数组。

Mato_No1 2011-04-17 19:11 发表评论