KMP专题

1、HDU 1711 Number Sequence

　　题意：给出两个数字串a,b,问能否使得数字串b为a的子串，能则输出最小的匹配位置。

　　思路：KMP模板题

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 1000010;
const int maxm = 10010;
int p[maxm];
int des[maxn];
int Next[maxm];
int n, m;
void GetNext(int *next, int *src, int len)
{//next和src都从下标1开始存储
    next[1] = 0;
    int j = 1, i = 0;
    while (j <= len)
    {
        if (i == 0 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}

int KMP(int *T, int *P, int *next)//在目标串T中从位置1开始查找模式串P第一次出现的位置
{
    int lenT = n;
    int lenP = m;
    int posT = 1, posP = 1;
    while (posP <= lenP&&posT <= lenT)
    {
        if (posP == 0 || T[posT] == P[posP])
        {
            ++posT;
            ++posP;
        }
        else posP = next[posP];
    }
    if (posP <= lenP) return -1;
    else return posT - lenP;
}
int main()
{
    int t;
    scanf("%d", &t);

    while (t--)
    {
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i++) scanf("%d", &des[i]);
        for (int i = 1; i <= m; i++) scanf("%d", &p[i]);
        GetNext(Next, p, m);
        printf("%d
", KMP(des, p, Next));
    }
    return 0;
}

2、HDU 1686 Oulipo

　　题意：给出模式串p,文本串t,求p在t中出现的次数(可重叠)

　　思路：KMP同时记录匹配的个数。

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 1000100;
const int maxp = 10010;
char t[maxn];
char p[maxp];
int Next[maxp];
void GetNext(int *next, char *src, int len)
{//next和src都从下标0开始存储
    next[0] = -1;
    int j = 0, i = -1;
    while (j < len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}

int KMP(char*T, char *P, int *next)//在目标串T中从位置1开始查找模式串P第一次出现的位置
{
    int lenT = strlen(T);
    int lenP = strlen(P);
    int posT = 0, posP = 0;
    int cnt = 0;
    while (posT <lenT)
    {
        if (posP == -1 || T[posT] == P[posP])
        {
            ++posT;
            ++posP;
        }
        else posP = next[posP];
        if (posP== lenP)
        {
            cnt++;
            posP = next[posP];
        }
    }
    return cnt;
}
int main()
{
    int Case;
    scanf("%d", &Case);
    while (Case--)
    {
        scanf("%s", p);
        scanf("%s", t);
        GetNext(Next, p, strlen(p));
        printf("%d
", KMP(t,p, Next));
    }
    return 0;
}

3、hdu 2087 剪花布条

　　题意：给出a串和b串,求b串在a串中出现的次数(不可重叠)

　　思路：KMP。注意更新指针时和上一题的不同。

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 1010;
const int maxp = 1010;
char t[maxn];
char p[maxp];
int Next[maxp];
void GetNext(int *next, char *src, int len)
{//next和src都从下标0开始存储
    next[0] = -1;
    int j = 0, i = -1;
    while (j < len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}

int KMP(char*T, char *P, int *next)//在目标串T中从位置1开始查找模式串P第一次出现的位置
{
    int lenT = strlen(T);
    int lenP = strlen(P);
    int posT = 0, posP = 0;
    int cnt = 0;
    while (posT <lenT)
    {
        if (posP == -1 || T[posT] == P[posP])
        {
            ++posT;
            ++posP;
        }
        else posP = next[posP];
        if (posP == lenP)
        {
            cnt++;
            posP++;
        }
    }
    return cnt;
}
int main()
{
    while (~scanf("%s",&t))
    {
        if (t[0] == '#')break;
        scanf("%s", p);
        GetNext(Next, p, strlen(p));
        printf("%d
", KMP(t, p, Next));
    }
    return 0;
}

 4、HDU 3746 Cyclic Nacklace

　　题意：求最少在结尾补几个字符才能使得此串形成循环.

　　思路：lenB%(lenB-Next[lenB])==0则其有周期lenB/(lenB-Next[lenB])，其中最小循环节长度是lenB-Next[lenB]。

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 100010;
const int maxp = 100010;
char t[maxn];
char p[maxp];
int Next[maxp];
void GetNext(int *next, char *src, int len)
{//next和src都从下标0开始存储
    next[0] = -1;
    int j = 0, i = -1;
    while (j < len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}
int main()
{
    int C;
    scanf("%d", &C);
    while (C--)
    {
        scanf("%s", &t);
        int ll = strlen(t);
        GetNext(Next, t,ll);
        int len = ll - Next[ll];//循环节长度
        if (len != ll&&ll%len == 0) printf("0
");
        else printf("%d
", len - Next[ll] % len);
    }
    return 0;
}

5、POJ 1961 Period

　　题意：求出母串的所有前缀的循环节大于1的循环串。

　　思路：根据next数组的性质即 i-next[i] 为一个循环节的长度。

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 1000010;
char des[maxn];
int Next[maxn];
int n, Case;
void GetNext(int *next, char *src, int len)
{
    next[0] = -1;
    int j = 0, i = -1;
    while (j <len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}
void Solve()
{
    printf("Test case #%d
", Case++);
    for (int i = 1; i <= n; i++)
    {
        int len = i - Next[i];
        if (i!= len && i % len == 0)
        {
            printf("%d %d
", i, i / len);
        }
    }
    printf("
");
}
int main()
{
    Case = 1;
    while (~scanf("%d", &n) && n)
    {
        scanf("%s", des);
        GetNext(Next, des, n);
        Solve();
    }
    return 0;
}

6、HUST 1010 The Minimum Length

　　题意：有一个字符串A，一次次的重写A，会得到一个新的字符串AAAAAAAA.....,现在将这个字符串从中切去一部分得到一个字符串B，例如有一个字符串A="abcdefg".，复制几次之后得到abcdefgabcdefgabcdefgabcdefg....，现在切取一部分，得到字符串B，现在只给出字符串B，求出字符串A的长度。

　　思路：最小的循环节：len-next[len]。

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 1000100;
char des[maxn];
int Next[maxn];
int n, Case;
void GetNext(int *next, char *src, int len)
{
    next[0] = -1;
    int j = 0, i = -1;
    while (j <len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}
void Solve()
{
    printf("%d
",n-Next[n]);
}
int main()
{
    while (~scanf("%s",des))
    {
        n = strlen(des);
        GetNext(Next, des, n);
        Solve();
    }
    return 0;
}

7、poj 2406 Power Strings

　　题意：给一个字符串a，它可以看成若干个相同的子串循环形成的，求最大循环次数n。

　　思路：利用KMP算法，求字符串的特征向量next，若len可以被len - next[len]整除，则最大循环次数n为len/(len - next[len])，否则为1。

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 1000100;
char des[maxn];
int Next[maxn];
int n, Case;
void GetNext(int *next, char *src, int len)
{
    next[0] = -1;
    int j = 0, i = -1;
    while (j <len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}
void Solve()
{
    if(n%(n-Next[n])==0)printf("%d
", n/(n - Next[n]));
    else printf("1
");
}
int main()
{
    while (~scanf("%s", des))
    {
        if (des[0] == '.')break;
        n = strlen(des);
        GetNext(Next, des, n);
        Solve();
    }
    return 0;
}

8、poj 2752 Seek the Name, Seek the Fame

　　题意：给出一个字符串str，求出str中存在多少子串，使得这些子串既是str的前缀，又是str的后缀。从小到大依次输出这些子串的长度。

　　思路：next[i]的意义就是：前面长度为i的字串的【前缀和后缀的最大匹配长度】。所以对于这道题，求出len处的next值，并递归的向下求出所有的next值，得到的就是答案。

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 400100;
char des[maxn];
int Next[maxn];
int n, Case;
void GetNext(int *next, char *src, int len)
{
    next[0] = -1;
    int j = 0, i = -1;
    while (j <len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}
void Solve(int x)
{
    if (x != 0)
    {
        Solve(Next[x]);
        if (x == n) printf("%d
", x);
        else printf("%d ", x);
    }
}
int main()
{
    while (~scanf("%s", des))
    {
        n = strlen(des);
        GetNext(Next, des, n);
        Solve(n);
    }
    return 0;
}

9、POJ 3080 Blue Jeans

　　题意：找出n个串中最长的公共串，并且要求字典序最大。

　　思路：直接枚举第一串的所有子串，然后与后面的所有串进行比较即可。

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;

const int N = 107;
char s[N][61];
int Next[N];

void GetNext(char a[], int n)
{
    int i = 0, j = -1;
    Next[0] = -1;
    while (i<n)
    {
        if (j == -1 || a[i] == a[j])
            Next[++i] = ++j;
        else
            j = Next[j];
    }
}

int kmp(char a[], char b[], int n)
{
    int i = 0, j = 0;
    while (i<60)
    {

        if (j == -1 || b[i] == a[j])
            i++, j++;
        else
            j = Next[j];
        if (j == n)
            return true;
    }
    return false;
}

int main()
{
    int T, n, f;
    scanf("%d", &T);
    while (T--)
    {
        char ans[N] = "Z";
        scanf("%d", &n);
        for (int i = 0; i<n; i++)
            scanf("%s", s[i]);
        for (int len = 60; len >= 3; len--)//子串的长度
        {
            for (int i = 0; i <= 60 - len; i++)//子串的开始下标
            {
                char subStr[N] = { 0 };
                strncpy(subStr, s[0] + i, len);

                GetNext(subStr, len);//从subStr中得到Next
                int flag = 0;
                for (int j = 1; j<n; j++)
                {
                    if (!kmp(subStr, s[j], len))
                    {
                        flag = 1;
                        break;
                    }
                }
                if (flag == 0 && strcmp(ans, subStr)>0)
                    strcpy(ans, subStr);
            }
            f = 0;
            if (ans[0] != 'Z')
            {
                printf("%s
", ans);
                f = 1;
                break;
            }
        }
        if (f == 0)
            printf("no significant commonalities
");

    }
    return 0;
}

10、HDU 2594 Simpsons’ Hidden Talents

　　题意：给定两个字符串s1,s2,求最长的s1前缀ss使得ss为s2的后缀,输出该字符串和其长度。

　　思路：①将s1和s2拼接在一起，next[len]也就是最终答案，不过需要注意的是next[len]不能大于s1,s2的长度。

　　　　   ②题目要求最长的s1的前缀同时满足是s2的后缀，可以反过来想一下，把s2作为主串，s1为子串,然后s1不断往后移动，匹配之后就可以了.

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 50010*2;
const int maxp = 50010*2;
char t[maxn];
char p[maxp];
int Next[maxp];
void GetNext(int *next, char *src, int len)
{//next和src都从下标0开始存储
    next[0] = -1;
    int j = 0, i = -1;
    while (j < len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}

int KMP(char*T, char *P, int *next)//在目标串T中从位置1开始查找模式串P第一次出现的位置
{
    int lenT = strlen(T);
    int lenP = strlen(P);
    int posT = 0, posP = 0;
    while (posT <lenT)
    {
        if (posP == -1 || T[posT] == P[posP])
        {
            ++posT;
            ++posP;
        }
        else posP = next[posP];
    }
    return posP;
}
int main()
{
    while (~scanf("%s", &p))
    {
        scanf("%s", t);
        int lt = strlen(t), lp = strlen(p);
        strcat(p, t);//新增
        GetNext(Next, p, strlen(p));
        //int ll=KMP(t, p, Next);
        int ll = lt+lp;
        while (Next[ll] > lt || Next[ll] > lp) ll = Next[ll];
        ll = Next[ll];
        if (ll>0)
        {
            for (int i = 0; i < ll; i++) printf("%c", p[i]);
            printf(" %d
", ll);
        }
        else printf("0
");
    }
    return 0;
}

11、hdu 3336 Count the string

　　题意：给出s,求所有s的前缀在s中出现的次数的和。

　　思路：因为next[i]表示前i个字符所组成的字符串的最大前后缀匹配长度 

　　　　①不断递归求得next[i]，cnt++.

　　　　②所求=字串的前缀个数+与前缀相同的子串。不断累加next[i](当next[i]!=0&&next[i+1]!=next[i])

#include<iostream>
#include<cstring>
using namespace std;
const int maxp = 200010;
const int MOD = 10007;
char p[maxp];
int Next[maxp];//next数组的值就是当前子串的后缀与前缀匹配的个数
void GetNext(int *next, char *src, int len)
{//next和src都从下标0开始存储
    next[0] = -1;
    int j = 0, i = -1;
    while (j < len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        int lp;
        scanf("%d", &lp);
        scanf("%s", p);
        GetNext(Next, p, lp);
        int ans = lp%MOD;
        for (int i = 1; i <= lp; i++)
        {
            int tmp = i;
            while (Next[tmp]) ans = (ans + 1) % MOD, tmp = Next[tmp];
        }
        printf("%d
", ans);
    }
    return 0;
}

 12、HDU 4300 Clairewds message

　　题意：给你一个加密协议，即26个英文字母加密对应表，然后给你一个前一段是加密串，后一段为加密串对应的原串的字符串（原串可能小于加密串）输出最短的原串和加密串。

　　思路：先将原串S全部反加密得到串S'，再将S'串去匹配S，得到明文的长度。

#include <cstdio>
#include <cstring>
#include <string>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
const int MAXN = 100017;

char strm[MAXN];//密码表
char strz[MAXN];//不完整的密文和密文
char str[MAXN]; //密码表转换后
char s[MAXN];   //密文和明文转换后
int Next[MAXN];

void getnext(char T[], int len)
{
    int i = 0, j = -1;
    Next[0] = -1;
    while (i < len)
    {
        if (j == -1 || T[i] == T[j])
        {
            i++, j++;
            Next[i] = j;
        }
        else
            j = Next[j];
    }
}
int KMP(int len1, int len2)
{
    int i, j = 0;
    if (len1 % 2 == 1)
    {
        i = len1 / 2 + 1;
    }
    else
        i = len1 / 2;
    while (i < len1 && j < len2)
    {
        if (j == -1 || strz[i] == s[j])
        {
            i++, j++;
        }
        else
            j = Next[j];
    }
    return j;//j值代表的就是前缀和后缀的最长相等长度
}

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%s", strm);
        for (int i = 0; i < 26; i++)
        {
            char ss = strm[i];
            str[ss] = i;
        }
        scanf("%s", strz);
        int lenz = strlen(strz);
        for (int i = 0; i < lenz; i++)//将密文和明文按照密码表转换
        {
            int tt = str[strz[i]];
            s[i] = 'a' + tt;
        }
        int lens = strlen(s);
        getnext(s, lens);
        int j = KMP(lenz, lens);//得到密文的个数
        if (j * 2 == lenz)//前缀和后缀恰各占一半
        {
            printf("%s
", strz);
        }
        else
        {
            int tt = lenz - j;
            printf("%s", strz);
            for (int i = j; i < tt; i++)//需要添加的明文
            {
                printf("%c", s[i]);
            }
            printf("
");
        }
    }
    return 0;
}

 13、POJ 3450 Corporate Identity

　　题意：求n个字符串的最长公共字串。

　　思路：选取其中一个字符串，枚举其所有后缀，KMP求得其后缀和其余字符串的最长前缀的最小值，更新ans.

#include<iostream>
#include<algorithm>
#include<cstring>
#include<string.h>
using namespace std;
const int maxn = 4010;
const int maxl = 210;
char str[maxn][maxl];
int Next[maxl];
char tstr1[maxl], tstr2[maxl];
int n;
void GetNext(int *next, char *src, int len)
{//next和src都从下标0开始存储
    next[0] = -1;
    int j = 0, i = -1;
    while (j < len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}

int KMP(char*T, char *P, int *next)
{//查找字符串P在字符串T的最长前缀子字符串
    int lenT = strlen(T);
    int lenP = strlen(P);
    int posT = 0, posP = 0;
    int cnt = 0;
    int maxmatch = 0;
    while (posP<lenP&&posT <lenT)
    {
        if (posP == -1 || T[posT] == P[posP])
        {
            ++posT;
            ++posP;
            maxmatch = max(maxmatch, posP);
        }
        else posP = next[posP];
    }
    return maxmatch;
}
int main()
{
    while (~scanf("%d", &n) && n)
    {
        for (int i = 1; i <= n; i++) scanf("%s", str[i]);
        int len = strlen(str[1]);
        int ans = 0, pos = 0;
        for (int i = 0; i < len; i++)
        {//遍历第一个字符串的所有后缀p
            GetNext(Next, str[1] + i, len - i);
            int tl = maxl;
            for (int j = 2; j <= n; j++)
            {//得到后缀p和剩余n-1个字符串的相同前缀的最小值
                tl = min(tl, KMP(str[j], str[1] + i, Next));
            }
            if (tl > ans) ans = tl, pos = i;
            else if (tl == ans)
            {//得到字典序较小的
                memset(tstr1, 0, sizeof(tstr1));
                memset(tstr2, 0, sizeof(tstr2));

                strncpy(tstr1, str[1] + pos, ans);
                strncpy(tstr2, str[1]+i,ans);
                if (strcmp(tstr2, tstr1) < 0) pos = i;
            }
        }
        if (ans > 0)
        {
            memset(tstr1, 0, sizeof(tstr1));
            strncpy(tstr1, str[1] + pos, ans);
            printf("%s
", tstr1);
        }
        else printf("IDENTITY LOST
");
    }
    return 0;
}
/*
4
abcd
abcd
abcd
abcd
3
abc
abcc
ab

*/

 14、HDU 1238 Substrings

　　题意：找到一个子串，该子串的顺或逆为所有字符串的子串，求其最长长度。

　　思路：枚举子串，和其他字符串匹配。

#include<iostream>  
#include<cstdio>  
#include<cstring>  
#include<cstdlib>  
#include<algorithm>  
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1000000007;
const int maxn = 500005;
typedef long long ll;
void get_next(char *s, int *Next)
{
    int len = strlen(s);
    Next[0] = -1;
    int index;
    for (int i = 1; i<len; ++i)
    {
        index = Next[i - 1];
        while (index >= 0 && s[i] != s[index + 1])
        {
            index = Next[index];
        }
        if (s[i] == s[index + 1])
        {
            Next[i] = index + 1;
        }
        else
        {
            Next[i] = -1;
        }
    }
}
int KMP(char *target, char *pattern)
{
    int len1 = strlen(target);
    int len2 = strlen(pattern);
    int Next[maxn];
    get_next(pattern, Next);
    int i = 0, j = 0;
    while (i < len1 && j < len2)
    {
        if (target[i] == pattern[j])
        {
            ++i;
            ++j;
        }
        else if (j == 0)
        {
            ++i;
        }
        else
        {
            j = Next[j - 1] + 1;
        }
    }
    if (j == len2)
    {
        return i - j;
    }
    else
    {
        return -1;
    }
}
char str[101][101];
int main()
{
    int n, t, k;
    char s1[101], s2[101];
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        int pos = 0, MIN = inf;
        int flag = 0;
        for (int i = 0; i<n; ++i)
        {
            scanf("%s", str[i]);
            int len = strlen(str[i]);
            if (len < MIN)
            {
                MIN = len;
                pos = i;
            }
        }
        for (int i = MIN; i>0; --i)
        {//枚举子串长度，从大开始  
            for (int j = 0; j + i <= MIN; ++j)
            {//枚举子串起点  
                for (k = 0; k<i; ++k)
                {//生成子串和反串  
                    s1[k] = str[pos][k + j];
                    s2[i - k - 1] = str[pos][k + j];
                }
                s1[i] = 0;
                s2[i] = 0;
                for (k = 0; k<n; ++k)
                {//匹配  
                    if (KMP(str[k], s1) == -1 && KMP(str[k], s2) == -1)
                    {
                        break;
                    }
                }
                if (k == n)
                {
                    flag = 1;
                    printf("%d
", i);
                    break;
                }
            }
            if (flag)break;
        }
        if (!flag)
        {
            printf("0
");
        }
    }
    return 0;
}

 15、HDU 3374 String Problem

　　题意：求给出字符串的最小和最大表示的开始位置，并且确定其数目。

　　思路：字符串最小最大表示模板。数目可通过最小循环节len-Next[len]确定。

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

#define MAXN 1000100

int len;
int Next[MAXN];
char Str[MAXN];
int minTimes, maxTimes;
int minRank, maxRank;

//求最小表示的起始坐标
int getMin()
{
    int i = 0, j = 1, k = 0;
    while (i< len && j< len&&k<len)
    {
        if (Str[(i + k)%len] == Str[(j + k)%len])
            k++;
        else
        {
            if (Str[(i + k) % len] > Str[(j + k) % len])
                i +=k + 1;
            else
                j +=k+1;
            k = 0;
            if (i == j)//若滑动后i == j那么j++
                j++;
        }
    }
    return min(i, j);
}

//求最大表示的起始坐标
int getMax()
{
    int i = 0, j = 1, k = 0;
    while (i< len && j< len&&k<len)
    {
        if (Str[(i + k)%len] == Str[(j + k)%len])
            k++;
        else
        {
            if (Str[(i + k) % len] < Str[(j + k) % len])
                i = i + k + 1;
            else
                j = j + k + 1;
            k = 0;
            if (i == j)//若滑动后i == j那么j++
                j++;
        }
    }
    return min(i, j);
}
//求next数组
void GetNext(int *next, char *src, int len)
{//next和src都从下标0开始存储
    next[0] = -1;
    int j = 0, i = -1;
    while (j < len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}
int main()
{
    while (~scanf("%s", Str))
    {

        int flag;
        len = strlen(Str);
        //求字符串的最小表示
        minRank = getMin();
        //求字符串的最大表示
        maxRank = getMax();
        GetNext(Next,Str,len);
        minTimes = maxTimes = (len % (len - Next[len]) ? 1 : len / (len - Next[len]));
        //输出
        printf("%d %d %d %d
", minRank + 1, minTimes, maxRank + 1, maxTimes);
    }
    return 0;
}

 16、hdu 2609 How many

　　题意：求给出的n的字符串的不同数目。（如果一个字符串通过旋转能够得到另一个字符串，则当成相同字符串）

　　思路：将所有字符串用最小表示法表示，然后set一下。

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<set>
using namespace std;
const int maxn = 10010;
const int maxl = 110;
char s[maxl];
char tmp[maxl];
set<string>ss;
int n;
//求最小表示的起始坐标
int getMin(char *Str,int len)
{
    int i = 0, j = 1, k = 0;
    while (i< len && j< len&&k<len)
    {
        if (Str[(i + k) % len] == Str[(j + k) % len])
            k++;
        else
        {
            if (Str[(i + k) % len] > Str[(j + k) % len])
                i += k + 1;
            else
                j += k + 1;
            k = 0;
            if (i == j)//若滑动后i == j那么j++
                j++;
        }
    }
    return min(i, j);
}
int Solve()
{
    ss.clear();
    for (int i = 1; i <= n; i++)
    {
        scanf("%s", s);
        int len = strlen(s);
        int pos = getMin(s, len);
        memset(tmp, 0, sizeof(tmp));
        strncpy(tmp, s+pos, len - pos);
        strncat(tmp, s, pos);
        ss.insert(string(tmp));
    }
    return ss.size();
}
int main()
{
    while (~scanf("%d", &n))
    {
        printf("%d
", Solve());
    }
    return 0;
}

 17、FZU Problem 1901 Period II

　　题意：给你一个字符串str，对于每个str长度为p的前缀，如果str[i]==str[p+i](p+i<len)，那么我们认为它是一个periodic prefixs.求所有满足题意的前缀的长度p。

　　思路：对于模式串str，next数组的意义就是：如果next(j)=t,那么str[1…t]=str[len-t+1…len]。所以不断递归打印next[j]即可。

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn = 1000010;
char des[maxn];
int Next[maxn];
int ans[maxn];
void GetNext(int *next, char *src, int len)
{//next和src都从下标0开始存储
    next[0] = -1;
    int j = 0, i = -1;
    while (j < len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}
int main()
{
    int C = 1;
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%s", des);
        int len = strlen(des);
        GetNext(Next, des, len);
        int cnt = 0;
        int ll = Next[len];
        while (ll)
        {
            ans[cnt++] = len - ll;
            ll = Next[ll];
        }
        ans[cnt++] = len;
        printf("Case #%d: %d
", C++,cnt);
        for (int i = 0; i < cnt; i++)
        {
            if (i) printf(" ");
            printf("%d", ans[i]);
        }
        printf("
");
    }
    return 0;
}

 18、HDU 3613 Best Reward

　　题意：给出一个由26种字母组成的字符串，每种字母有权值，当一个串是回文串的时候，它的权值是其中所有字母的权值之和，否则是0。现在要将这个字符串切成两段，问两段的权值和最大是多少。

　　思路：扩展KMP模板。将原串s1反转得到s2，然后进行用s1对s2进行扩展KMP匹配, 得到extend, 对于s1的前i个字符如果和s2的后i个字符相等即extend[len - i] == i则前i个字符为回文串, 判断后len - i个字符是否是回文串用s2对s1进行扩展KMP即可

//将原串s1反转得到s2，然后进行s1, s2扩展KMP匹配, 得到extend, 对于s1的前i个字符如果和s2的后i个字符相等即extend[len - i] == i则前i个字符为回文串, 判断后len - i个字符是否是回文串用s2, s1进行扩展KMP即可
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#define INF 0x3f3f3f3f;
using namespace std;

const int MAX = 500000 + 10;
char s1[MAX], s2[MAX];
int Next[MAX], extend1[MAX], extend2[MAX];
int sum[MAX], val[27];
//extend[i]表示目标串从i开始的后缀和模式串的前缀的最长公共长度
void get_next(char *P, int len)
{
    int k = 0, i = 1;
    Next[0] = len;//可有可无,因为用不上 
    while (k + 1<len && P[k] == P[k + 1])++k;
    Next[1] = k;//这里预先算好next[1]是因为不能k=0,否则next[i-k]=next[i]不是已算好的 
    k = 1;
    while (++i<len)
    {//和EKMP的过程一样 
        int maxr = k + Next[k] - 1;
        Next[i] = min(Next[i - k], max(maxr - i + 1, 0));//这里是扩展KMP的精髓,即算法核心思想就是这
        while (i + Next[i]<len && P[Next[i]] == P[i + Next[i]])++Next[i];
        if (i + Next[i]>k + Next[k])k = i;
    }
}

void EKMP(char *P, char *T, int *extend)
{
    int lenP = strlen(P);
    int lenT = strlen(T);
    get_next(P, lenP);
    int k = 0, i = 0;
    int len = min(lenP, lenT);
    while (k<len && P[k] == T[k])++k;
    extend[0] = k;
    k = 0;
    while (++i<lenT)
    {
        int maxr = k + extend[k] - 1;
        extend[i] = min(Next[i - k], max(maxr - i + 1, 0));//next[i-k]是a与b从i开始的可能已经匹配的长度
        while (i + extend[i]<lenT &&extend[i]<lenP&&P[extend[i]] == T[i + extend[i]])++extend[i];//这里是扩展KMP的精髓,即算法核心思想就是这
        if (i + extend[i]>k + extend[k])k = i;
        //int pp = k + extend[k] - 1, ll = Next[i - k];
        //if (i - 1 + ll >= pp)
        //{
        //    int j = max(0, pp - i + 1);
        //    while (i + j < lenT&&j < lenP&&T[i + j] == P[j]) j++;
        //    extend[i] = j;
        //    k = i;
        //}
        //else extend[i] = ll;
    }
}

int main()
{
    int n;
    cin >> n;
    while (n--)
    {
        for (int i = 0; i<26; ++i)cin >> val[i];
        scanf("%s", s1);
        int len = strlen(s1);
        for (int i = 1; i <= len; ++i)
        {
            sum[i] = sum[i - 1] + val[s1[i - 1] - 'a'];//记录前缀价值和
            s2[i - 1] = s1[len - i];//得到原串的反转
        }
        EKMP(s1, s2, extend1);
        EKMP(s2, s1, extend2);
        int ans = 0, temp = 0;
        for (int i = 1; i<len; ++i)
        {
            if (extend1[len - i] == i)temp += sum[i];//表示前i个字符是回文串
            if (extend2[i] == len - i)temp += sum[len] - sum[i];//表示后len-i个字符为回文串
            if (temp>ans)ans = temp;
            temp = 0;
        }
        cout << ans << endl;
    }
    return 0;
}

 19、poj 3376 Finding Palindromes

　　题意：给你N个字符串, 你可以两两连接得到N * N个字符串, 问之中回文串的数量. N个字符串的长度和加起来不超过2000000.

　　思路：扩展KMP+字典树

假如我们把其中一个翻转，若此时，短的那个串是长的那个的前缀，而长的那个串后面剩余的后缀恰好是个回文串，那这两个串连起来就是个回文串了。比如abc和abacba连接，我们把后一个串翻转，得到abcaba，abc为其前缀，而aba是个回文串，那么连起来就是个回文串。

那我们就把所有的串插入到trie中，然后再用所有的反串去匹配。匹配的过程中，走到任意一个节点，而这个节点有可能是若干个串的结尾，那么此时判反串匹配位置下面剩余的部分是否回文。如果是的，ans就加上以这个节点为结尾的原串的个数（这个插入的时候就可以统计进去了）。如果走完了，还没走到叶子节点，那么就要看走到的节点下的子树（其实是以前面走过的路径为前缀的字符串剩下的一些后缀）有多少是回文的了（这个先预处理所有的串的后缀有哪些是回文的，然后在插入的时候统计到节点上）。

————————摘自：http://blog.csdn.net/pi9nc/article/details/12524647

#include<stdio.h>  
#include<algorithm>  
#include<string.h>  
#define ll __int64  
#include<vector>  
using namespace std;

const int maxn = 2222222;
char vec[maxn];
int g[maxn], nxt[maxn];
bool st[maxn];
int extend[maxn], Next[maxn];
void get_Next(const char *P)
{
    int len = strlen(P);
    int k = 0, i = 1;
    Next[0] = len;//可有可无,因为用不上 
    while (k + 1<len && P[k] == P[k + 1])++k;
    Next[1] = k;//这里预先算好next[1]是因为不能k=0,否则next[i-k]=next[i]不是已算好的 
    k = 1;
    while (++i<len)
    {//和EKMP的过程一样 
        int maxr = k + Next[k] - 1;
        Next[i] = min(Next[i - k], max(maxr - i + 1, 0));//这里是扩展KMP的精髓,即算法核心思想就是这
        while (i + Next[i]<len && P[Next[i]] == P[i + Next[i]])++Next[i];
        if (i + Next[i]>k + Next[k])k = i;
    }
}

void EXKMP(char *T, char *P)
{
    int lenT = strlen(T), lenP = strlen(P);
    int k = 0, i = 0;
    int len = min(lenP, lenT);
    while (k<len && P[k] == T[k])++k;
    extend[0] = k;
    k = 0;
    while (++i<lenT)
    {
        int maxr = k + extend[k] - 1;
        extend[i] = min(Next[i - k], max(maxr - i + 1, 0));//next[i-k]是a与b从i开始的可能已经匹配的长度
        while (i + extend[i]<lenT &&extend[i]<lenP&&P[extend[i]] == T[i + extend[i]])++extend[i];//这里是扩展KMP的精髓,即算法核心思想就是这
        if (i + extend[i]>k + extend[k])k = i;
    }
}

int tot = 0, c[maxn][26], cnt[maxn], val[maxn];
//cnt[i]记录从i到叶子有多少回文串；val[i]表示在该点结束的字符串的个数
int new_node()
{
    int i;
    for (i = 0; i < 26; i++) c[tot][i] = 0;
    cnt[tot] = val[tot] = 0;
    return tot++;
}

void insert(char *s)
{
    int len = strlen(s), i, now = 0;
    for (i = 0; i < len; i++)
    {
        int k = s[i] - 'a';
        if (!c[now][k]) c[now][k] = new_node();
        now = c[now][k];
        if (i + 1 < len && extend[i + 1] == len - i - 1)
        {//s[i+1]~s[len-1]为回文串
            cnt[now] ++;
        }
    }
    cnt[now] ++;
    val[now] ++;
}

ll ans = 0;

void cal(int len)
{
    int j, i, now = 0;
    st[len + 1] = 1;
    for (j = 1; j <= len; j++)
    {
        if (st[j]) now = 0;
        int k = vec[j] - 'a';
        if (!c[now][k])
        {
            now = 0;
            j = nxt[j] - 1;
            continue;
        }
        now = c[now][k];
        if (!st[j + 1] && g[j + 1]) ans += (ll)val[now];
        if (st[j + 1])
        {
            ans += (ll)cnt[now];
            now = 0;
        }
    }
}

char s1[maxn], s[maxn];

int main()
{
    int n, i, j, k;
    while (~scanf("%d", &n))
    {
        tot = 0;
        new_node();//建立Tire根结点
        int t = 0;
        for (i = 1; i <= n; i++)
        {
            scanf("%d%s", &j, s);
            strcpy(s1, s);
            int len = strlen(s);
            reverse(s1, s1 + len);//反转
            get_Next(s1);
            EXKMP(s, s1);//s1匹配s，得到s后缀回文串的长度
            insert(s);//插入原串
            get_Next(s);
            EXKMP(s1, s);//s匹配s1，得到s前缀回文串的长度
            st[t + 1] = 1;//起点
            for (j = 0; j < len; j++)
            {
                if (extend[j] == len - j) g[++t] = 1;//如果s[0]~s[j]为回文串，则标记
                else g[++t] = 0;
                vec[t] = s1[j];//记录反转串
                if (j) st[t] = 0;
            }
        }
        int last = t + 1;//最后一个反转串的下一个，结束标志
        for (i = t; i >= 1; i--)
        {
            nxt[i] = last;//记录当前反转串的下一个反转串
            if (st[i]) last = i;
        }
        ans = 0;
        cal(t);
        printf("%I64d
", ans);
    }
    return 0;
}

20、hdu 4763 Theme Section

　　题意：找到给出字符串的一个子串，其是该字符串的前缀和后缀，且在字符串中间出现过(和前缀后缀不重合)，求其最大长度。

　　思路：根据next数组性质，递归找next[len],判断中间是否出现过。

#include<iostream>
#include<cstring>
using namespace std;
const int maxp = 1000010;
char p[maxp];
int Next[maxp];
void GetNext(int *next, char *src, int len)
{//next和src都从下标0开始存储
    next[0] = -1;
    int j = 0, i = -1;
    while (j < len)
    {
        if (i == -1 || src[j] == src[i])
        {
            j++;
            i++;
            next[j] = i;
        }
        else i = next[i];
    }
}
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%s", p);
        int len = strlen(p);
        GetNext(Next, p, len);
        int ll = Next[len];
        int ans = 0;
        while (ll > 0)
        {
            bool can = false;
            for (int i = ll; i < len - ll; i++)
            {
                if (p[i] == p[0])
                {
                    int j = i, k = 0;
                    while (k<ll&&p[j] == p[k]) j++, k++;
                    if (k == ll)
                    {
                        can = true;
                        break;
                    }
                }
            }
            if (can)
            {
                ans = ll;
                break;
            }
            ll = Next[ll];
        }
        printf("%d
", ans);
    }
    return 0;
}