HNCPC 2022 K：Substrings Same as Prefix（SAM 纯板子）

Posted 2023-04-08 Brightess

CSG-CPC 1199：Substrings Same as Prefix 湖南省第十八届大学生计算机程序设计竞赛（HNCPC2022）

Description
We want to know how similar the content of a string is to its prefix. A string could gain a score of k when there is a non-prefix substring of length k that is the same as its prefix. Find the total score for a string.

Input
There are 20 test cases. Each case contains a string of English letters with length n.

1 ≤ n ≤ 105

Output
Each case one line, the score of the string.

Sample Input
abcabc
aaaa
Sample Output
6
10
Hint
For the first case, “a”, “ab”, “abc” are non-prefix substrings same as prefix and the score is 1+2+3=6.

For the second case, 3 “a”s, 2 “aa”s and 1 “aaa” are non-prefix substrings same as prefix. Then the score is 3+4+3=10.

Source
湖南省第十八届大学生计算机程序设计竞赛（HNCPC2022）
Author
CSGrandeur

赛前没有好好地复习 SAM，没出这题责任在我。

题意：

多组测试数据，每次输入一个长度最大为 1e5 的字符串 s。要求算出每次输入字符串的“得分”，“得分”的定义： 当有一个长度为 k 的 非前缀子串 与 s 的 前缀 相同时，s 可以获得 k 的分数，得到的总分为 s 的“得分”。

思路：

对每次输入的原串构建后缀自动机，并在 parent 树上进行 dp，求得每个节点代表子串的出现次数，之后遍历所有前缀，把前缀放 SAM 上跑，看是否有非前缀与之匹配，算出每次的得分，累加即可得到答案。

个人感觉是这道题的变形：P5231 [JSOI2012]玄武密码

时间复杂度：$O(n)$

代码：

#include<bits/stdc++.h>

using namespace std;
const int N = 1e5 + 10, M = N << 1;
int ch[M][52], fa[M], len[M], np = 1, tot = 1;
long long cnt[M];
char s[N];
vector<int> g[M];

inline void Clear() 
	memset(ch, 0, sizeof ch);
	memset(fa, 0, sizeof fa);
	memset(len, 0, sizeof len);
	np = tot = 1;
	memset(cnt, 0, sizeof cnt);
	for (int i = 0; i < M; ++i) g[i].clear();


inline int get(char c) 	//给出的字符串可能有大写，这是个坑
	if (islower(c)) return c - 'A' - 6;
	else return c - 'A';


void extend(int c)

	int p = np; np = ++tot;
	len[np] = len[p] + 1, cnt[np] = 1;
	while (p && !ch[p][c]) 
		ch[p][c] = np;
		p = fa[p];
	
	if (!p) 
		fa[np] = 1;
	
	else 
		int q = ch[p][c];
		if (len[q] == len[p] + 1) 
			fa[np] = q;
		
		else 
			int nq = ++tot;
			len[nq] = len[p] + 1;
			fa[nq] = fa[q], fa[q] = fa[np] = nq;
			while (p && ch[p][c] == q) 
				ch[p][c] = nq;
				p = fa[p];
			
			memcpy(ch[nq], ch[q], sizeof ch[q]);
		
	


void dfs(int u)

	for (auto son : g[u]) 
		dfs(son);
		cnt[u] += cnt[son];
	


inline void solve()

	for (int i = 0; s[i]; ++i) extend(get(s[i]));
	for (int i = 2; i <= tot; ++i) 
		g[fa[i]].emplace_back(i);
	
	dfs(1);
	int p = 1;
	long long sum = 0;
	for (int i = 0; s[i]; ++i) 
		auto c = get(s[i]);
		p = ch[p][c];
		sum += (cnt[p] - 1) * (i + 1);
	
	printf("%lld\\n", sum);


signed main()

	while (~scanf("%s", s)) 
		Clear();
		solve();
	

	return 0;

2019HNCPC C Distinct Substrings 后缀自动机

题意

给定一个长度为n字符串，字符集大小为m(1<=n,m<=1e6)，求\(\bigoplus_c = 1^m\left(h(c) \cdot 3^c \bmod (10^9+7)\right)\)的值。其中h(c)为将c加到字符串末尾产生的新的本质不同的子串数目。

解题思路

比赛的时候没做出来，颁奖的时候听lts和lsx讲了之后发现可以用SAM做，而且板子稍微改改就可以了。

具体就是每次添加一个字符最多新建2个节点，根据SAM的性质，添加c后新建节点对本质不同的子串的数目的贡献就是h(c)，用len[i]-len[link[i]]就能算出来。

现场赛的时候我一直没想到添加结点之后要怎么把这个结点再删掉，没有立刻想出来，然后就去做D数位DP了，但是其实很简单，可以把extend函数改一改，对于询问只算答案不修改原来的节点，这样就不需要删除；或者用一个容器记录修改了哪一些结点，询问完了再遍历一遍改回去。这两种方法应该都是\(O(1)\)修改的。

代码实现

和叉姐的标程对拍没有出错，应该是对的吧

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int maxn=1e6+5;
const int mod=1e9+7;

struct Suffix_Automaton
    struct state
        int len,link;
        map<int,int>next;
    st[maxn<<1];
    int last,tot;
    
    int sz;
    
    void init()
        st[1].len=0;st[0].link=0;
        st[1].next.clear();
        last=tot=1;;
    
    int newnode()
        ++tot;
        st[tot].len=st[tot].link=0;
        st[tot].next.clear();
        return tot;
    
    void extend(int c)
        int p=last;
        int cur=newnode();
        st[cur].len=st[last].len+1;
        last=cur;
        while(p && !st[p].next.count(c))
            st[p].next[c]=cur;
            p=st[p].link;
        
        if(!p)st[cur].link=1;
        else
            int q=st[p].next[c];
            if(st[p].len+1==st[q].len)st[cur].link=q;
            else
                int clone=newnode();
                st[clone].len=st[p].len+1;
                st[clone].next=st[q].next;
                st[clone].link=st[q].link;
                st[q].link=st[cur].link=clone;
                while(st[p].next[c]==q)
                    st[p].next[c]=clone;
                    p=st[p].link;
                
            
        
    
    ll solve(int c)
        ll res=0;
        
        int p=last;
        int cur=newnode();
        st[cur].len=st[last].len+1;
        //last=cur;
        while(p && !st[p].next.count(c))
            //st[p].next[c]=cur;
            p=st[p].link;
        
        if(!p)
            st[cur].link=1;
            res=st[cur].len-st[st[cur].link].len;
        
        else
            int q=st[p].next[c];
            if(st[p].len+1==st[q].len)
                st[cur].link=q;
                res=st[cur].len-st[st[cur].link].len;
            
            else
                int clone=newnode();
                st[clone].len=st[p].len+1;
                //st[clone].next=st[q].next;
                st[clone].link=st[q].link;
                //while(p && st[p].next[c]==q)
                    //st[p].next[c]=clone;
                    //p=st[p].link;
                //
                //st[q].link=clone;
                st[cur].link=clone;
                
                //结点q的link变为clone，所以需要把原来的删掉再把新的加进去 
                res=((res-(st[q].len-st[st[q].link].len))%mod+mod)%mod;
                res=(res+st[q].len-st[clone].len)%mod;

                res=(res+st[cur].len-st[st[cur].link].len)%mod;
                res=(res+st[clone].len-st[st[clone].link].len)%mod;
            
        
        
        tot=sz;
        return (res%mod+mod)%mod;
    
S;
int n,m;
int main()

    while(~scanf("%d %d",&n,&m))
        S.init();
        int x;
        for(int i=1;i<=n;i++)
            scanf("%d",&x);
            S.extend(x);
        
        S.sz=S.tot;
        ll ans=0,three=1,hc;
        for(int i=1;i<=m;i++)
            three=three*3%mod;
            hc=S.solve(i);
            ans^=(1*hc*three%mod);
        
        printf("%lld\n",ans);
    
    return 0;