HDU4117 GRE WORDS(AC自动机+线段树维护fail树的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
a 1
ab 2
abb 3
baba 5
abbab 8

Sample Output

Case #1: 14

---

题解：

给定n个字符串，要求按顺序取一些字符串，满足后一个字符串是前一个字符串的子串，要求使得取出的权值和最大。

题目类似一般的DP问题，项最长上升子序列，只不过把上升的要求改成了是前一个的子串，权重也发生了改变 。

判断子串关系，我们用AC 自动机。

我们把AC自动机的fail指针拿出来建立一棵树，然后在求这棵树的dfs序，对于每个点，我所能得到的最大权值一定是该点到root的所有权值。然后我们对每个点的in[x],和out[x]之间的dfs序去更新。

每次取最大值即可

参考代码：

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