P4070 [SDOI2016]生成魔咒

Posted 2021-09-09 Jozky86

P4070 [SDOI2016]生成魔咒

题意：

有n个字符xi，每次在S的末尾加入一个字符，(一开始S为空)，每次加入xi后的不相同字串有多少个

题解：

做这个题首先要会后缀数组P3809 【模板】后缀排序，还要知道不同的子串如何求P2408 不同子串个数，这两个题我都有写过博客
对于一个字符串，我们在其末尾加一个新字符，对这个字符串的height等变换还是很大的，整个格局都会被打乱(因为我们是后缀数组，在最后加，所有后缀都会改变)。但是如果我们在前面加，在最前面加字符，那只会额外产生一个新字符

原本是ABCD
后缀是：ABCD，BCD，CD，D
在末尾加个E
ABCDE
后缀变成:ABCDE,BCDE,CDE,DE,E（没有一个和之前是一样的）
如果是在开头加E
EABCD
后缀就是：EABCD,ABCD,BCD,CD,D(和原先比只多了一个EABCD，我们只需要处理新增就可以)

但是题目就是让在后面加，怎么搞？
我们可以将这个字符串翻转呀，这样每次加不就是在最前面加

原本是ABCD
翻转：DCBA
加入E
得到：EDCBA
新增后缀EDCBA，现在我们要求新增不重复字串，按照结论，后缀长度减去其height[i]

height[i]如何求？
这时，只有插入的那个新后缀紧邻的height 值发生了改变，注意到这个值是可以直接在整段字符串的后缀数组中查到的，即 lcp(prev(i),post(i)) 。
height[i]的变化是O(1)的，我们用一个set每次插入后缀排名，对于以第i位开始的后缀，其排名是rk[i],他的就找他在set中的前一位(到目前位置，已有后缀的前一项)，再找后项，两边分别取min(height[l~r])，这可以用st来实现。这就是重复部分，用长度len减去重复部分，就是后缀的贡献
详细看代码

代码：

// Problem: P4070 [SDOI2016]生成魔咒
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P4070
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Data:2021-08-23 12:42:42
// By Jozky

#include <bits/stdc++.h>
#include <unordered_map>
#define debug(a, b) printf("%s = %d\\n", a, b);
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;
clock_t startTime, endTime;
//Fe~Jozky
const ll INF_ll= 1e18;
const int INF_int= 0x3f3f3f3f;
void read(){};
template <typename _Tp, typename... _Tps> void read(_Tp& x, _Tps&... Ar)
{
    x= 0;
    char c= getchar();
    bool flag= 0;
    while (c < '0' || c > '9')
        flag|= (c == '-'), c= getchar();
    while (c >= '0' && c <= '9')
        x= (x << 3) + (x << 1) + (c ^ 48), c= getchar();
    if (flag)
        x= -x;
    read(Ar...);
}
template <typename T> inline void write(T x)
{
    if (x < 0) {
        x= ~(x - 1);
        putchar('-');
    }
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}
void rd_test()
{
#ifdef LOCAL
    startTime= clock();
    freopen("in.txt", "r", stdin);
#endif
}
void Time_test()
{
#ifdef LOCAL
    endTime= clock();
    printf("\\nRun Time:%lfs\\n", (double)(endTime - startTime) / CLOCKS_PER_SEC);
#endif
}
const int MAXN= 100005;

char ch[MAXN], all[MAXN];
int sa[MAXN], rk[MAXN], height[MAXN], tax[MAXN], tp[MAXN], a[MAXN], n, m;
char str[MAXN];
int b[MAXN];
//rk[i] 第i个后缀的排名; sa[i] 排名为i的后缀位置; height[i] 排名为i的后缀与排名为(i-1)的后缀的LCP
//tax[i] 计数排序辅助数组; tp[i] rk的辅助数组(计数排序中的第二关键字),与sa意义一样。
//a为原串
void RSort()
{
    //rk第一关键字,tp第二关键字。
    for (int i= 0; i <= m; i++)
        tax[i]= 0;
    for (int i= 1; i <= n; i++)
        tax[rk[tp[i]]]++;
    for (int i= 1; i <= m; i++)
        tax[i]+= tax[i - 1];
    for (int i= n; i >= 1; i--)
        sa[tax[rk[tp[i]]]--]= tp[i]; //确保满足第一关键字的同时，再满足第二关键字的要求
} //计数排序,把新的二元组排序。

int cmp(int* f, int x, int y, int w)
{
    return f[x] == f[y] && f[x + w] == f[y + w];
}
//通过二元组两个下标的比较，确定两个子串是否相同

void Suffix()
{
    //sa
    for (int i= 1; i <= n; i++)
        rk[i]= a[i], tp[i]= i;
    m= 127, RSort(); //一开始是以单个字符为单位，所以(m = 127)

    for (int w= 1, p= 1, i; p < n; w+= w, m= p) { //把子串长度翻倍,更新rk

        //w 当前一个子串的长度; m 当前离散后的排名种类数
        //当前的tp(第二关键字)可直接由上一次的sa的得到
        for (p= 0, i= n - w + 1; i <= n; i++)
            tp[++p]= i; //长度越界,第二关键字为0
        for (i= 1; i <= n; i++)
            if (sa[i] > w)
                tp[++p]= sa[i] - w;

        //更新sa值,并用tp暂时存下上一轮的rk(用于cmp比较)
        RSort(), swap(rk, tp), rk[sa[1]]= p= 1;

        //用已经完成的sa来更新与它互逆的rk,并离散rk
        for (i= 2; i <= n; i++)
            rk[sa[i]]= cmp(tp, sa[i], sa[i - 1], w) ? p : ++p;
    }
    //离散：把相等的字符串的rk设为相同。
    //LCP
    int j, k= 0;
    for (int i= 1; i <= n; height[rk[i++]]= k)
        for (k= k ? k - 1 : k, j= sa[rk[i] - 1]; a[i + k] == a[j + k]; ++k)
            ;
    //这个知道原理后就比较好理解程序
}
int st[MAXN][30];
void ST()
{
    for (int i= 1; i <= n; i++)
        st[i][0]= height[i];
    int w= log2(n);
    for (int k= 1; k <= w; k++) {
        for (int i= 1; i <= n; i++) {
            if (i + (1 << k) > n + 1)
                break;
            st[i][k]= min(st[i][k - 1], st[i + (1 << (k - 1))][k - 1]);
        }
    }
}
int get_min(int l, int r)
{
    int k= log2(r - l + 1);
    return min(st[l][k], st[r - (1 << k) + 1][k]);
}
void Init()
{
    read(n);
    for (int i= 1; i <= n; i++) {
        read(a[i]);
        b[i]= a[i];
    }
    sort(b + 1, b + 1 + n);
    int len= unique(b + 1, b + 1 + n) - (b + 1);
    reverse(a + 1, a + 1 + n);
    for (int i= 1; i <= n; i++) {
        a[i]= lower_bound(b + 1, b + 1 + len, a[i]) - b;
    }
}
set<int> s;

int main()
{
    Init();
    Suffix();
    ST();
    // for (int i= 1; i <= n; i++)
    // printf("height[i]=%d\\n", height[i]);
    ll ans= 0;
    for (int i= n; i; i--) { //倒序考虑
        s.insert(rk[i]);
        set<int>::iterator it;
        it= s.find(rk[i]);
        int lcp= 0;
        if (it != s.begin()) { //如果没到开头，说明前面有height，和前面取min
            int p= *(--it);
            lcp= get_min(p + 1, rk[i]);
            ++it; //还原
        }

        /*
        注意：s.begin();返回指向容器最开始位置数据的指针
		而s.end();返回指向容器最后一个数据单元+1的指针
        */
        ++it;
        if (it != s.end()) {
            int p= *it;
            lcp= max(lcp, get_min(rk[i] + 1, p));
        }
        int len= n - i + 1;
        ans+= len - lcp;
        printf("%lld\\n", ans);
    }
}