Ring HDU - 2296（AC自动机+dp）

题目链接

题意：给你m个字符串，每个字符串有自己的价值，求一个长度不超过n的字符串，满足其包含的所有子串价值之和最大 。

思路：套路有点明显，AC自动机+dp

dp[i][j]表示走了i步，到达j节点时的最大价值， 则dp[i][j]=max(dp[i-1][father])+value[j]

但是这题细节很多：一是关于建AC自动机时候字符串价值的预处理，二是dp过程的常数优化，三是当有多个最优解字符串的时候要求长度最小 且字典序最小的那个。 具体看代码注释了~

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<stdlib.h>
#include<string.h>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<math.h>
#include<set>
using namespace std;
#define INF 0x3f3f3f
#define LL unsigned long long
const int maxn=1e3+200;
int tree[maxn][26];//字典树
int isstr[maxn];//记录这个节点结尾的字符串的序号
int tot;//节点总数 
int fail[maxn];
int n,m;
char s1[15];
int value[105];//第i个字符串的价值
string ans_str;//答案串
int dp[55][maxn];//第i步  到达j号节点对应的最大值
//dp[i][j]=max(dp[i-1][k])+w[j]
string str[55][maxn];//记录dp[i][j]状态下的字符串
inline void Init()
{
    for(int i=0;i<55;i++)
    {
        for(int j=0;j<maxn;j++)
        {
            str[i][j]="";
            dp[i][j]=-1;//初始化成-1 
        }
    }
    ans_str="";
    memset(tree,0,sizeof(tree));
    memset(isstr,0,sizeof(isstr));
    tot=0;
    memset(fail,0,sizeof(fail));
}
inline void Insert(char *s,int x)
{
    int root=0,len=strlen(s);
    for(int i=0;i<len;i++)
    {
        int id=s[i]-'a';
        if(!tree[root][id]) tree[root][id]=++tot;
        root=tree[root][id];
    }
    isstr[root]=x;//把字符串的价值意义转化成了这个节点的意义，因为根节点到这个节点的路径是唯一的，且路径就是该字符串
}
inline void getfail()
{
    queue<int> q;
    //初始化第二层，fail指针全指向根节点，入队
    for(int i=0;i<26;i++)
    {
        if(tree[0][i])
        {
            fail[tree[0][i]]=0;
            q.push(tree[0][i]);
        }
    }
    while(!q.empty())
    {
        int v=q.front();
        q.pop();
        value[isstr[v]]+=value[isstr[fail[v]]];//细节一：像ABC BC 这种 要加上他后缀的价值
        for(int i=0;i<26;i++)
        {
            if(tree[v][i]) 
            {
                fail[tree[v][i]]=tree[fail[v]][i];
                q.push(tree[v][i]);
            }
            else tree[v][i]=tree[fail[v]][i];
        }
    }
}

int main()
{
//    ios::sync_with_stdio(false);
//    cin.tie(0);
//    cout.tie(0);
    int T;
    cin>>T;
    while(T--)
    {
        Init();
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++)
        {
            scanf("%s",s1);
            Insert(s1,i);
        }
        for(int i=1;i<=m;i++) scanf("%d",value+i);
        getfail();
        dp[0][0]=0;
        for(int i=0;i<n;i++)//由i 更新i+1
        {
            for(int j=0;j<=tot;j++)
            {
                if(dp[i][j]!=-1)//-1则无意义 不能转移到这个状态   
                {
                    for(int id=0;id<26;id++)
                    {
                        int u=tree[j][id];
                        if(value[isstr[u]]+dp[i][j]>dp[i+1][u])
                        {
                            dp[i+1][u]=value[isstr[u]]+dp[i][j];
                            str[i+1][u]=str[i][j]+(char)('a'+id);
                        }
                        else if(value[isstr[u]]+dp[i][j]==dp[i+1][u])
                        {
                            string temp=str[i][j]+(char)('a'+id);
                            //判断temp是否字典序小于str[i+1][u]
                            if(temp<str[i+1][u]) str[i+1][u]=temp;
                        }
                    }
                }
            }
        }
        int ans=0;
        for(int i=1;i<=n;i++)//每个1~n的长度都要枚举
        {
            for(int j=0;j<=tot;j++) ans=max(ans,dp[i][j]);
        }
        if(!ans)
        {
            cout<<""<<'\n';
            continue;
        }
        for(int i=1;i<=n;i++)//这里同样每个都需要枚举
        {
            for(int j=0;j<=tot;j++)
            {
                if(dp[i][j]==ans)//求出最短 或同样短但字典序最小的那个
                {
                    if(ans_str=="" || (ans_str.size()>str[i][j].size()) ||
                     (ans_str.size()==str[i][j].size() && ans_str>str[i][j]) )
                    {
                        ans_str=str[i][j];
                    }
                }
            }
            if(ans_str!="") break;//常数优化  一旦得到了一个，此时就是最短的了 可以break
        }
        cout<<ans_str<<'\n';
    }
    system("pause");
    return 0;
}