[BZOJ4567][Scoi2016]背单词（Trie+DFS+贪心）

假设每个单词都不会出现第一种情况，那么每个单词的代价一定 ≤n ≤ n ，这时候总代价一定小于 n2 n 2 。因此第一种情况是一定不能出现的。
把每个单词变成反串，这样后缀就变成了前缀。
把反串建成一棵Trie，取出表示每个单词的节点，对于Trie上的每个节点 u u ，求一个 lstu l s t u ，表示 u u 的祖先中，作为单词末尾并且与 u u 最近的节点（可以递推得到），如果 u u 的祖先中没有这样的节点则 lstu=0 l s t u = 0 。
对于每个 u u ，让 lstu l s t u 作为 u u 的父节点，构成一棵树（森林）。
而现在就是在这棵森林中填入 1 1 到 n n 的数字，每个点填入的数字必须大于这个点的父节点填入的数字。如果一个点为根，那么这个点的代价为这个点填入的数字，否则这个点的代价等于这个点填入的数字减去这个点的父节点填入的数字。求最小的总代价。
可以新建一个虚拟节点为根，连接森林中所有树的根，形成一棵树。考虑贪心，找到一个最优的DFS序。容易想到，一个贪心地想法是先遍历点数最少的子树，再按升序遍历点数多的子树。填入数字之后，就可以计算出代价。
代码：

#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef long long ll;
const int N = 1e5 + 5, M = 51e4 + 5, L = 26, E = 2e5 + 5;
int n, l, QAQ = 1, Go[M][L], pos[N], lst[M], ecnt, nxt[E], adj[N],
go[E], cnt[N], mark[M], sze[N], T, num[N], tot, tmp[N]; ll ans;
char s[M];
bool comp(int a, int b) {
    return sze[a] < sze[b];
}
void add_edge(int u, int v) {
    nxt[++ecnt] = adj[u]; adj[u] = ecnt; go[ecnt] = v;
}
void ins(int x) {
    int i, u = 1; for (i = 1; i <= l; i++) {
        int c = s[l - i + 1] - 'a';
        if (!Go[u][c]) Go[u][c] = ++QAQ;
        u = Go[u][c];
    }
    mark[pos[x] = u] = x;
}
void dfs(int u) {
    int i, v; for (i = 0; i < 26; i++) if (Go[u][i])
        lst[v = Go[u][i]] = mark[u] ? mark[u] : lst[u],
        mark[v] ? cnt[lst[v]]++ : 0, dfs(v);
}
void dfs2(int u) {
    sze[u] = 1; for (int e = adj[u], v; e; e = nxt[e])
        dfs2(v = go[e]), sze[u] += sze[v];
}
void dfs3(int u) {
    int i, km = tot; for (int e = adj[u]; e; e = nxt[e]) tmp[++tot] = go[e];
    sort(tmp + km + 1, tmp + tot + 1, comp); num[u] = T++; int tail = tot;
    for (i = km + 1; i <= tot; i++) dfs3(tmp[i]), tot = tail;
}
int main() {
    int i; cin >> n; for (i = 1; i <= n; i++)
        scanf("%s", s + 1), l = strlen(s + 1), ins(i); dfs(1);
    for (i = 1; i <= n; i++) if (lst[pos[i]]) add_edge(lst[pos[i]], i);
    for (i = 1; i <= n; i++) if (!lst[pos[i]]) add_edge(n + 1, i);
    dfs2(n + 1); dfs3(n + 1); ll ans = 0;
    for (i = 1; i <= n; i++) ans += num[i] - num[lst[pos[i]]];
    cout << ans << endl;
    return 0;
}