hdu 4117 GRE Words （ac自动机 线段树 dp）

参考：http://blog.csdn.net/no__stop/article/details/12287843

此题利用了ac自动机fail树的性质，fail指针建立为树，表示父节点是孩子节点的后缀

然后更新其影响的字符串的方法，即区间更新，维护最大值，用线段树优化。

而其可以影响的字符串为其在fail树中的子树节点

此题一直MLE，调了一下午+晚上。最后发现。

（1）ac自动机中的节点开始直接初始化，应动态初始化（也终于理解了许多人那么做）

（2）还有用vector表示树边时，一开始初始clear，也会耗很多内存。

（3）线段树开始直接初始化CLR（smax， 0）CLR（cov， 0），由于数组比较大，内存耗较大

最后，ac自动机节点动态初始化，用链表模拟表示树边，线段树动态build，终于有MLE变成了wa

怒重敲，终于ac了

PS:一开始使用后缀数组ac的，数据水了。。。

不过ac自动机2s+，后缀数组8s+

ac自动机：

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

#define FE(i, a, b) for(int i = (a); i <= (b); ++i)
#define FD(i, b, a) for(int i = (b); i >= (a); --i)
#define REP(i, N) for(int i = 0; i < (N); ++i)
#define CLR(a, v) memset(a, v, sizeof(a))
#define PB push_back
#define MP make_pair
typedef long long LL;
const int INF = 0x3f3f3f3f;

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

const int MAX = 333333;
const int SIG = 26;

struct Edge{
    int to, next;
}adj[MAX * 2];
int adj_cnt;
int head[MAX];
void adj_init()
{
    adj_cnt = 0;
    CLR(head, -1);
}
void add_edge(int x, int y)
{
    adj[adj_cnt].to = y;
    adj[adj_cnt].next = head[x];
    head[x] = adj_cnt++;
}

int tl[MAX], tr[MAX];
int tot;

char ca[MAX], s[MAX];
int id[MAX];
int val[MAX];

int smax[MAX << 2], cov[MAX << 2];
void update_cov(int rt, int x)
{
    smax[rt] = max(smax[rt], x);
    cov[rt] = max(cov[rt], x);
}
void up(int rt)
{
    smax[rt] = max(smax[rt << 1], smax[rt << 1 | 1]);
}
void down(int rt)
{
    if (cov[rt])
    {
        update_cov(rt << 1, cov[rt]); update_cov(rt << 1 | 1, cov[rt]);
        cov[rt] = 0;
    }
}
void build(int l, int r, int rt)///!!!
{
    smax[rt] = cov[rt] = 0;
    if (l == r) return ;
    int m = (l + r) >> 1;
    build(lson); build(rson);
    up(rt);
}
void update(int L, int R, int x, int l, int r, int rt)
{
    if (L <= l && r <= R)
    {
        update_cov(rt, x);
        return ;
    }
    down(rt);
    int m = (l + r) >> 1;
    if (L <= m) update(L, R, x, lson);
    if (R > m) update(L, R, x, rson);
    up(rt);
}
int query(int p, int l, int r, int rt)
{
    if (l == r) return smax[rt];
    down(rt);
    int m = (l + r) >> 1;
    if (p <= m) return query(p, lson);
    else return query(p, rson);
}

struct AC{
    int ch[MAX][SIG];
    int f[MAX];
    int sz;
    int newnode()///!!!
    {
        CLR(ch[sz], 0);
        return sz++;
    }
    void init()
    {
        sz = 0;
        newnode();
    }
    int idx(char c) { return c-'a'; }
    void insert(char *s)
    {
        int u=0,n=strlen(s);
        for(int i=0;i<n;i++)
        {
            int c=idx(s[i]);
            if(!ch[u][c]) ch[u][c] = newnode();
            u = ch[u][c];
        }
    }
    void getFail()
    {
        queue<int> q;
        f[0] = 0;
        for(int c = 0; c < SIG; c++)
        {
            int u = ch[0][c];
            if(u) { f[u] = 0; q.push(u); }
        }

        while(!q.empty())
        {
            int r = q.front(); q.pop();
            for(int c = 0; c < SIG; c++)
            {
                int  u = ch[r][c];
                if(!u) { ch[r][c] = ch[f[r]][c]; continue; }
                q.push(u);
                int v = f[r];
                while(v && !ch[v][c]) v = f[v];
                f[u] = ch[v][c];
            }
        }
    }
    void dfs(int u, int fa)
    {
        tl[u] = ++tot;
        for (int r = head[u]; r != -1; r = adj[r].next)
        {
            int v = adj[r].to;
            if (v != fa) dfs(v, u);
        }
        tr[u] = tot;
    }
    void makeTree()
    {
        adj_init();
        for (int i = 1; i < sz; i++)///
        {
            add_edge(i, f[i]); add_edge(f[i], i);
        }
        tot = 0;
        dfs(0, -1);
    }
    int solve(char *s)
    {
        int len = strlen(s);
        int u = 0;
        int now, ans;
        ans = now = 0;
        build(1, tot, 1);
        for (int i = 0; i < len; i++)
        {
            u = ch[u][s[i] - 'a'];
            int valu = query(tl[u], 1, tot, 1);
            now = max(now, valu);
            if (id[i])
            {
                if (val[id[i]] > 0) now += val[id[i]];
                ans = max(ans, now);
                update(tl[u], tr[u], now, 1, tot, 1);

                u = now = 0;
            }
        }
        return ans;
    }
}ac;

int main()
{
    int len;
    int n, m;
    int T, nc;
    nc = 1;
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d", &n);
        len = 0;
        ac.init();
        CLR(id, 0);
        for (int i = 1; i <= n;i++)
        {
            scanf("%s%d", ca, &val[i]);
            ac.insert(ca);
            int l = strlen(ca);
            REP(j, l)
            {
                s[len++] = ca[j];
            }
            id[len - 1] = i;
        }
        ac.getFail();
        ac.makeTree();
        printf("Case #%d: %d\n", nc++, ac.solve(s));
    }
}

后缀数组：

//#pragma warning (disable: 4786)
//#pragma comment (linker, "/STACK:16777216")
//HEAD
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
//LOOP
#define FF(i, a, b) for(int i = (a); i < (b); ++i)
#define FD(i, b, a) for(int i = (b) - 1; i >= (a); --i)
#define FE(i, a, b) for(int i = (a); i <= (b); ++i)
#define FED(i, b, a) for(int i = (b); i>= (a); --i)
#define REP(i, N) for(int i = 0; i < (N); ++i)
#define CLR(A,value) memset(A,value,sizeof(A))
#define CPY(a, b) memcpy(a, b, sizeof(a))
#define FC(it, c) for(__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
//STL
#define SZ(V) (int)V.size()
#define PB push_back
//INPUT
#define RI(n) scanf("%d", &n)
#define RII(n, m) scanf("%d%d", &n, &m)
#define RIII(n, m, k) scanf("%d%d%d", &n, &m, &k)
#define RIV(n, m, k, p) scanf("%d%d%d%d", &n, &m, &k, &p)
#define RV(n, m, k, p, q) scanf("%d%d%d%d%d", &n, &m, &k, &p, &q)
#define RS(s) scanf("%s", s)
//OUTPUT
#define WI(n) printf("%d\n", n)
#define WS(s) printf("%s\n", s)
typedef long long LL;
typedef unsigned long long ULL;
typedef vector <int> VI;
const int INF = 1000000000;
const double eps = 1e-10;

const int MAXN=110000 * 4;

int wa[MAXN], wb[MAXN], wv[MAXN], wn[MAXN];
char r[MAXN];
int a[MAXN], sa[MAXN], rank[MAXN], height[MAXN];
int idx[MAXN];
int val[20010];
int len[20010];
int sumlen[20010];
int dp[20010];

int cmp(int *r, int a, int b, int k)
{
    return r[a] == r[b] && r[a + k] == r[b + k];
}
void build_sa(int *r, int *sa, int n, int m)
{
    int i, j, p;
    int *x = wa, *y = wb, *t;
    for (i = 0; i < m; i++) wn[i] = 0;
    for (i = 0; i < n; i++)wn[x[i] = r[i]]++;///
    for (i = 1; i < m; i++) wn[i] += wn[i - 1];
    for (i = n - 1; i >= 0; i--) sa[--wn[x[i]]] = i;

    for (p = 1, j = 1; p < n; j <<= 1, m = p)
    {
        for (p = 0, i = n - j; i < n; i++) y[p++] = i;
        for (i = 0; i < n; i++) if (sa[i] >= j) y[p++] = sa[i] - j;

        for (i = 0; i < m; i++) wn[i] = 0;
        for (i = 0; i < n; i++) wn[wv[i] = x[y[i]]]++;///
        for (i = 1; i < m; i++) wn[i] += wn[i - 1];
        for (i = n - 1; i >= 0; i--) sa[--wn[wv[i]]] = y[i];

        t = x; x = y; y = t;
        x[sa[0]] = 0; p = 1;
        for (i = 1; i < n; i++)
            x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
    }
}

void getHeight(int *r, int *sa, int n)
{
    int i, j, k = 0;
    for (i = 1; i <= n; i++)
    {
        rank[sa[i]] = i;
        height[i] = 0;
    }
    for (i = 0; i < n; i++)
    {
        if (k) k--;
        j = sa[rank[i] - 1];
        while (r[i + k] == r[j + k]) k++;
        height[rank[i]] = k;
    }
}

int getid(int x)
{
    return idx[sa[x]];
}
int solve(int t, int n)
{
    int sum = 0;
    FE(i, 1, t)
    {
        dp[i] = val[i];
        sumlen[i] = sum;
        sum += len[i] + 1;
    }
    int nowi;
    FED(i, t, 1)
    {
        nowi = sumlen[i];

        int lmin = INF;
        for (int j = rank[nowi] + 1; j <= n; j++)
        {
            lmin = min(lmin, height[j]);
            if (lmin < len[i]) break;
            if (nowi < sa[j])
                dp[i] = max(dp[i], val[i] + dp[getid(j)]);
        }
        lmin = INF;
        for (int j = rank[nowi] - 1; j > 0; j--)
        {
            lmin = min(lmin, height[j + 1]);
            if (lmin < len[i]) break;
            if (nowi < sa[j])
                dp[i] = max(dp[i], val[i] + dp[getid(j)]);
        }
    }
    int ans = 0;
    FE(i, 1, t) ans = max(ans, dp[i]);
    return ans;
}

int main()
{
    int test;
    int t, n, m;
    int ncase = 1;
    RI(test);
    while (test--)
    {
        n = 0;
        m = 256;
        CLR(idx, 0);
        RI(t);
        FE(i, 1, t)
        {
            RS(r);
            RI(val[i]);
            int l = len[i] = strlen(r);
            REP(j, l)
            {
                a[n] = (int)r[j];
                idx[n++] = i;
            }
            a[n++] = m++;
        }
        a[--n] = 0; --m;
        build_sa(a, sa, n + 1, m);
        getHeight(a, sa, n);

        printf("Case #%d: %d\n", ncase++, solve(t, n));
    }
    return 0;
}