HDU 4117 GRE Words (AC自动机 + 线段树优化DP) 2011年成都现场赛G题

题目大意：

就是现在给出n (n <= 20000)个单词, 每个单词由一些小写字母组成, 现在这些单词按照输入的顺序给定, 每个单词还有一个权值, 当然可能出现某个单词出现了两次, 即两个串完全一样但是多次出现, 权值还可能不同, 那么如果将这n个单词删掉一些之后, 剩下的单词满足按照原本输入的顺序排列, 上面一个是下面一个的子串, 这种删除方法是合法的, 求在所有合法的删除方案中剩下的单词的权值和最大是多少, 输入的单词总长度不超过30W

大致思路：

首先不难想到建立n个串的AC自动机, 用dp[i]表示最终剩下的串以第i个串结尾的的方案中权值和的最大值

那么dp[i] = max(dp[j] + w[i]) 1 <= j < i, dp[i]至少是0

显然如果这么直接dp的话讲所有穿建立自动机然后遍历, 直接DP时间复杂度是O(n*n + m), m是字符串总长度

那么由于n的限制, 这个方案是不接受的

于是这里需要用到fail树了, 这个题也是第一次遇到的AC自动机上利用fail树的性质的题

对于AC自动机上的L个点, 每个点只有一个fail指针, 且多个点之间的fail指针一定不会形成环(不含根节点), 那么按照fail指针的关系建立出fail树, 树上父亲节点是子节点的子串, 于是问题变成了, 对于第i个串, 当我们确定出其dp[i]时, 将其在AC自动机上对应的点标记一个值, 对于接下来的查询的次j个串, 其在AC自动机上进行遍历时经过的点和其fail树上的父亲节点代表的都是其子串, 于是问题变成, 对于一棵树上一些点已经被标记出值, 接下来会询问对于某个点, 其父亲结点中被标记出的值最大时多少

于是就变成的一个经典的用时间戳和线段树解决的问题, 建立fail树, dfs出其每个点的时间戳然后用线段树维护, 区间更新, 单点查询....祭奠一下我好久没写过的线段树...

这个做法的时间复杂度是O(m + n + mlogn)

具体细节参见代码吧(刚开始我线段树根节点顺手打成了以0开始计数...真是跪了...)

代码如下：

Result  :  Accepted     Memory  :  28436 KB     Time  :  2262 ms

/*
 * Author: Gatevin
 * Created Time:  2015/5/20 18:40:59
 * File Name: Rin_Tohsaka.cpp
 */
//防爆栈...
#pragma comment(linker, "/STACK:16777216")
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;
#define foreach(e, x) for(__typeof(x.begin()) e = x.begin(); e != x.end(); ++e)
#define SHOW_MEMORY(x) cout<<sizeof(x)/(1024*1024.)<<"MB"<<endl

struct Segment_Tree
{
    #define lson l, mid, rt << 1
    #define rson mid + 1, r, rt << 1 | 1
    int val[300010 << 2];
    bool flag[300010 << 2];//延迟标记
    void build(int l, int r, int rt)
    {
        val[rt] = flag[rt] = 0;
        if(l == r) return;
        int mid = (l + r) >> 1;
        build(lson);
        build(rson);
    }
    void pushDown(int rt)//向下更新延迟标记, 其实这题可以不用延迟标记的...
    {
        if(flag[rt])
        {
            val[rt << 1] = max(val[rt << 1], val[rt]);
            val[rt << 1 | 1] = max(val[rt << 1 | 1], val[rt]);
            flag[rt << 1] = flag[rt << 1 | 1] = 1;
            flag[rt] = 0;
            return;
        }
    }
    //将区间[L, R]中的最大值更新
    void update(int l, int r, int rt, int L, int R, int value)
    {
        if(l >= L && r <= R)
        {
            val[rt] = max(val[rt], value);
            flag[rt] = 1;
            return;
        }
        int mid = (l + r) >> 1;
        if(mid >= L) update(lson, L, R, value);
        if(mid + 1 <= R) update(rson, L, R, value);
    }
    int query(int l, int r, int rt, int pos)
    {
        if(l == r) return val[rt];
        pushDown(rt);
        int mid = (l + r) >> 1;
        if(mid >= pos) return query(lson, pos);
        if(mid + 1 <= pos) return query(rson, pos);
        return -233333333;
    }
};


struct Trie
{
    int next[300010][26], fail[300010];
    int L, root;
    int n;//字符串个数
    vector <string> V;//存储输入的字符串
    vector <int> G[300010];//存储fail树
    int left[300010], right[300010];//[left[i], right[i]]对应自动机上节点i在fail树上对应线段树的时间戳
    int w[20010];//字符串权值
    Segment_Tree seg;
    int newnode()
    {
        for(int i = 0; i < 26; i++)
            next[L][i] = -1;
        L++;
        return L - 1;
    }
    void init()
    {
        L = 0;
        root = newnode();
    }
    void insert(int id)
    {
        for(int now = root, i = 0, sz = V[id].size(); i < sz; i++)
        {
            if(next[now][V[id][i] - 'a'] == -1)
                next[now][V[id][i] - 'a'] = newnode();
            now = next[now][V[id][i] - 'a'];
        }
        return;
    }
    void build()
    {
        fail[root] = root;
        queue <int> Q;
        Q.push(root);
        while(!Q.empty())
        {
            int now = Q.front();
            Q.pop();
            for(int i = 0; i < 26; i++)
                if(next[now][i] == -1)
                    next[now][i] = now == root ? root : next[fail[now]][i];
                else
                {
                    fail[next[now][i]] = now == root ? root : next[fail[now]][i];
                    Q.push(next[now][i]);
                }
        }
        return;
    }
    int time;
    void dfs(int now)
    {
        left[now] = ++time;
        for(int i = 0, sz = G[now].size(); i < sz; i++)
            dfs(G[now][i]);
        right[now] = time;
    }
    void construct()
    {
        for(int i = 0; i < L; i++) G[i].clear();
        for(int i = 1; i < L; i++)//找出fail树
            G[fail[i]].push_back(i);
        time = 0;
        dfs(root);//得到各个节点在线段树上对应的时间戳(区间代表)
        return;
    }
    int answer()
    {
        scanf("%d", &n);
        V.clear();
        string tmp;
        init();
        for(int i = 0; i < n; i++)
        {
            cin>>tmp>>w[i];
            V.push_back(tmp);
            insert(i);
        }
        build();
        construct();
        seg.build(1, time, 1);
        int ans = 0;
        for(int i = 0; i < n; i++)
        {
            int tmp = 0;
            int now = root;
            for(int j = 0, sz = V[i].size(); j < sz; j++)
            {
                now = next[now][V[i][j] - 'a'];
                tmp = max(tmp, seg.query(1, time, 1, left[now]) + w[i]);
            }
            seg.update(1, time, 1, left[now], right[now], tmp);
            ans = max(ans, tmp);
        }
        return ans;
    }
};

Trie AC;

int main()
{
    ios::sync_with_stdio(0);
    int T;
    scanf("%d", &T);
    for(int cas = 1; cas <= T; cas++)
        printf("Case #%d: %d\n", cas, AC.answer());
    return 0;
}