牛客网2019多校第四场 I-string 后缀数组+回文自动姬

牛客网2019多校第四场 I-string 后缀数组+回文自动姬

题目大意

做到现在的题，感觉牛客的题目是最最最直白的，这题题面没有背景故事，直奔主题。
给我们一个字符串，找到一个子串集合，集合内的子串两两不同（a != b），同时两两不互逆（即倒置其中一个串后等于另一个串，rev(a) != b），询问满足要求的集合最大能包含多少元素。

思路

一旦询问子串个数之类的题目，第一时间就想到自动姬家族。如果想要输出所有不相同的子串，我们可以直接套后缀数组，遍历一遍height数组算答案。但是这里要求不仅是a != b，同时要求a != rev(b)。我们能够想到将原串str变成str + '{' + rev(str)（’{’ 可换为任意题目给出字符集中不存在的字符），然后再进行后缀数组或广义后缀自动姬的操作，对这个串进行本质不同并不包含'{'子串的计数。这样得到的计数是 str本质不同字符串的集合∪rev(str)本质不同字符串集合 的元素个数。例如abac转为abac{caba，然后进行计数，手推枚举计数中包含的子串：a, ab, aba, abac, ac, b, ba, bac, c, ca, cab, caba，共12个。仔细观察能够发现原串的回文串只会在其中出现一次，但是其他的串会正反各出现一次。如果我们想要得到最终答案，则需要将原串所有本质不同的回文串数回来。最终得到一个集合：
a, a, b, b, c, c, ac, ca, ba, ab, cab, bac, aba, aba, abac, caba
为了让大家看得更清楚，我将其排了一下序，会发现每个字符串正反各出现了一次，那么距离我们最终答案就差一个除与2了，nice~

AC代码

#include <bits/stdc++.h>

typedef long long ll;
using namespace std;

const int CHAR_MAXN = 128;
const int MAXN = 4e5 + 10;

char str[MAXN];
int last, tot;
ll cnt = 0;//统计不同回文串的个数，即等同于回文树的节点数-1（不包括0节点）
struct Pam {

    /**
     * 对应串的长度
     */
    int len;
    /**
     * 失配节点
     */
    int fail;
    /**
     * 子节点
     */
    int son[CHAR_MAXN];

    /**
     * 是否被访问过
     */
    bool vis;

} pam[MAXN];

/**
 * 初始化
 */
void init() {
    memset(pam, 0, sizeof(pam));
    pam[0].len = 0;
    pam[0].fail = 1;
    pam[1].len = -1;
    tot = 2;
    cnt = 0;
}

/**
 * 获取从now节点开始匹配到尾缀为str[index]回文串的节点
 * @param now 待匹配节点
 * @param index 匹配字符串的下标
 * @return 匹配节点编号
 */
int get(int now, int index) {
    while (str[index] != str[index - pam[now].len - 1])
        now = pam[now].fail;
    return now;
}

/**
 * 添加一个str中index位置上的字符，更新回文树
 * @param index 指定字符位置
 */
void add(int index) {
    int u = get(last, index);
    int ch = str[index] - 'a';
    if (pam[u].son[ch] == 0) {
        int v = tot++;
        pam[v].len = pam[u].len + 2;
        pam[v].fail = pam[get(pam[u].fail, index)].son[ch];
        pam[u].son[ch] = v;
        cnt++;
    }

    //更新上次访问节点
    last = pam[u].son[ch];
}

int SA[MAXN], myRank[MAXN], height[MAXN], sum[MAXN], tp[MAXN];
//rank[i] 第i个后缀的排名, SA[i] 排名为i的后缀的位置, Height[i] 排名为i的后缀与排名为(i-1)的后缀的LCP
//sum[i] 基数排序辅助数组, 存储小于i的元素有多少个, tp[i] rank的辅助数组(按第二关键字排序的结果),与SA意义一样

bool cmp(const int *f, int x, int y, int w) {
    return f[x] == f[y] && f[x + w] == f[y + w];
}

void get_SA(const char *s, int n, int m) {
    //先预处理长度为1的情况
    for (int i = 0; i < m; i++) sum[i] = 0;//清0
    for (int i = 0; i < n; i++) sum[myRank[i] = s[i]]++;//统计每个字符出现的次数
    for (int i = 1; i < m; i++) sum[i] += sum[i - 1];//sum[i]为小于等于i的元素的数目
    for (int i = n - 1; i >= 0; i--) SA[--sum[myRank[i]]] = i;//下标从0开始,所以先自减
    //SA[i]存储排名第i的后缀下标,SA[--sum[rank[i]]] = i 即下标为i的后缀排名为--sum[rank[i]],这很显然
    for (int len = 1; len <= n; len *= 2) {
        int p = 0;
        //直接用SA数组对第二关键字排序
        for (int i = n - len; i < n; i++) tp[p++] = i;//后面i个数没有第二关键字,即第二关键字为空,所以最小
        for (int i = 0; i < n; i++) {
            if (SA[i] >= len) tp[p++] = SA[i] - len;
        }
        //tp[i]存储按第二关键字排序第i的下标
        //对第二关键字排序的结果再按第一关键字排序,和长度为1的情况类似
        for (int i = 0; i < m; i++) sum[i] = 0;
        for (int i = 0; i < n; i++) sum[myRank[tp[i]]]++;
        for (int i = 1; i < m; i++) sum[i] += sum[i - 1];
        for (int i = n - 1; i >= 0; i--) SA[--sum[myRank[tp[i]]]] = tp[i];
        //根据SA和rank数组重新计算rank数组
        swap(myRank, tp);//交换后tp指向旧的rank数组
        p = 1;
        myRank[SA[0]] = 0;
        for (int i = 1; i < n; i++) {
            myRank[SA[i]] = cmp(tp, SA[i - 1], SA[i], len) ? p - 1 : p++;//注意判定rank[i]和rank[i-1]是否相等
        }
        if (p >= n) break;
        m = p;//下次基数排序的最大值
    }
    //求height
    int k = 0;
    n--;
    for (int i = 0; i <= n; i++) myRank[SA[i]] = i;
    for (int i = 0; i < n; i++) {
        if (k) k--;
        int j = SA[myRank[i] - 1];
        while (s[i + k] == s[j + k]) k++;
        height[myRank[i]] = k;
    }
}

int main() {
#ifdef ACM_LOCAL
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    auto start_____ = clock();
#endif
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    cin >> str;
    ll len = strlen(str);
    str[len] = '{';
    for (ll i = len + 1; i < len * 2 + 1; i++)
        str[i] = str[2 * len - i];
    str[2 * len + 1] = 0;
    len = strlen(str) + 1;
    get_SA(str, len, CHAR_MAXN);
    ll mid = len / 2 - 1;
    ll ans = 0;
    len = strlen(str);
    //求出所有不同子串个数
    for (ll i = 1; i <= len; i++) {
        if (mid >= SA[i])
            ans += max(mid - SA[i] - height[i], 0LL);
        else
            ans += max(len - SA[i] - height[i], 0LL);
    }

    init();
    for (ll i = 0; i < len / 2; i++) {
        add(i);
    }

    cout << (ans + cnt) / 2 << endl;

#ifdef ACM_LOCAL
    auto end_clock_for_debug = clock();
    cerr << "Run Time: " << double(end_clock_for_debug - start_____) / CLOCKS_PER_SEC << "s" << endl;
#endif
    return 0;
}

当时比赛的时候没有时间看这个题，而且那个时候还没开始字符串专题的学习。赛后补题的时候，思路不太清晰，看了题解，emmm，题解NB~
实现途径有多种，本质不同的部分可以用后缀自动机或后缀数组（推荐后缀数组，但是后缀自动机也很重要），回文串部分可以用回文自动机或马拉车+后缀数组（后一种方法是看题解上有的，题解也推荐回文自动机），几乎有四种不同的方法可以写这道题。
这个题目属于中上难度，有了思路随便写都能过（毕竟只是套两个板子），就怕没思路，嘤嘤嘤。