HDU 2296 Ring AC自动机 + 动态规划

题目大意：

就是现在给出m个串，每个串都有一个权值，现在你要找到一个长度不超过n的字符串，其中之前的m个串每出现一次就算一次那个字符串的权值，求能找到的最大权值的字符串，如果存在多个解，输出最短的字典序最小的串。当最大全权值为0时输出空串。

输入最多100个子串，权值为不超过100的正整数。每个子串长度至少为1，不超过10, N <= 50

大致思路：

首先建立AC自动机的状态转移图，然后用 dp[ i ][ j ]表示长度为 i ，结尾停留在Trie树上节点为 j 的串能得到的最大权值， dps[ i ][ j ]对应其字符串

那么不难发现状态转移方程  dp[i+1][next[j][t]] = max(dp[i+1][next[j][t]], dp[i][j] + end[next[j][t]]), 0 <= t < 26; end[ i ]表示Trie树上节点i对应的能贡献的权值

代码如下：

Result  :  Accepted     Memory  :  2800 KB     Time  :  187 ms

/*
 * Author: Gatevin
 * Created Time:  2014/11/22 8:08:22
 * File Name: Kagome.cpp
 */
#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;

int t, n, m;
int w[101];//每个编号的权值

int dp[52][1010];
string dps[52][1010];
/*
 * dp[i][j]表示长度为i的串，结尾停在Trie树上结点编号为j的位置时能得到的最大权值
 * dps[i][j]表示dp[i][j]对应的最优解的字符串
 */

struct Trie
{
    int next[1010][26], fail[1010], end[1010];
    int root, L;
    int newnode()
    {
        for(int i = 0; i < 26; i++)
            next[L][i] = -1;
        end[L++] = 0;
        return L - 1;
    }
    void init()
    {
        L = 0;
        root = newnode();
        return;
    }
    void insert(char* s, int id)
    {
        int now = root;
        for(; *s; s++)
        {
            if(next[now][*s - 'a'] == -1)
                next[now][*s - 'a'] = newnode();
            now = next[now][*s - 'a'];
        }
        end[now] += w[id];
        return;
    }
    void build()
    {
        queue <int> Q;
        fail[root] = root;
        Q.push(root);
        while(!Q.empty())
        {
            int now = Q.front();
            Q.pop();
            if(end[fail[now]]) end[now] += end[fail[now]];//end[i]表示节点i处能带来的权值
            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;
    }
    void solve()
    {
        memset(dp, -1, sizeof(dp));
        for(int i = 0; i <= n; i++)
            for(int j = 0; j < L; j++)
                dps[i][j] = "";
        dp[0][0] = 0;
        for(int i = 0; i < n; i++)
            for(int j = 0; j < L; j++)
            {
                if(dp[i][j] == -1) continue;
                for(int t = 0; t < 26; t++)
                {
                    if(dp[i + 1][next[j][t]] == dp[i][j] + end[next[j][t]] && dps[i + 1][next[j][t]] > dps[i][j] + char(t + 'a'))//相等时比较字符串字典序
                    {
                        dps[i + 1][next[j][t]] = dps[i][j] + char(t + 'a');
                    }
                    if(dp[i + 1][next[j][t]] < dp[i][j] + end[next[j][t]])//不等时取更优的解
                    {
                        dp[i + 1][next[j][t]] = dp[i][j] + end[next[j][t]];
                        dps[i + 1][next[j][t]] = dps[i][j] + (char)(t + 'a');
                    }
                }
            }
        int ans = 0;
        int ansi = 0, ansj = 0;
        for(int i = 1; i <= n; i++)
            for(int j = 0; j < L; j++)
            {
                if(ans == dp[i][j] && dps[ansi][ansj] > dps[i][j])
                {
                    ansi = i;
                    ansj = j;
                }
                if(ans < dp[i][j])
                {
                    ans = dp[i][j];
                    ansi = i;
                    ansj = j;
                }
            }
        cout<<dps[ansi][ansj]<<endl;
        return;
    }
};

Trie AC;

int main()
{
    char ts[101][11];
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d", &n, &m);
        AC.init();
        for(int i = 1; i <= m; i++)
        {
            scanf("%s", ts[i]);
        }
        for(int i = 1; i <= m; i++)
        {
            scanf("%d", w + i);
            AC.insert(ts[i], i);
        }
        AC.build();
        AC.solve();
    }
    return 0;
}