算法模板の字符串处理

1、AC自动机

void buildTrie(Node *root, char *str){  
    Node *p = root;  
    for(int i = 0; str[i]; ++i){  
        int index = str[i] - '0';  
        if(!p->next[index]) p->next[index] = new Node(ecnt++);  
        p = p->next[index];  
    }  
    p->flag = true;  
}  
     
void makeFair(Node *root){  
    queue<Node*> que; que.push(root);  
    while(!que.empty()){  
        Node *tmp = que.front(); que.pop();  
        for(int i = 0; i < 10; ++i){  
            if(!tmp->next[i]) continue;  
            if(tmp == root) tmp->next[i]->fail = root;  
            else{  
                Node *p = tmp->fail;  
                while(p){  
                    if(p->next[i]){  
                        tmp->next[i]->fail = p->next[i];  
                        break;  
                    }  
                    p = p->fail;  
                }  
                if(!p) tmp->next[i]->fail = root;  
            }  
            if(tmp->next[i]->fail->flag) tmp->next[i]->flag = true;  
            else que.push(tmp->next[i]);  
        }  
    }  
    root->fail = root;  
}

2、后缀自动机（HDU 1403）

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

const int MAXN = 100000 + 10;
char buf[MAXN];
struct State {
    State *par, *go[26];
    int val;/*
    State() :
            par(0), val(0) {
        memset(go, 0, sizeof go);
    }*/
}*root, *last;
State statePool[MAXN * 2], *cur;

void init() {
    memset(statePool, 0, 2 * strlen(buf) * sizeof(State));
    cur = statePool;
    root = last = cur++;
}

void extend(int w) {
    State *p = last, *np = cur++;
    np->val = p->val + 1;
    while (p && !p->go[w])
        p->go[w] = np, p = p->par;
    if (!p) np->par = root;
    else {
        State*q = p->go[w];
        if (p->val + 1 == q->val) np->par = q;
        else {
            State *nq = cur++;
            memcpy(nq->go, q->go, sizeof q->go);
            nq->val = p->val + 1;
            nq->par = q->par;
            q->par = nq;
            np->par = nq;
            while (p && p->go[w] == q)
                p->go[w] = nq, p = p->par;
        }
    }
    last = np;
}

int main() {
    char *pt;
    while(scanf("%s", buf) != EOF) {
        init();
        for (pt = buf; *pt; ++pt)
            extend(*pt - 'a');
        scanf("%s", buf);
        State *t = root;
        int l = 0, ans = 0;
        for (pt = buf; *pt; ++pt) {
            int w = *pt - 'a';
            if (t->go[w]) {
                t = t->go[w];
                ++l;
            } else {
                while (t && !t->go[w]) t = t->par;
                if (!t) l = 0, t = root;
                else {
                    l = t->val + 1;
                    t = t->go[w];
                }
            }
            ans = max(ans, l);
        }
        printf("%d
", ans);
    }
    return 0;
}

3、后缀数组//字符串末尾要手动添加一个最小字符（比如0）

char s[MAXN];
int sa[MAXN], height[MAXN], rank[MAXN], c[MAXN], tmp[MAXN];
int n;

void makesa(int m) {
    memset(c, 0, m * sizeof(int));
    for(int i = 0; i < n; ++i) ++c[rank[i] = s[i]];
    for(int i = 1; i < m; ++i) c[i] += c[i - 1];
    for(int i = 0; i < n; ++i) sa[--c[rank[i]]] = i;
    for(int k = 1; k < n; k <<= 1) {
        for(int i = 0; i < n; ++i) {
            int j = sa[i] - k;
            if(j < 0) j += n;
            tmp[c[rank[j]]++] = j;
        }
        int j = c[0] = sa[tmp[0]] = 0;
        for(int i = 1; i < n; ++i) {
            if(rank[tmp[i]] != rank[tmp[i - 1]] || rank[tmp[i] + k] != rank[tmp[i - 1] + k])
                c[++j] = i;
            sa[tmp[i]] = j;
        }
        memcpy(rank, sa, n * sizeof(int));
        memcpy(sa, tmp, n * sizeof(int));
    }
}

void calheight() {
    for(int i = 0, k = 0; i < n; height[rank[i++]] = k) {
        if(k > 0) --k;
        int j = sa[rank[i] - 1];
        while(s[i + k] == s[j + k]) ++k;
    }
}

int logn[MAXN];
int best[20][MAXN];

void initRMQ() {
    logn[0] = -1;
    for(int i = 1; i <= n; ++i)
        logn[i] = (i & (i - 1)) == 0 ? logn[i - 1] + 1 : logn[i - 1];
    for(int i = 1; i <= n; ++i) best[0][i] = height[i];
    for(int i = 1; i <= logn[n]; ++i) {
        int ed = n - (1 << i) + 1;
        for(int j = 1; j <= ed; ++j)
            best[i][j] = min(best[i - 1][j], best[i - 1][j + (1 << (i - 1))]);
    }
}

int lcp(int a, int b) {
    a = rank[a], b = rank[b];
    if(a > b) swap(a, b);
    ++a;
    int t = logn[b - a + 1];
    return min(best[t][a], best[t][b - (1 << t) + 1]);
}

4、Manacher（Update：2014年11月13日）

void manacher() {
    int mx = 0, id;
    for(int i = 1; i < n; ++i) {
        if(mx > i) p[i] = min(p[2 * id - i], mx - i);
        else p[i] = 1;
        while(s[i + p[i]] == s[i - p[i]]) ++p[i];
        if(i + p[i] > mx) {
            id = i;
            mx = i + p[i];
        }
    }
}

void print() {
    int id = 0;
    for(int i = 1; i < n; ++i)
        if(p[i] > p[id]) id = i;
    int l = (id - p[id] + 1) / 2, r = l + p[id] - 1;
    for(int i = l; i < r; ++i) putchar(str[i]);// 范围[l, r)
    puts("");
}

int main() {//两倍数组大小
    scanf("%s", str);
    s[n++] = '$', s[n++] = '#';
    for(int i = 0; str[i]; ++i) {
        s[n++] = str[i];
        s[n++] = '#';
    }
    s[n] = 0;
    manacher();
    print();
}