HDU 4758 Walk Through Squares ( Trie图 && 状压DP && 数量限制类型 )

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

分析 : 简单想想不难发现最后肯定是走了 (n+1) 个 ' D ' 和 (m+1)个 ' R ' ，那么也就是说用 (n+1) 个 ' D ' 和 (m+1)个 ' R ' 构造出长度为 (n+m+2) 的字符串，且包含给定的两个子串的方案数有多少个（ 跟 HDU 3341 类似 ），那么来看看关键点，即考虑 ' D '与' R '的数量、以及当前节点包含了多少个子串、当前停留在Trie上哪个节点，那么可以定义出DP[i][j][k][l]代表在有 i 个 ' D '（即向下走了 i 步）、j 个 ' R '（向右走 j 步）、停留在 k 这个节点、包含子串情况 l 时的最大方案数，则状态转移方程为

每个节点能向 ' D ' 和 ' R ' 转移，这里以向 ' D ' 转移为例

DP[i+1][j][k][l | Trie[k]['D'].id] += DP[i][j][k][l] ( Trie[k]['D']代表从 k 转移到状态为' D '节点，其 id 表示包含字母的情况 )

DP初始状态为 DP[0][0][0][0] = 1、DP其他 = 0

#include<bits/stdc++.h>
using namespace std;
;
;
;
int n, m;
][][][];
struct Aho{
    struct StateTable{
        int Next[Letter];
        int fail, id;
    }Node[Max_Tot];
    int Size;
    queue<int> que;

    inline void init(){
        while(!que.empty()) que.pop();
        memset(Node[].Next, , ].Next));
        Node[].fail = Node[].id = ;
        Size = ;
    }

    inline void insert(char *s, int id){
        ;
        ; s[i]; i++){
            int idx = (s[i] == 'D');
            if(!Node[now].Next[idx]){
                memset(Node[Size].Next, , sizeof(Node[Size].Next));
                Node[Size].fail = Node[Size].id = ;
                Node[now].Next[idx] = Size++;
            }
            now = Node[now].Next[idx];
        }
        Node[now].id |= (<<id);
    }

    inline void BuildFail(){
        Node[].fail = ;
        ; i<Letter; i++){
            ].Next[i]){
                Node[Node[].Next[i]].fail = ;
                que.push(Node[].Next[i]);
            }].Next[i] = ;
        }
        while(!que.empty()){
            int top = que.front(); que.pop();
            Node[top].id |= Node[Node[top].fail].id;
            ; 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;

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

    dp[][][][] = ;

    ; i<=n; i++){
        ; j<=m; j++){
            ; k<ac.Size; k++){
                ; l<; l++){
                    ){
                        ];
                        ];
                        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;
                    }
                }
            }
        }
    }

    ;
    ; i<ac.Size; i++){
        ans += dp[n][m][i][];
        ans %= MOD;
    }
    return ans%MOD;
}
];
int main(void)
{
    int nCase;
    scanf("%d", &nCase);
    while(nCase--){
        scanf("%d %d", &m, &n);
        ac.init();
        ; i<; i++){
            scanf("%s", S);
            ac.insert(S, i);
        }ac.BuildFail();
        printf("%d\n", Solve());
    }
    ;
}