Lost‘s revenge HDU - 3341(AC自动机+状压dp)

题意：给出n个模式串，一个目标串，问把目标串重新排位最多能产生多少个模式串，可以重叠且所有串只包含A C G T。目标串长度不超过40

思路：1、问题转化成，使用与目标串相同数目的A G C T字符排列组合，得到的字符串最多能包含多少个模式串。多模式匹配问题，建好AC自动机。

2、目标串长度不多，联想到可以用类似 ”乌龟棋“这题类似的状压dp，把A G C T的使用数目情况看成一种状态，Hash[i][j][k][m]表示用了i个A j个G k个C m个T时的状态Hash从0开始赋值，于是每个状态就对应了一个int 类型的值，每个状态可以达到某些顶点，dp[i][k]表示k状态下到达i顶点的最优解 。

3、dp过程： 首先dp[0][0]=0，其余初始化成-1
转移方程：dp[i][now]=max(dp[father][last])+isstr[i]，isstr[i]表示字符串数量

具体的转移过程我们就枚举当前的状态now,枚举now状态当前可到达的所有顶点i，对其所有的孩子节点进行更新.代码如下

 dp[0][0]=0;
        int a[4]={0};//4种转移方式
        for(a[0]=0;a[0]<=num[0];a[0]++)
        {
            for(a[1]=0;a[1]<=num[1];a[1]++)
            {
                for(a[2]=0;a[2]<=num[2];a[2]++)
                {
                    for(a[3]=0;a[3]<=num[3];a[3]++)
                    {
                        int now=Hash[a[0]][a[1]][a[2]][a[3]];//枚举每个状态
                        for(int i=0;i<=tot;i++)
                        {
                            if(dp[i][now]!=-1)//-1表示当前状态不可到达这个顶点
                            {
                                for(int id=0;id<4;id++)
                                {
                                    if(a[id]==num[id]) continue;//满了
                                    int next;//孩子节点的状态
                                    if(id==0) next=Hash[a[0]+1][a[1]][a[2]][a[3]];
                                    else if(id==1) next=Hash[a[0]][a[1]+1][a[2]][a[3]];
                                    else if(id==2) next=Hash[a[0]][a[1]][a[2]+1][a[3]];
                                    else if(id==3) next=Hash[a[0]][a[1]][a[2]][a[3]+1];
                                    int u=tree[i][id];//孩子节点
                                    dp[u][next]=max(dp[u][next],dp[i][now]+isstr[u]);
                                }
                            }
                        }
                    }
                }
            }

其余细节见代码注释：

#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=5e2+20;
int book[128];
int tree[maxn][26];//字典树
int isstr[maxn];
int tot;//节点总数 
int fail[maxn];
int n;
char s1[50];
int dp[maxn][15005];//到达i节点  此时AGCT使用量是j状态时的最优解
//dp[i][j]=maxn(dp[father][last])+isstr[i]
//从0开始枚举每个状态  枚举当前状态能够访问的顶点 由该顶点4个孩子节点 更新后面的状态
int num[4];
int cnt=0;
void Init()
{
    book['A']=0;
    book['G']=1;
    book['C']=2;
    book['T']=3;
    memset(tree,0,sizeof(tree));
    memset(isstr,0,sizeof(isstr));
    tot=0;
    memset(fail,0,sizeof(fail));
    memset(num,0,sizeof(num));
    fill(dp[0],dp[0]+maxn*15005,-1);//初始化成-1
}
void Insert(char *s)
{
    int len=strlen(s),root=0;
    for(int i=0;i<len;i++)
    {
        int id=book[s[i]];
        if(!tree[root][id]) tree[root][id]=++tot;
        root=tree[root][id];
    }
    isstr[root]++;//可能含有相同的模式串
}
void getfail()
{
    queue<int> q;
    for(int i=0;i<4;i++)
    {
        if(tree[0][i]) 
        {
            q.push(tree[0][i]);
            //fail[tree[0][i]]=0;
        }
        //else tree[0][i]=0
    }
    while(!q.empty())
    {
        int v=q.front();
        q.pop();
        isstr[v]+=isstr[fail[v]];//容易被忽略的细节
        for(int i=0;i<4;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);
    while(~scanf("%d",&n) && n)
    {
        Init();
        for(int i=1;i<=n;i++)
        {
            scanf("%s",s1);
            Insert(s1);
        }
        getfail();
        scanf("%s",s1);
        int len=strlen(s1);
        for(int i=0;i<len;i++) num[book[s1[i]]]++;
        int Hash[num[0]+1][num[1]+1][num[2]+1][num[3]+1];//给每个状态编号
        int x=-1;//x最终为 所有字符取完的状态
        for(int i=0;i<=num[0];i++)
        {
            for(int j=0;j<=num[1];j++)
            {
                for(int k=0;k<=num[2];k++)
                {
                    for(int m=0;m<=num[3];m++) Hash[i][j][k][m]=++x;
                }
            }
        }
        //分别有num[0] num[1] num[2] num[3] 个A G C T  dp过程类似乌龟棋
        //dp[i][k] 表示k状态下 到达第i个顶点的最优解
        dp[0][0]=0;
        int a[4]={0};//4种转移方式
        for(a[0]=0;a[0]<=num[0];a[0]++)
        {
            for(a[1]=0;a[1]<=num[1];a[1]++)
            {
                for(a[2]=0;a[2]<=num[2];a[2]++)
                {
                    for(a[3]=0;a[3]<=num[3];a[3]++)
                    {
                        int now=Hash[a[0]][a[1]][a[2]][a[3]];
                        for(int i=0;i<=tot;i++)
                        {
                            if(dp[i][now]!=-1)//-1表示当前状态不可到达这个顶点
                            {
                                for(int id=0;id<4;id++)
                                {
                                    if(a[id]==num[id]) continue;
                                    int next;
                                    if(id==0) next=Hash[a[0]+1][a[1]][a[2]][a[3]];
                                    else if(id==1) next=Hash[a[0]][a[1]+1][a[2]][a[3]];
                                    else if(id==2) next=Hash[a[0]][a[1]][a[2]+1][a[3]];
                                    else if(id==3) next=Hash[a[0]][a[1]][a[2]][a[3]+1];
                                    int u=tree[i][id];
                                    dp[u][next]=max(dp[u][next],dp[i][now]+isstr[u]);
                                }
                            }
                        }
                    }
                }
            }
        }
        int ret=0;
        for(int i=0;i<=tot;i++) ret=max(ret,dp[i][x]);
        printf("Case %d: %d\n",++cnt,ret);
    }
    system("pause");
    return 0;
}