【MZ】hdu 4117 AC自动机DP + 线段树优化

problem:

给你N个字符串， N(1 <= N <= 2 * 10⁴), 所有穿的长度加一起不超过 3 * 10⁵.每个串有个值。这个值[-1000， 1000].

问不打乱字符串顺序，从中取若干个字符串，使得前一个串是后一个串的子串，求满足前面调条件的字符串值得和最大，求这个值。

think:

建立AC自动机。后面检查取了以每个字符串是最后取的串的最大值。那么检查第i个字符串的时候，就是这个字符串的未节点前面所有的fail指针一直到根节点和他的上面节点的最大值，加上第i个字符串的值。直接这样暴力的话，是N*M，一定会超时的。

由于每个节点一直fail都会指向根节点，所以把他转化为一棵fail树。我们发现当改变fail树里面的一个节点时，会影响到的是他的子孙，那么就可以用时间戳来把fail树变成线性的从而可以用线段树进行优化。

可是除了fail影响一个节点的还有trie树里面的父节点。所以我们顺着所有的字符扫一遍，存一下上一个走到的结点就是他的trie树中的父节点。和fail树的线段树中比较一下就可以了。

这题建了三棵树，trie树，fail树，线段树。vetor存树耗内存，把所有long long 都改成int才从mle变成ac。

code:

const int kind = 26;
const int NN = 333333;

int cnt;//ac状态数
char str[NN];//所有的字符接在一起
int pos[NN];

int fail[NN];//每个状态的fail指针
int child[NN][kind];//trie树
int ans;//最终答案

int val[NN];//每个单词输入的value

int tal;//时间戳状态数
vector<int>v[NN];//fail树
int in[NN];//时间戳
int out[NN];
int mx[NN<<2];//线段树

inline int newNode(){
    ++cnt;
    for(int i=0; i<kind; ++i) child[cnt][i] = -1;
    return cnt;
}

void insert(char *str, int root, int id){
    int p = root;
    int len = strlen(str);
    for(int i=0; i < len; ++i){
        int k = str[i] - 'a';
        if(child[p][k] == -1) child[p][k] = newNode();
        p = child[p][k];
    }
}

void build_fail(int root){
    queue<int>q;
    int p = root;
    q.push(p);
    while(!q.empty()){
        p = q.front();
        q.pop();
        if(p) v[fail[p]].push_back(p);
        for(int k = 0; k < kind; ++k){
            int tmp = child[p][k];
            if(tmp != -1){
                if(p!=root) fail[tmp] = child[fail[p]][k];
                else fail[tmp] = root;
                q.push(tmp);
            } else {
                if(p!=root) child[p][k] = child[fail[p]][k];
                else child[p][k] = root;
            }
        }
    }
}

void dfs(int s){
    in[s] = ++tal;
    int len = v[s].size();
    for(int i = 0; i < len; ++i){
        dfs(v[s][i]);
    }
    out[s] = tal;
    v[s].clear();
}

int query(int l, int r, int k, int L){
    if(l==L && r==L) return mx[k];
    int mid = (l+r)>>1;
    mx[k<<1] = max(mx[k<<1], mx[k]);
    mx[k<<1|1] = max(mx[k<<1|1], mx[k]);
    if(L<=mid) return query(l, mid, k<<1, L);
    else return query(mid+1, r, k<<1|1, L);
}

void update(int l, int r, int k, int L, int R, int x){
    if(mx[k] >= x) return;
    if(l==L && r==R){
        mx[k] = x;
        return;
    }
    int mid = (l+r)>>1;
    if(R<=mid) update(l, mid, k<<1, L, R, x);
    else if(L>mid) update(mid+1, r, k<<1|1, L, R, x);
    else{
        update(l, mid, k<<1, L, mid, x);
        update(mid+1, r, k<<1|1, mid+1, R, x);
    }
}

int main(){
    int n, m, tt=0;
    scanf("%d", &m);
    while(m--){
        scanf("%d", &n);
        cnt = -1;
        int root = newNode();
        pos[0] = 0;
        for(int i = 1; i <= n; ++i){
            scanf("%s%d", str + pos[i-1], &val[i]);
            insert(str + pos[i-1], root, i);
            pos[i] = pos[i-1] + strlen(str + pos[i-1]);
        }
        build_fail(root);
        tal = 0;
        dfs(0);
        memset(mx, 0, sizeof(mx));
        ans = 0;
        for(int i = 1; i <= n; ++i){
            int p = 0;
            int preTmp = 0;
            for(int j = pos[i-1]; j < pos[i]; ++j){//这里虽然是两层循环，其实一共只有pos[n]
                int v = val[i] * (j==pos[i]-1);
                p = child[p][str[j]-'a'];
                int tmp = query(1, tal, 1, in[p]);
                tmp = max(preTmp, tmp) + v;
                ans = max(ans, tmp);
                update(1, tal, 1, in[p], out[p], tmp);
                preTmp = tmp;
            }
        }
        printf("Case #%d: ", ++tt);
        cout<<ans<<endl;
    }
    return 0;
}
/*
100
5
a 1
ab 2
abb 3
baba 5
abbab 8

5
a 1
b 1
ab 3
aabb 3
abb 10

2
aa 1
a 1

4
a 1
aab 10
bab 1
aabab 1

4
a 1
aab 1
bab 10
aabab 1
*/