[bzoj4567][Scoi2016][背单词] (贪心+trie树)

Description

Lweb 面对如山的英语单词，陷入了深深的沉思，“我怎么样才能快点学完，然后去玩三国杀呢？”。这时候睿智

的凤老师从远处飘来，他送给了 Lweb 一本计划册和一大缸泡椒，他的计划册是长这样的：

—————

序号  单词

—————

 1

 2

……

n-2

n-1

 n

—————

 

然后凤老师告诉 Lweb ，我知道你要学习的单词总共有 n 个，现在我们从上往下完成计划表，对于一个序号为 x 

的单词（序号 1...x-1 都已经被填入）：

1) 如果存在一个单词是它的后缀，并且当前没有被填入表内，那他需要吃 n×n 颗泡椒才能学会；

2) 当它的所有后缀都被填入表内的情况下，如果在 1...x-1 的位置上的单词都不是它的后缀，那么你吃 x 颗泡

椒就能记住它；

3) 当它的所有后缀都被填入表内的情况下，如果 1...x-1的位置上存在是它后缀的单词，所有是它后缀的单词中

，序号最大为 y ，那么你只要吃 x-y 颗泡椒就能把它记住。

Lweb 是一个吃到辣辣的东西会暴走的奇怪小朋友，所以请你帮助 Lweb ，寻找一种最优的填写单词方案，使得他

记住这 n 个单词的情况下，吃最少的泡椒。

 

Input

输入一个整数 n ，表示 Lweb 要学习的单词数。接下来 n 行，每行有一个单词（由小写字母构成，且保证任意单

词两两互不相同）1≤n≤100000, 所有字符的长度总和 1≤|len|≤510000

 

Output

 Lweb 吃的最少泡椒数

 

Sample Input

2 
a 
ba

Sample Output

2

Solution

可以利用后缀的性质将所有字符串反过来建字典树

那么求最优填词方案也就是求代价最小的访问序，即一个最优的dfs序，这样就可以去掉第一种吃泡椒的方案，因为代价太大

可以证明，优先访问单词数量小的子树更优，满足贪心性质

这样就解出了此题

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define MaxN 100010
#define MaxL 500010
namespace io{
#define MaxBuf 1<<22
#define Blue() ((S==T&&(T=(S=B)+fread(B,1,MaxBuf,stdin),S==T))?0:*S++)
    char B[MaxBuf],*S=B,*T=B;
    template<class Type>inline void Rin(Type &x){
        x=0;int c=Blue();
        for(;c<48||c>57;c=Blue())
            ;
        for(;c>47&&c<58;c=Blue())
            x=(x<<1)+(x<<3)+c-48;
    }
    inline void geTc(char *C,int &x){
        x=0;char c=Blue();
        for(;c<'a'||c>'z';c=Blue())
            ;
        for(;c>='a'&&c<='z';c=Blue())
            *C++=c,x++;
    }
}
int n;
char s[MaxL];
long long ans(0LL);
class Trie{
public:
    int ch[MaxL][26],tot;
    bool val[MaxL];
    Trie(){
        tot=1;
        memset(ch,0,sizeof ch);
        memset(val,false,sizeof val);
    }
    inline void insert(char *C,int len){
        int now=1;
        for(int i=len-1;~i;i--){
            if(!ch[now][C[i]-'a'])
                ch[now][C[i]-'a']=++tot;
            now=ch[now][C[i]-'a'];
        }
        val[now]=true;
    }
}T;
namespace DFS{
    int sz[MaxN],q[MaxN],top;
    struct Pointer{
        int to;
        Pointer *next;
    }*fir[MaxN];
    inline void link(int x,int y){
        static Pointer mem[MaxN],*tot=mem;
        *++tot=(Pointer){y,fir[x]},fir[x]=tot;
    }
    void _dfs(int at,int fa){
        static int timer=1;
        if(T.val[at]){
            link(fa,++timer);
            sz[fa=timer]=1;
        }
        for(int i=0;i<26;i++)
            if(T.ch[at][i])
                _dfs(T.ch[at][i],fa);
    }
    void maintain(int at){
        for(Pointer *iter=fir[at];iter;iter=iter->next){
            maintain(iter->to);
            sz[at]+=sz[iter->to];
        }
    }
    bool cmp(int x,int y){
        return sz[x]<sz[y];
    }
    void calc(int at,int pre){
        static int timer;
        timer++;
        ans+=timer-pre;
        pre=timer;
        int l=top+1,r=top;
        for(Pointer *iter=fir[at];iter;iter=iter->next)
            q[++r]=iter->to;
        std::sort(q+l,q+1+r,cmp);
        top=r;
        for(int i=l;i<=r;i++)
            calc(q[i],pre);
        top=l-1;
    }
}
int main(){
    io::Rin(n);
    for(int i=1,len;i<=n;i++){
        io::geTc(s,len);
        T.insert(s,len);
    }
    DFS::_dfs(1,1);
    DFS::maintain(1);
    DFS::calc(1,1);
    printf("%lld\n",ans);
    return 0;
}