URAL 1297 Palindrome

URAL_1297

    找回文串最直观的一个算法就是枚举中间的点，然后向两边查找，看最后能拓展多远，但是这样是n^2的算法，利用后缀数组可以达到O(nlogn)的复杂度。

其实在枚举中间的点之后，向外拓展多远是取决于两个方向相反的字符串的公共前缀的，而如果利用后缀数组我们就可以在O(logn)的时间内找到这两个字符串公共前缀最长是多少。

    下面面临的一个问题就是两个字符串是方向相反的，为了能够使两个字符串同向，我们可以把原序列翻过来的序列插入到原序列后面，这样这个字符串里面顺序看过去就既包含了原序列的正向的字符串，同时也包含了原序列的反向的字符串。

    但是，如果这样去找后缀间的公共前缀的话，我们会发现有可能前半部分的字符串尾部可能会和后半部分的字符串首部合并到一起看作某后缀的前缀，为了避免出现这种情况，我们可以在两个字符串中间插入一个比较奇异的字符（这个字符没在原序列中出现即可），比如’$’，这样就不用担心这个问题了。

    之后，之所以能够在O(logn)的时间内找到两个字符串公共前缀最长是多少，源于height数组的一些性质。不妨设两个后缀的起始位置分别为i、j（不妨设i<j），那么两个后缀的最长公共前缀的长度就是height[rank[i]+1],height[rank[i]+2],...,height[rank[j]]中的最小值，这一点根据height数组的定义不难证明。这样我们就可以利用线段树在O(logn)的时间找到这些值中的最小值了。

#include<stdio.h>
#include<string.h>
#define MAXD 2010
#define INF 0x3f3f3f3f
char b[MAXD];
int tree[4 * MAXD];
int N, M, P, r[MAXD], rank[MAXD], height[MAXD], sa[MAXD], wa[MAXD], wb[MAXD], ws[MAXD], wv[MAXD];
void init()
{
    int i, j, k;
    for(i = 0; b[i]; i ++)
        r[i] = b[i];
    r[N = i] = '$';
    for(j = i - 1, ++ i; j >= 0; i ++, j --)
        r[i] = b[j];
    r[M = i] = 0;
}
int cmp(int *p, int x, int y, int l)
{
    return p[x] == p[y] && p[x + l] == p[y + l];
}
void da(int n, int m)
{
    int i, j, p, *x = wa, *y = wb, *t;
    for(i = 0; i < m; i ++)
        ws[i] = 0;
    for(i = 0; i < n; i ++)
        ++ ws[x[i] = r[i]];
    for(i = 1; i < m; i ++)
        ws[i] += ws[i - 1];
    for(i = n - 1; i >= 0; i --)
        sa[-- ws[x[i]]] = i;
    for(p = 1, j = 1; p < n; j *= 2, m = p)
    {
        for(p = 0, i = n - j; i < n; i ++)
            y[p ++] = i;
        for(i = 0; i < n; i ++)
            if(sa[i] >= j)
                y[p ++] = sa[i] - j;
        for(i = 0; i < n; i ++)
            wv[i] = x[y[i]];
        for(i = 0; i < m; i ++)
            ws[i] = 0;
        for(i = 0; i < n; i ++)
            ++ ws[wv[i]];
        for(i = 1; i < m; i ++)
            ws[i] += ws[i - 1];
        for(i = n - 1; i >= 0; i --)
            sa[-- ws[wv[i]]] = y[i];
        for(t = x, x = y, y = t, x[sa[0]] = 0, p = 1, i = 1; i < n; i ++)
            x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1: p ++;
    }
}
void calheight(int n)
{
    int i, j, k = 0;
    for(i = 1; i <= n; i ++)
        rank[sa[i]] = i;
    for(i = 0; i < n; height[rank[i ++]] = k)
        for(k ? -- k : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; k ++);
}
void build()
{
    int i, j, k;
    memset(tree, 0x3f, sizeof(tree));
    for(P = 1; P < M + 2; P <<= 1);
    for(i = 1; i <= M; i ++)
        tree[P + i] = height[i];
    for(i = P - 1; i > 0; i --)
        tree[i] = tree[2 * i] < tree[2 * i + 1] ? tree[2 * i] : tree[2 * i + 1];
}
int search(int x, int y)
{
    int i, j, t, min = INF;
    if(x > y)
        t = x, x = y, y = t;
    for(i = P + x, j = P + y + 1; i ^ j ^ 1; i >>= 1, j >>= 1)
    {
        if((~i & 1) && tree[i ^ 1] < min)
            min = tree[i ^ 1];
        if((j & 1) && tree[j ^ 1] < min)
            min = tree[j ^ 1];
    }
    return min;
}
void solve()
{
    int i, j, k, ans, minr;
    da(M + 1, 128);
    calheight(M);
    build();
    ans = 0, minr = INF;
    for(i = 0; i < N; i ++)
    {
        k = search(rank[i], rank[M - i - 1]);
        if(2 * k - 1 > ans || (2 * k - 1 == ans && i - k + 1 < minr))
            ans = 2 * k - 1, minr = i - k + 1;
        k = search(rank[i], rank[M - i]);
        if(2 * k > ans || (2 * k == ans && i - k < minr))
            ans = 2 * k, minr = i - k;
    }
    for(i = 0; i < ans; i ++)
        printf("%c", r[i + minr]);
    printf("\n");
}
int main()
{
    while(scanf("%s", b) == 1)
    {
        init();
        solve();
    }
    return 0;
}