对AC自动机+DP题的一些汇总与一丝总结 (1)

(1)题意 : 输入n、m、k意思就是给你 m 个模式串，问你构建长度为 n 至少包含 k 个模式串的方案有多少种

分析：(HDU2825)

DP[i][j][k] 表示 DP[第几步][哪个节点结尾][当前选了哪些单词] = 方案数

 for(int i=; i<=n; i++)
            for(int j=; j<ac.Size; j++)
                for(int l=; l<(<<m); l++)
                    dp[i][j][l] = ;
        dp[][][] = ;
        for(int i=; i<n; i++){
            for(int j=; j<ac.Size; j++){
                for(int l=; l<(<<m); l++){
                    if(dp[i][j][l] > ){
                        for(int x=; x<Letter; x++){
                            int newi = i+;
                            int newj = ac.Node[j].Next[x];
                            int newl = (ac.Node[ newj ].id) | l;
                            dp[newi][newj][newl] += dp[i][j][l];
                            dp[newi][newj][newl] %= MOD;
                        }
                    }
                }
            }
        }

(2)题意 : 给出 n 个模式串，最后给出一个主串，问你主串打乱重组的情况下，最多能够包含多少个模式串。（只有ATGC四总字符）(HDU3341)

(也就是说，给定了字母数量的限制去构造)

DP[A][T][G][C][Node]前四维表示ATGC数量，最后一维表示当前状态停留在节点 Node

即利用一个四维数组 Hash[11][11][11][11] ( 每一个字母最多就是 10 个，所以这样开数组 ) ，然后只需要统计主串各个种类字符的数量，

        for(int j=; j<=ac.Size; j++)
            for(int i=; i<=HashCnt; i++)
                dp[i][j] = -;

    dp[][] = ;

    for(int A=; A<=num[]; A++){
        for(int T=; T<=num[]; T++){
            for(int G=; G<=num[]; G++){
                for(int C=; C<=num[]; C++){
                    for(int i=; i<ac.Size; i++){
                        int j = Hash[A][T][G][C];
                        if(dp[j][i] >= ){
                            for(int k=; k<; k++){
                                if(k== && A == num[]) continue;
                                if(k== && T == num[]) continue;
                                if(k== && G == num[]) continue;
                                if(k== && C == num[]) continue;
                                int a, t, g, c;
                                a = (k==), t = (k==);
                                g = (k==), c = (k==);
                                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);
                            }
                        }
                    }
                }
            }
        }
    }

(3)题意 : 给出一个 n 行、m 列的方格图，现从图左上角(0, 0) 到右下角的 (n, m)走出一个字符串(规定只能往下或者往右走)，向右走代表' R ' 向下走则是代表 ' D ' 最后从左上角到右下角，不同的路线会走出不同的字符串，问你这些不同的字符串有多少个是包含了接下来给定的两个子串。（HDU 4758）

(用 (n+1) 个 ' D ' 和 (m+1)个 ' R ' 构造出长度为 (n+m+2) 的字符串，且包含给定的两个子串的方案数有多少个)

DP[i][j][k][l]代表在有 i 个 ' D '（即向下走了 i 步）、j 个 ' R '（向右走 j 步）、停留在 k 这个节点、包含子串情况 l 时的最大方案.

 for(int i=; i<=n; i++)
        for(int j=; j<=m; j++)
            for(int k=; k<ac.Size; k++)
                for(int l=; l<; l++)
                    dp[i][j][k][l] = ;

    dp[][][][] = ;

    for(int i=; i<=n; i++){
        for(int j=; j<=m; j++){
            for(int k=; k<ac.Size; k++){
                for(int l=; l<; l++){
                    if(dp[i][j][k][l] > ){
                        int Node1 = ac.Node[k].Next[];
                        int Node2 = ac.Node[k].Next[];
                        dp[i][j+][Node1][l | ac.Node[Node1].id] += dp[i][j][k][l];
                        dp[i+][j][Node2][l | ac.Node[Node2].id] += dp[i][j][k][l];
                        dp[i][j+][Node1][l | ac.Node[Node1].id] %= MOD;
                        dp[i+][j][Node2][l | ac.Node[Node2].id] %= MOD;
                    }
                }
            }
        }
    }

我们可以发现：题目3其实就是题目2和题目1的结合

1.对于是给出字符数量限制的，我们一般在DP的时候加维度表示字符数量的情况：比如dp[A][T][G][C][] 前四维表示ATGC数量

2.对于是包含模式串的限制，我们一般在DP的时候加维度（二进制）表示选了哪些串m,切AC自动机的节点需要保留选串的情况

（Node[now].id |= (1<<id);）

3.我们在一些题目中还发现了，AC自动机节点是求一个（Node[now].cnt++;） 这是一般问包含多少个模式窜

Node[now].falt =1;  这是标记哪些是给出的模式串    这些保留的变量是看情况而定