Codeforces 17E Palisection 回文自动机+邻接表

最新推荐文章于 2020-08-25 09:21:08 发布

ProLightsfxjh

最新推荐文章于 2020-08-25 09:21:08 发布

阅读量1k

点赞数 1

分类专栏：字符串：回文自动机 Codeforces Div. 2：E 算法的艺术文章标签： ACM Codeforces 回文自动机邻接表

本文链接：https://blog.csdn.net/prolightsfxjh/article/details/61017216

版权

算法的艺术同时被 3 个专栏收录

330 篇文章 313 订阅

订阅专栏

Codeforces Div. 2：E

4 篇文章 0 订阅

订阅专栏

字符串：回文自动机

1 篇文章 0 订阅

订阅专栏

In an English class Nick had nothing to do at all, and remembered about wonderful strings called palindromes. We should remind you that a string is called a palindrome if it can be read the same way both from left to right and from right to left. Here are examples of such strings: «eye», «pop», «level», «aba», «deed», «racecar», «rotor», «madam».

Nick started to look carefully for all palindromes in the text that they were reading in the class. For each occurrence of each palindrome in the text he wrote a pair — the position of the beginning and the position of the ending of this occurrence in the text. Nick called each occurrence of each palindrome he found in the text subpalindrome. When he found all the subpalindromes, he decided to find out how many different pairs among these subpalindromes cross. Two subpalindromes cross if they cover common positions in the text. No palindrome can cross itself.

Let's look at the actions, performed by Nick, by the example of text «babb». At first he wrote out all subpalindromes:

• « b» — 1..1 • « bab» — 1..3 • « a» — 2..2 • « b» — 3..3 • « bb» — 3..4 • « b» — 4..4

Then Nick counted the amount of different pairs among these subpalindromes that cross. These pairs were six:

1. 1..1 cross with 1..3 2. 1..3 cross with 2..2 3. 1..3 cross with 3..3 4. 1..3 cross with 3..4 5. 3..3 cross with 3..4 6. 3..4 cross with 4..4

Since it's very exhausting to perform all the described actions manually, Nick asked you to help him and write a program that can find out the amount of different subpalindrome pairs that cross. Two subpalindrome pairs are regarded as different if one of the pairs contains a subpalindrome that the other does not.

Input

The first input line contains integer n (1 ≤ n ≤ 2·106) — length of the text. The following line contains n lower-case Latin letters (from ato z).

Output

In the only line output the amount of different pairs of two subpalindromes that cross each other. Output the answer modulo 51123987.

   Examples 
 
     input 
   
4
babb

     output 
   
6

     input 
   
2
aa

     output 
   
2

Source

Codeforces Beta Round #17

My Solution

题意：给出一个字符串要求找出多少对有相交部分的回文子串。

回文自动机+邻接表

首先，直接求这个问题比较麻烦，故可以转化为总的回文子串的对数减掉不相交的回文子串的对数。

故先预处理出suml[i]表示从左到到，0~i-1内的回文子串的个数，

然后倒的再建一个自动机，每次 lesr = num[last]表示插入这个字符以后以这个字符结尾的回文子串的个数，然后 suml[i] * lesr就是此时的不相交的回文子串的对数，

然后对于每个i都求出不相交的回文子串的对数，然后总对数减去这个即可。

之后就是超内存的问题了，nxt[MAXN][CHAR_SIZE]太大了，本来没有注意，超内存了以后算了一下原始的自动机需要200多MB内存，但这里只给了100多MB，

然后试了 map<pair<int, int>, int> nxt;然后超时了(┬＿┬)，

后来算了下用map之后变成了O(nlogn)，但这里n比较大有2e6，所以nlogn大概不算其它常数就有4e7，确实超时，所以要几乎O(n)才行。

所以上了邻接表，虽然不快，但比map要快，比普通的nxt[MAXN][CHAR_SIZE]省了很多内存。

复杂度略大于O(n)

#include <iostream>
#include <cstdio>
#include <string>
#include <map>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
typedef pair<int, int> ii;
const int MAXN = 2e6 + 8;
const int CHAR_SIZE = 26;
const int MOD = 51123987;
//244,14MB..
struct link_list{
    int u[MAXN], v[MAXN], nxt[MAXN], head[MAXN], tot, i;
    void _clear(){
        memset(head, -1, sizeof head);
        tot = 0;
    }
    void _clear(int x){head[x] = -1; }
    int get(int x, int y){
        for(i = head[x]; i != -1; i = nxt[i]){
            if(u[i] == y) return v[i];
        }
        return 0;
    }
    void  _insert(int x, int y, int z){
        u[tot] = y, v[tot] = z;
        nxt[tot] = head[x];
        head[x] = tot++;
    }
};

struct PAM{
    link_list nxt;
    int fail[MAXN];
    int num[MAXN], len[MAXN], S[MAXN];
    int last, n, p;
    int newnode(int l){
        nxt._clear(p);
        num[p] = 0, len[p] = l;
        return p ++;
    }
    void init(){
        p = 0;
        newnode(0); newnode(-1);
        last = n = 0;
        S[n] = -1;
        fail[0] = 1;
    }
    int get_fail(int x){
        while(S[n -len[x] - 1] != S[n]) x= fail[x];
        return x;
    }
    int add(int c){
        S[++n] = c;
        int cur = get_fail(last);
        if(!nxt.get(cur, c)){
            int now = newnode(len[cur] + 2);
            fail[now] = nxt.get(get_fail(fail[cur]), c);
            nxt._insert(cur, c, now);
            num[now] = num[fail[now]] + 1;
        }
        last = nxt.get(cur, c);
        //cnt[last]++;
        return num[last];
    }
    void _count(){
        ;//for(int i = p - 1; i >= 0; i--) cnt[fail[i]] += cnt[i];
    }
} pam;

string s;
LL suml[MAXN];

inline LL mod(const LL x)
{
    return x - x / MOD * MOD;
}
int main()
{
    #ifdef LOCAL
    freopen("16.in", "r", stdin);
    //freopen("16.out", "w", stdout);

    #endif // LOCAL
    ios::sync_with_stdio(false); cin.tie(0);

    LL n, i, ans = 0, nocross = 0, lesr;
    cin >> n >> s;
    pam.init();
    for(i = 0; i < n; i++){
        suml[i+1] = mod(suml[i] + pam.add(s[i] - 'a')); //1 ~ n based
        //cout << suml[i+1] << endl;
    }
    pam.init(); lesr = 0; pam.nxt._clear();
    for(i = n - 1; i >= 0; i--){
        lesr = pam.add(s[i] - 'a');
        nocross = mod(nocross + mod(lesr * suml[i]));
        //cout << nocross<<endl;
    }
    ans = mod(mod(suml[n] * (suml[n] - 1) / 2) - nocross);
    while(ans < 0) ans += MOD;
    cout << ans << endl;
    return 0;
}

Thank you!

------from ProLights