ACdream 1104 瑶瑶想找回文串（SplayTree + Hash + 二分）

Problem Description

刚学完后缀数组求回文串的瑶瑶（tsyao）想到了另一个问题：如果能够对字符串做一些修改，怎么在每次询问时知道以某个字符为中心的最长回文串长度呢？因为瑶瑶整天只知道LOL，当他知道自己省选成绩的时候就天天在LOL，导致现在的她实在是太弱了，根本解决不了这个问题，于是就来找你帮忙，么么哒~你就帮帮她吗

Input

第一行为一个长度不超过100000字符串s作为初始字符串。第二行一个正整数n，表示操作/询问的个数。接下来n行，每行有如下几种可能出现的操作/询问：

Insert a x  在a处字符的后面插入一个字符x

Delete a  把a处字符删除

Update a x 把a处字符改为x

Query a 查询以a为中心的最长回文串长度

Output

对于每个询问，输出得到的最长回文串长度

题目大意：略。

思路：

——————————————————————————————————————————————————————————

搬一下官方（？）题解：http://tsyao.tk/archives/94

SPLAY保存改区间从左向右的hash值和从右向左的hash值，对于每个询问，二分字符串长度。总的时间复杂度是O(qlognlogn)

——————————————————————————————————————————————————————————

处理技巧：头尾加上一个空字符可以不用考虑边界的情况。

代码（1932MS）：

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

const int MAXN = 150010;
const int MOD = 1e8 + 7;
const LL seed = 131;

LL base[MAXN];
char s[MAXN], op[10];
int n, m;

void initBase(int n = 150000) {
    base[0] = 1;
    for(int i = 1; i <= n; ++i) base[i] = base[i - 1] * seed % MOD;
}

struct SplayTree {
    struct Node {
        int size, lhash, rhash;
        char c;
        Node *fa, *ch[2];
    };
    Node statePool[MAXN], *nil, *root;
    int stk[MAXN], top;
    int ncnt;

    SplayTree() {
        nil = statePool;
    }

    void init() {
        ncnt = 1;
        top = 0;
    }

    Node* new_node(char v, Node* f) {
        Node* t;
        if(top) t = &statePool[stk[--top]];
        else t = &statePool[ncnt++];
        t->size = 1;
        t->lhash = t->rhash = t->c = v;
        t->ch[0] = t->ch[1] = nil;
        t->fa = f;
        return t;
    }

    void del_node(Node* &x) {
        stk[top++] = x - statePool;
        x = nil;
    }

    void update(Node* x) {
        int s0 = x->ch[0]->size, s1 = x->ch[1]->size;
        x->size = s0 + s1 + 1;
        x->lhash = (x->ch[0]->lhash * base[s1 + 1] + x->c * base[s1] + x->ch[1]->lhash) % MOD;
        x->rhash = (x->ch[1]->rhash * base[s0 + 1] + x->c * base[s0] + x->ch[0]->rhash) % MOD;
    }

    void rotate(Node* x) {
        Node* y = x->fa;
        int t = (y->ch[1] == x);
        y->fa->ch[y->fa->ch[1] == y] = x; x->fa = y->fa;
        y->ch[t] = x->ch[t ^ 1]; x->ch[t ^ 1]->fa = y;
        x->ch[t ^ 1] = y; y->fa = x;
        update(y);
    }

    void splay(Node* x, Node* f) {
        while(x->fa != f) {
            if(x->fa->fa == f) rotate(x);
            else {
                Node *y = x->fa, *z = y->fa;
                if((z->ch[1] == y) == (y->ch[1] == x)) rotate(y);
                else rotate(x);
                rotate(x);
            }
        }
        update(x);
        if(x->fa == nil) root = x;
    }

    Node* kth(int k) {
        Node* x = root;
        while(true) {
            int t = x->ch[0]->size + 1;
            if(t == k) break;
            if(t > k) x = x->ch[0];
            else x = x->ch[1], k -= t;
        }
        return x;
    }

    void build(Node* &x, Node* f, int l, int r) {
        int mid = (l + r) >> 1;
        x = new_node(s[mid], f);
        if(l < mid) build(x->ch[0], x, l, mid - 1);
        if(mid < r) build(x->ch[1], x, mid + 1, r);
        update(x);
    }

    void insert(int pos, char c) {
        splay(kth(pos), nil);
        splay(kth(pos + 1), root);
        root->ch[1]->ch[0] = new_node(c, root->ch[1]);
        update(root->ch[1]); update(root);
    }

    void modify(int pos, char c) {
        splay(kth(pos), nil);
        root->c = c;
        update(root);
    }

    void remove(int pos) {
        splay(kth(pos - 1), nil);
        splay(kth(pos + 1), root);
        del_node(root->ch[1]->ch[0]);
        update(root->ch[1]); update(root);
    }

    bool check(int pos, int len) {
        splay(kth(pos - len - 1), nil);
        splay(kth(pos + len + 1), root);
        splay(kth(pos), root->ch[1]);
        Node* x = root->ch[1]->ch[0];
        return x->lhash == x->rhash;
    }

    int query(int pos) {
        int l = 1, r = min(pos - 2, root->size - 1 - pos) + 1;
        while(l < r) {
            int mid = (l + r) >> 1;
            if(check(pos, mid)) l = mid + 1;
            else r = mid;
        }
        return 2 * l - 1;
    }

    void debug(Node* x) {
        static int t = 0;
        if(x == root) printf("Debug %d
", ++t);
        printf("val:%d lson:%d rson:%d lhash:%d rhash:%d
", x - statePool, x->ch[0] - statePool, x->ch[1] - statePool, x->lhash, x->rhash);
        if(x->ch[0] != nil) debug(x->ch[0]);
        if(x->ch[1] != nil) debug(x->ch[1]);
    }
} splay;

int main() {
    scanf("%s", s + 1);
    n = strlen(s + 1);
    initBase();
    splay.init();
    splay.build(splay.root, splay.nil, 0, n + 1);
    scanf("%d", &m);
    char c;
    for(int i = 0, a; i < m; ++i) {
        scanf("%s%d", op, &a);
        ++a;
        if(strcmp(op, "Insert") == 0) {
            scanf(" %c", &c);
            splay.insert(a, c);
        }
        if(strcmp(op, "Delete") == 0)
            splay.remove(a);
        if(strcmp(op, "Update") == 0) {
            scanf(" %c", &c);
            splay.modify(a, c);
        }
        //splay.debug(splay.root);
        if(strcmp(op, "Query") == 0)
            printf("%d
", splay.query(a));
    }
}