Hdu 4117 GRE Words(字符串_AC自动机(DP))

题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=4117

题目大意: 题目给定n个字符串，每个串都有一个权值，让我们找出若干个字符串组成一个序列，前面一个字符串是后面一个字符串的子串，问我们能获得最大权值和？n <= 2万，字符串长度<=30万。

解题思路: 2011年成都区域赛的题目，是Spoj1676的加强版，要求对ac自动机理解得应更深些。这题的意思和Spoj1676差不多，只不过多了一个顺序必须一定。如果我们也像上题那样去做就没办法保证顺序。
     我最开始的做法是一个一个字符串地插入，插入的同时进行构建fail指针写着写着就混乱了，因为提交到杭电一直RE，其实是杭电数据的问题，但我没办法分辨是我代码的问题还是数据的问题，我就尽量改代码。改着改着发现其实马上构建fail指针要一直回溯找匹配部分和后缀部分最大的权值，这样还不如一次性构建好ac自动机先不计算每个节点结束的最大权值，构建好之后一个一个字符串插入进行计算，这样也可以保证顺序，更容易想更容易写。
     这题的所有字符串需要进行保存，最早我是用string数组，但是莫名地挂了，最后我把每个字符串都压缩到一个char数组里，用pos数组记录每个串的结束为止，就顺利ac了。

测试数据:

Input:
10
5
a 1
b 2
c 3
e 5
abcde 8
5
a 1
ab 2
abb 3
baba 5
abbab 8
1
a -10
5
abc 10
cba 10
dbca 10
jkjks 10
fuckme 10
5
a 1
aa 2
aaa 3
aaaa 4
aaaaa 5
5
aaaaaaaaaaaaaa 10
bbbbbbbbbbbb 10
cccccccccccccccc 10
dddddddddddddd 10 
aaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccddddddddddddddd 10

Output:
13
14
0
10
15
20
OutPut:
Case #1: 20
Case #2: 24
Case #3: 170975

C艹代码:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;
#define MAX 310000
#define max(a,b) ((a)>(b)?(a):(b))


struct node {

    int  st,flag;
    node *next[26],*fail;
}tree[MAX],*root,*qu[MAX];
char str[MAX],dir[MAX];
int ptr,n,ans,val[MAX];
int head,tail,tot,pos[MAX];


node *CreateNode() {

    tree[ptr].st = 0;
    for (int i = 0; i < 26; ++i)
        tree[ptr].next[i] = NULL;
    return &tree[ptr++];
}
void Initial() {

	pos[0] = 0,dir[0] = '\0';
    ptr = head = tail = 0;
    root = CreateNode();
    root->fail = root;
}
void Insert(char *str) {

    node *p = root;
    for (int i = 0; str[i]; ++i) {

        int k = str[i] - 'a';
        if (p->next[k] == NULL)
            p->next[k] = CreateNode();
        p = p->next[k];
    }
}
void Build_AC() {

    qu[head++] = root;
    while (tail < head) {

        node *p = qu[tail++];
        for (int k = 0; k < 26; ++k)
            if (p->next[k]) {

                if (p == root) p->next[k]->fail = root;
                else p->next[k]->fail = p->fail->next[k];
                qu[head++] = p->next[k];
            }
            else {

                if (p == root) p->next[k] = root;
                else p->next[k] = p->fail->next[k];
            }
    }
}
void Solve_AC(int l,int r,int val) {

    node *p = root,*q;
    int k,i = 0,temp = 0;


    for (i = l; i <= r; ++i) {

        int k = dir[i] - 'a';
        temp = max(temp,p->next[k]->st);
        q = p->next[k];
        while (q != root) {
        
            temp = max(temp,q->st);
            q = q->fail;
        }
        p = p->next[k];
    }
    p->st = temp + val;
}


int main()
{
    int i,t,cas = 0;


    scanf("%d",&t);
    while (t--) {

        scanf("%d",&n);
        Initial();
        for (i = 1; i <= n; ++i) {

			scanf("%s %d",dir+pos[i-1],&val[i]);
			pos[i] = strlen(dir);
            Insert(dir+pos[i-1]);
        }


        Build_AC();
        for (i = 1; i <= n; ++i) 
            if (val[i] > 0) Solve_AC(pos[i-1],pos[i]-1,val[i]);
        ans = 0;
        for (i = 1; i < ptr; ++i)
            ans = max(ans,tree[i].st);
        printf("Case #%d: %d\n",++cas,ans);
    }
}

本文ZeroClock原创，但可以转载，因为我们是兄弟。