HDU4117 GRE WORDS (AC + segment tree automaton tree fail to maintain order dfs)

Recently George is preparing for the Graduate Record Examinations (GRE for short). Obviously the most important thing is reciting the words.
Now George is working on a word list containing N words.
He has so poor a memory that it is too hard for him to remember all of the words on the list. But he does find a way to help him to remember. He finds that if a sequence of words has a property that for all pairs of neighboring words, the previous one is a substring of the next one, then the sequence of words is easy to remember.
So he decides to eliminate some words from the word list first to make the list easier for him. Meantime, he doesn't want to miss the important words. He gives each word an importance, which is represented by an integer ranging from -1000 to 1000, then he wants to know which words to eliminate to maximize the sum of the importance of remaining words. Negative importance just means that George thought it useless and is a waste of time to recite the word.
Note that although he can eliminate any number of words from the word list, he can never change the order between words. In another word, the order of words appeared on the word list is consistent with the order in the input. In addition, a word may have different meanings, so it can appear on the list more than once, and it may have different importance in each occurrence.

InputThe first line contains an integer T(1 <= T <= 50), indicating the number of test cases.
Each test case contains several lines.
The first line contains an integer N(1 <= N <= 2 * 10 ⁴), indicating the number of words.
Then N lines follows, each contains a string S _i and an integer W _i, representing the word and its importance. S _i contains only lowercase letters.
You can assume that the total length of all words will not exceeded 3 * 10 ⁵.OutputFor each test case in the input, print one line: "Case #X: Y", where X is the test case number (starting with 1) and Y is the largest importance of the remaining sequence of words.Sample Input

1 
5 
1 
b 2 
er 3 
baby 5 
abbab 8

Sample Output

Case #1: 14

---

answer:

Given n strings required in order to take some string, the substring is satisfied before a string of a string, so that the requirements and maximum weights taken.

Similar problems DP general subject, increase the longest entry sequence, but the rising requirement is changed before a substring, the weight also changed.

Judgment substring relationship, we use AC automaton.

We fail pointer AC automaton out to establish a tree, then in seeking the tree dfs sequence, for each point, the maximum weight I can get to that point must be the root of ownership value. Then dfs between us in order for each point [x], and out [x] to update.

Can each take the maximum value

Reference Code:

#include<cstdio> 
#include<cstring> 
#include<algorithm> 
#include<iostream> 
#include<queue> 
using namespace std; 
typedef long long LL; 
const int maxn=3e5+5; 
int cnt,root,n,kase,w[20000+5],pos[20000+5]; 
int INDEX,in[maxn],out[maxn]; 
char s[maxn]; 
int fail[maxn]; 
int S[maxn*4],tag[maxn*4],MAX,L,R; 
int st[maxn],tot; 
struct edge { 
    int v,nxt; 
}v[maxn*2]; 
inline void addedge(int x,int y) 
{ 
    v[tot]=(edge){y,st[x]}; 
    st[x]=tot++; 
} 
struct node { 
int nxt[26],cnt; 
}T[maxn]; 
inline int newnode() 
{ 
    cnt++; memset(T[cnt].nxt,0,sizeof(T[cnt].nxt)); 
    T[cnt].cnt=0; fail[cnt]=0; 
    return cnt; 
} 
inline void insert(char *s) 
{ 
    int now=root; int i=0; 
    while(s[i]) 
    { 
        if(!T[now].nxt[s[i]-'a'])T[now].nxt[s[i]-'a']=newnode(); 
        now=T[now].nxt[s[i]-'a']; i++; 
    } 
    T[now].cnt++; 
} 
queue<int>Q; 
inline void build() 
{ 
    Q.push(root); 
    while(!Q.empty()) 
    { 
        int k=Q.front(); Q.pop(); 
        if(k!=root)addedge(fail[k],k); 
        for(int i=0;i<26;++i) 
        { 
            if(!T[k].nxt[i]){T[k].nxt[i]=T[fail[k]].nxt[i];continue;} 
            if(k!=root) 
                fail[T[k].nxt[i]]=T[fail[k]].nxt[i]; 
            Q.push(T[k].nxt[i]); 
        } 
    } 
} 
inline void DFS(int u,int fa) 
{ 
    in[u]=++INDEX; 
    for(int i=st[u];~i;i=v[i].nxt) 
        if(v[i].v!=fa) DFS(v[i].v,u); 
    out[u]=INDEX; 
} 
inline void update(int k) 
{ 
    S[k]=max(S[k<<1],S[k<<1|1]); 
} 
inline void down(int k) 
{ 
    if(!tag[k])return ; 
    tag[k<<1]=max(tag[k<<1],tag[k]); 
    tag[k<<1|1]=max(tag[k<<1|1],tag[k]); 
    S[k<<1]=max(S[k<<1],tag[k]); 
    S[k<<1|1]=max(S[k<<1|1],tag[k]); tag[k]=0; 
} 
inline int ask(int l,int r,int k) 
{ 
    if(L<=l&&r<=R)return S[k]; 
    int mid=(l+r)>>1; down(k); 
    int res=0; 
    if(L<=mid)res=max(res,ask(l,mid,k<<1)); 
    if(R>mid)res=max(res,ask(mid+1,r,k<<1|1)); return res; 
} 
inline void add(int l,int r,int k) 
{ 
    if(L<=l&&r<=R) 
    { 
        S[k]=max(S[k],MAX); tag[k]=max(tag[k],MAX); 
        return ; 
    } 
    int mid=(l+r)>>1; down(k); 
    if(L<=mid)add(l,mid,k<<1); 
    if(R>mid)add(mid+1,r,k<<1|1); 
    update(k); 
} 
int main() 
{ 
    int t; scanf("%d",&t); 
    while(t--) 
    { 
        scanf("%d",&n); cnt=-1; 
        root=newnode(); tot=0; 
        memset(st,-1,sizeof(st)); 
        pos[0]=0; 
        for(int i=1;i<=n;++i) 
        { 
            scanf("%s%d",s+pos[i-1],w+i); 
            pos[i]=pos[i-1]+strlen(s+pos[i-1]); 
            insert(s+pos[i-1]); 
        } 
        build(); 
        INDEX=0; 
        DFS(root,-1); 
        int ans=0; 
        memset(S,0,sizeof(S)); 
        memset(tag,0,sizeof(tag)); 
        for(int i=1;i<=n;++i) 
        { 
            MAX=0; int p=root; 
            for(int j=pos[i-1];j<pos[i];++j) 
            { 
                p=T[p].nxt[s[j]-'a']; L=in[p];R=in[p]; 
                int res=ask(1,INDEX,1); 
                MAX=max(res,MAX); 
            }
            MAX=MAX+w[i]; 
            ans=max(ans,MAX); 
            L=in[p];R=out[p]; 
            add(1,INDEX,1); 
        } 
        printf("Case #% d:% d \ n", ++ kase, years); 
    } 
    Return  0 ; 
}

View Code