HDU 4436 str2int（后缀自动机）（2012 Asia Tianjin Regional Contest）

Problem Description

In this problem, you are given several strings that contain only digits from '0' to '9', inclusive.
An example is shown below.
101
123
The set S of strings is consists of the N strings given in the input file, and all the possible substrings of each one of them.
It's boring to manipulate strings, so you decide to convert strings in S into integers.
You can convert a string that contains only digits into a decimal integer, for example, you can convert "101" into 101, "01" into 1, et al.
If an integer occurs multiple times, you only keep one of them. 
For example, in the example shown above, all the integers are 1, 10, 101, 2, 3, 12, 23, 123.
Your task is to calculate the remainder of the sum of all the integers you get divided by 2012.

 

Input

There are no more than 20 test cases.
The test case starts by a line contains an positive integer N.
Next N lines each contains a string consists of one or more digits.
It's guaranteed that 1≤N≤10000 and the sum of the length of all the strings ≤100000.
The input is terminated by EOF.

 

Output

An integer between 0 and 2011, inclusive, for each test case.

 

题目大意：计算n个串的所有子串（重复的算一个）的和，结果求余2012。

思路：把n个字符串用一个奇怪的东东（比如10）连起来，建一个后缀自动机。

由于在后缀自动机上，每一条路径到一个点，都唯一代表着一个字符串，所以重复什么的就没有了。

然后后缀自动机是一个DAG，随便搞搞就能做了。

PS：对后缀自动机熟悉的话，这题还是挺水的，是当时后缀自动机还不普及的缘故么。

 

代码（406MS）：

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;

const int MAXN = 110000 + 10;
const int MOD = 2012;
char buf[MAXN];
struct State {
    State *fail, *go[11];
    int val, dp, cnt;
    bool mark;
    /*
    State() :
            fail(0), val(0) {
        memset(go, 0, sizeof go);
    }*/
}*root, *last;
State statePool[MAXN * 2], *cur;

void init() {
    memset(statePool, 0, sizeof(statePool));
    cur = statePool;
    root = last = cur++;
}

void extend(int w) {
    State *p = last, *np = cur++;
    np->val = p->val + 1;
    while (p && !p->go[w])
        p->go[w] = np, p = p->fail;
    if (!p) np->fail = root;
    else {
        State*q = p->go[w];
        if (p->val + 1 == q->val) np->fail = q;
        else {
            State *nq = cur++;
            memcpy(nq->go, q->go, sizeof q->go);
            nq->val = p->val + 1;
            nq->fail = q->fail;
            q->fail = nq;
            np->fail = nq;
            while (p && p->go[w] == q)
                p->go[w] = nq, p = p->fail;
        }
    }
    last = np;
}

inline void update_add(int &a, const int &b) {
    a = (a + b) % MOD;
}

struct Node {
    State *p;
    bool operator < (const Node &rhs) const {
        return p->val < rhs.p->val;
    }
} a[MAXN * 2];

int main() {
    int n;
    while(scanf("%d", &n) != EOF) {
        init();
        for(int i = 1; i <= n; ++i) {
            scanf("%s", buf);
            for(char *pt = buf; *pt; ++pt)
                extend(*pt - '0');
            extend(10);
        }
        int m = 0, ans = 0;
        for(State *p = statePool; p != cur; ++p) a[m++].p = p;
        sort(a, a + m);
        root->cnt = 1;
        for(int i = 0; i < m; ++i) {
            State *pt = a[i].p;
            if(pt == root->go[0] || pt->mark) continue;
            update_add(ans, pt->dp);
            for(int j = 0; j < 10; ++j) {
                if(!pt->go[j]) continue;
                update_add(pt->go[j]->dp, 10 * pt->dp + pt->cnt * j);
                update_add(pt->go[j]->cnt, pt->cnt);
            }
            if(pt->go[10]) pt->go[10]->mark = true;
        }
        printf("%d
", ans);
    }
}