HDU 2296

http://acm.split.hdu.edu.cn/showproblem.php?pid=2296

题意 ： 给你M个 字符串，这些字符串带有一定的价值，之后 告诉你每个 之前给你的字符串的价值，之后让你 最长为 N 的串 他的价值最大，如果价值相同输出 字符串长度最短的那个，如果长度相同，输出字典序小的那个………。

思路：
参考了大神的思路–>http://blog.youkuaiyun.com/u013480600/article/details/23597033
自己的总结：
1. 最大价值，还规定字符串，那么最大价值我们可以想到DP，字符串的选择可以当做模式串，之后给你的是匹配串，那么多匹配串我们可以搞AC机，那么这题的大框已经有了，就是AC机上DP，因为AC机自带一个串的状态的转移，我们可以自己想一下在插入字符串的时候同时在串的末尾用ends标记一下这个串的价值。在构造失败指针时要想到当前状态下的每个存在的状态的价值都要加上失败指针所构成的价值。
2. 构造DP方程，因为要输出的是最优结果的串，那么我们可以用string类来建立对象数组用来保存可能为结果的串，之后用一个串来保存答案。
3.
令dp[i][j]=x表示当前在i点走过了长j的路所生产的最大权值为x. 再用string path[i][j]来保存那个具有最大权值的最优字符串即可.不过要注意如果最后算的的最大权值是0,那么要输出空串.因为空串最短.

dp[i][j] = max(dp[k][j-1]+match[i]) 若dp[i][j]更新的时候,path[i][j]也要看看是否需要更新成:

if(path[i][j]!=””)path[i][j] = better(path[i][j] , path[k][j-1]+”x”)x字符表示从k走到i的那条边的字符是x.

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <string>
#define inf 0x3f3f3f3f3f
#include <string.h>
#define maxs 1010
#define MME(i,j) memset(i,j,sizeof(i))
using namespace std;
string path[maxs][111];
char s[maxs][110];
int t,n,m,ans;

class AC_automoan{

private:
    int nexts[maxs][27],fail[maxs],ends[maxs];
    int L,root;
    int dp[maxs][110];
public:

    int Newnode()
    {
     //   MME(dp,0);
        MME(nexts[L],-1);
        ends[L++]= 0;
        return L-1;
    }

    string betterans(string a,string b)
    {
        if(a=="")
            return a;
        if(a.size() != b.size())
            return a.size()<b.size()?a:b;
        else  return a<b ? a:b;
    }

    void init(){
        L=0;
        root=Newnode();
        MME(fail,0);
        MME(ends,0);
        ends[0]=0;
    }

    void Insert_word(char *s,int value)
    {
        int i,id,p=root,len=strlen(s);
        for(i=0;i<len;i++)
        {
            id=s[i]-'a';
            if(nexts[p][id]==-1)
                nexts[p][id]=Newnode();
            p=nexts[p][id];
        }
        ends[p]=value;
    }

    void build(){
        queue<int> Q;
        int now=root,i,id;
        for(int i=0;i<26;i++)
        {
            if(nexts[now][i]==-1)
                nexts[now][i]=0;
            else
            {
                fail[nexts[now][i]]=root;
                Q.push(nexts[now][i]);
            }
        }

        while(!Q.empty())
        {
            now=Q.front();
            Q.pop();
            for(int i=0;i<26;i++)
            {
                if(nexts[now][i]==-1)
                    nexts[now][i] = nexts[fail[now]][i];
                else
                {
                    fail[ nexts[now][i] ] = nexts[fail[now]][i];
                    Q.push( nexts[now][i] );
                    ends[ nexts[now][i] ]+=ends[ fail[  nexts[now][i] ] ];     //  走到当前节点所能得到的 权值
                }
            }
        }
    }

    string DP()
    {
       for(int i=0;i<L;i++)
       {
           for(int j=0;j<=n;j++)
           {
               dp[i][j]=-1;
               path[i][j]="";
           }
       }

       dp[0][0]=0;
       string res="";

       for(int len = 0 ; len < n ; len++ )    //DP[i][j]  表示第 i 个状态 长 j 的权值
       {
           for(int k=0;k<L;k++)
                if(dp[k][len]!=-1)//走过当前节点
           {
               //puts("******************");
               for(int j=0;j<26;j++)    //选择下一步选哪个字符
               {
                   if( dp[ nexts[k][j] ][len+1] <= dp[k][len]+ends[ nexts[k][j] ] )
                   {
                       char temp='a'+j;
                       //int &dpnew=dp[ nexts[k][j] ][len+1],&dplast=dp[k][len],&ad=ends[nexts[k][j]];//ends[nexts[k][j]];
                       if( dp[ nexts[k][j] ][len+1] < dp[k][len] + ends[nexts[k][j]] )
                       {
                           dp[ nexts[k][j] ][len+1] = dp[k][len] + ends[nexts[k][j]];
                           path[ nexts[k][j] ][len+1] = path[k][len]+temp;
                          // printf("nexts[%d][%d] -->Str is ",nexts[k][j]);
                           //cout<<path[ nexts[k][j] ] [len+1]<<endl;
                       }
                       else
                       {
                           path[nexts[k][j]][len+1]=betterans( path[nexts[k][j]][len+1],path[k][len]+temp);
                       }

                       if( ans < dp[ nexts[k][j] ][len+1] )
                       {
                           ans=dp[ nexts[k][j] ][len+1];
                           res=path[nexts[k][j]][len+1];
                       }
                       else if( ans == dp[ nexts[k][j] ][len+1] )
                           res=betterans(res,path[nexts[k][j]][len+1]);
                   }
               }

           }
       }
       return res;
    }
};

int main()
{

    scanf("%d",&t);
    while(t--)
    {
        AC_automoan AC;
        AC.init();
        ans=0;
        scanf("%d %d",&n,&m);
        for(int i=0;i<m;i++)
            scanf("%s",s[i]);
        int val;
        for(int i=0;i<m;i++)
        {
            scanf("%d",&val);
            AC.Insert_word(s[i],val);
        }
        AC.build();

        string ans=AC.DP();
        cout<<ans<<endl;
    }
    return 0;
}