HDU 3341 Lost's revenge ( Trie图 && 状压DP && 数量限制类型 )
题意 : 给出 n 个模式串，最后给出一个主串，问你主串打乱重组的情况下，最多能够包含多少个模式串。
分析 : 如果你做过类似 Trie图 || AC自动机 + DP 类似的题目的话，那么这道题相对之前的对于主串的“构造”过程加上了一个限制，那就是字符的元素的有限制的，那么DP的状态就不能用长度来表示状态（ 类比 POJ 2778 ），所以写出了一个错误的根据长度DP的代码
for(int i=0; i<len; i++){ for(int j=0; j<ac.Size; j++){ if(dp[i][j] >= 0){ for(int k=0; k<4; k++){ if(Lter[i][j][k] > 0){///表示 i、j 状态下，0123代表的“ATGC”字符数还剩多少，但是这是错的，因为在长度为 i 停留在当前节点 ///j 的字符串可能有多种，而这些字符串所拥有的剩余字符数是不一样的，不能单纯只用Lter[i][j][k]表示 ///实际上这只是我自己的理解，我没有打表跟踪过错误数据，你可以自己想想为什么这样子不行…… int newi = i + 1; int newj = ac.Node[j].Next[k]; dp[newi][newj] = max(dp[newi][newj], dp[i][j] + ac.Node[newj].cnt); for(int l=0; l<4; l++) Lter[newi][newj][l] = Lter[i][j][l]; Lter[newi][newj][k]--; } } } } }
那要如何定义DP状态呢？一般来说对于这样的数量和所在节点状态是关键点，所以我们可以DP[A][T][G][C][Node]前四维表示ATGC数量，最后一维表示当前状态停留在节点 Node ，但是这样子空间会爆炸，这时候就需要压缩一下状态，考虑压缩前四维，网上有很多利用进制的压缩，弱智的我有点不理解，所以还是用了普通的Hash，即利用一个四维数组 Hash[11][11][11][11] ( 每一个字母最多就是 10 个，所以这样开数组 ) ，然后只需要统计主串各个种类字符的数量，就能打出一个 Hash 表，将原本五维DP压成二维DP，DP[i][j] 表示各个字符数量状态为 i 且停留在 j 节点的最多包含模式串个数，则状态转移方程为 ( 一个节点状态能转到"ATGC"四个状态，那么以转到字符 ' A ' 为例 )
DP[ Hash[A+1][G][T][C] ][j] = max( DP[ Hash[A+1][G][T][C] ][j], DP[i][j] + Trie[j]['A'].cnt )
DP初始状态为 DP[0][0] = 0、DP[0~最大的Hash值数量][0~Trie图上的节点个数] = -1
#include<stdio.h> #include<string.h> #include<algorithm> #include<queue> using namespace std; const int Letter = 26; const int Max_Tot = 50 * 10 + 5; int mp[128]; int Hash[41][41][41][41]; struct Aho{ struct StateTable{ int Next[Letter]; int fail, cnt; }Node[Max_Tot]; int Size; queue<int> que; inline void init(){ while(!que.empty()) que.pop(); memset(Node[0].Next, 0, sizeof(Node[0].Next)); Node[0].fail = Node[0].cnt = 0; Size = 1; } inline void insert(char *s){ int now = 0; for(int i=0; s[i]; i++){ int idx = mp[s[i]]; if(!Node[now].Next[idx]){ memset(Node[Size].Next, 0, sizeof(Node[Size].Next)); Node[Size].fail = Node[Size].cnt = 0; Node[now].Next[idx] = Size++; } now = Node[now].Next[idx]; } Node[now].cnt++; } inline void BuildFail(){ Node[0].fail = 0; for(int i=0; i<Letter; i++){ if(Node[0].Next[i]){ Node[Node[0].Next[i]].fail = 0; que.push(Node[0].Next[i]); }else Node[0].Next[i] = 0;///必定指向根节点 } while(!que.empty()){ int top = que.front(); que.pop(); Node[top].cnt += Node[Node[top].fail].cnt; for(int i=0; i<Letter; i++){ int &v = Node[top].Next[i]; if(v){ que.push(v); Node[v].fail = Node[Node[top].fail].Next[i]; }else v = Node[Node[top].fail].Next[i]; } } } }ac; char S[44]; int dp[11*11*11*11+5][505]; int Solve() { int num[4]; memset(num, 0, sizeof(num)); for(int i=0; S[i]; i++) num[mp[S[i]]]++; int HashCnt = 0; for(int A=0; A<=num[0]; A++) for(int T=0; T<=num[1]; T++) for(int G=0; G<=num[2]; G++) for(int C=0; C<=num[3]; C++) Hash[A][T][G][C] = HashCnt++; for(int j=0; j<=ac.Size; j++) for(int i=0; i<=HashCnt; i++) dp[i][j] = -1; dp[0][0] = 0; for(int A=0; A<=num[0]; A++){ for(int T=0; T<=num[1]; T++){ for(int G=0; G<=num[2]; G++){ for(int C=0; C<=num[3]; C++){ for(int i=0; i<ac.Size; i++){ int j = Hash[A][T][G][C]; if(dp[j][i] >= 0){ for(int k=0; k<4; k++){ if(k==0 && A == num[0]) continue; if(k==1 && T == num[1]) continue; if(k==2 && G == num[2]) continue; if(k==3 && C == num[3]) continue; int a, t, g, c; a = (k==0), t = (k==1); g = (k==2), c = (k==3); dp[Hash[A+a][T+t][G+g][C+c]][ac.Node[i].Next[k]] = max(dp[Hash[A+a][T+t][G+g][C+c]][ac.Node[i].Next[k]], dp[j][i] + ac.Node[ac.Node[i].Next[k]].cnt); } } } } } } } int ans = 0; int MaxNum = Hash[num[0]][num[1]][num[2]][num[3]]; for(int i=0; i<ac.Size; i++) ans = max(ans, dp[MaxNum][i]); return ans; } int main(void) { int n, Case = 1; mp['A']=0, mp['T']=1; mp['G']=2, mp['C']=3; while(~scanf("%d", &n) && n){ ac.init(); for(int i=0; i<n; i++){ scanf("%s", S); ac.insert(S); }ac.BuildFail(); scanf("%s", S); printf("Case %d: %d\n", Case++, Solve()); } return 0; }
