后缀自动机 - str2int - UVA - 1673

后缀自动机 - str2int - UVA - 1673

题意：

$$\begin{gathered} 输入n个由数字构成的字符串s_1,s_2,...,s_n，对所有字符串的所有不重复的子串所表示的有效(不含前导0)数字进行求和， \\ 将结果对2012取模。 \end{gathered}$$

Sample Input：
5
101
123
09
000
1234567890

Sample Output：
202

题解：

$$\begin{gathered} 为了避免对n个数字分别建立后缀自动机，可以将n个字符串成一整个字符串: \\ 在每个数字中间添加一个特殊分隔符，然后再对整个字符串建立后缀自动机。 \\ 这样，在树上转移的时候，不向分隔符的方向走，并且不在初始状态往0走来避免前导0，对每个子串哈希再求和即可。 \end{gathered}$$

具体落实：

$$\begin{gathered} ①、将n个串合并预处理，并建立后缀自动机。 \\ ②、设cnt[v]:从SAM的初始状态到状态v中的所有不含分隔符以及前导0的数量。 \\ sum[v]:从初始状态到状态v的所有合法路径形成的数字之和。 \\ 则cnt[v]=\sum cnt[u]，其中状态v是由状态u转移来的， \\ sum[v]=\sum sum[u]\times 10+cnt[u]\times i，其中cnt[u]是以状态u转移到状态v的子串数量，i是状态v的结尾数字。 \\ 以123423为例：转移关系如下图: \end{gathered}$$

---

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <algorithm>

using namespace std;
const int mod = 2012;
const int maxn = 2e5+1e2;
const int maxnode = maxn;
const int sigmaSize = 10;

char s[maxn];

int id(char c) { return c-'0'; }

struct SAM
{
    int n , last;
    int ch[maxnode][sigmaSize] , fa[maxnode] , mx[maxnode];
    int c[maxn] , q[maxnode];
    int sum[maxn] , cnt[maxn];

    int newNode()       { mx[++n] = 0; memset(ch[n], 0, sizeof(ch[n])); return n; }
    void init(){ mx[n = last = 1] = 0; memset(ch[1], 0, sizeof(ch[1]));           }

    void extend(int x)
    {
        int p = last , np = newNode();
        mx[last = np] = mx[p] + 1;

        while(p && !ch[p][x]) ch[p][x] = np , p = fa[p];

        if(!p) fa[np] = 1;
        else
        {
            int q = ch[p][x];
            if(mx[q] == mx[p]+1) fa[np] = q;
            else
            {
                int nq = newNode();
                mx[nq] = mx[p] + 1;
                memcpy(ch[nq], ch[q], sizeof(ch[0]));
                fa[nq] = fa[q];
                fa[q] = fa[np] = nq;

                while(p && ch[p][x] == q) ch[p][x] = nq , p = fa[p];
            }
        }
    }

    void Sort()
    {
        memset(c, 0, sizeof(int)*(n+1));
        for(int i=1;i<=n;i++) c[mx[i]]++;
        for(int i=1;i<=n;i++) c[i] += c[i-1];
        for(int i=1;i<=n;i++) q[c[mx[i]]--] = i;
    }

    int dp()
    {
        Sort();
        memset(sum, 0, sizeof(int)*(n+1));
        memset(cnt, 0, sizeof(int)*(n+1));

        sum[1] = 0; cnt[1] = 1;
        for(int i=1 , j;i<=n;i++)
        {
            j = q[i];
            for(int k=0,t;k<sigmaSize;k++)
            {
                if(j==1 && !k) continue;
                t = ch[j][k];
                (sum[t] += cnt[j]*k + sum[j]*10) %= mod;
                (cnt[t] += cnt[j])               %= mod;
            }
        }
        int res = 0;
        for(int i=1;i<=n;i++) (res += sum[i]) %= mod;
        return res;
    }
}solver;

int n;

int main()
{
    while(cin>>n)
    {
        solver.init();
        while(n--)
        {
            scanf("%s" , s);
            solver.last = 1;
            for(int i=0,j=strlen(s);i<j;i++) solver.extend(id(s[i]));
        }

        cout<<solver.dp()<<endl;
    }

    return 0;
}