[HDU 2825] Wireless Password （AC自动机+状态压缩DP）

最新推荐文章于 2020-03-30 21:16:35 发布

原创最新推荐文章于 2020-03-30 21:16:35 发布 · 342 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#acm #ac自动机 #dp

本文介绍了一道经典的AC自动机结合状态压缩DP的问题。题目要求计算特定长度且包含至少k个关键词的字符串数量。文章详细阐述了如何利用AC自动机构建关键词匹配树，并结合状态压缩动态规划求解。代码实现简洁高效。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

链接

HDU 2825

题意

给出若干个关键词，问长度为n并且含有至少k个关键词的字符串个数。

题解

ac自动机上状态压缩dp。
定义d[i][j][k]：长度为i、位于trie树中j节点、状态为k的字符串个数。
状态携带有含有哪些关键词的信息，由于关键词不超过10个，很容易在1<<10个状态内将其编码，然后通过“或运算”进行情况合并。
另外，这题不需要建立trie图，如果用trie图做状态转移貌似耗时会更长（没验证过，感兴趣的可以试试）。
这题目的dp方程写出来需要4层for循环，注意需要进行剪枝，不然会T。

状态转移方程：
d[i][next[j][k]][st | nd[next[j][k]]] += d[i-1][j][st]

代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
#define MAXL (111)
#define degree (26)
#define next naxt
int trieG[MAXL][MAXL];
struct Aho
{
    int next[MAXL][degree], nd[MAXL], fail[MAXL];
    int L, root;

    int newnode()
    {
        for(int i = 0; i < degree; i++)
            next[L][i] = -1;
        nd[L] = 0;
        return L++;
    }
    void init() { L = 0; root = newnode(); }
    void insert(char s[], int id)
    {
        int now = root;
        for(int i = 0, key, sz = strlen(s); i < sz; i++)
        {
            key = s[i] - 'a';
            if(next[now][key] == -1)
                next[now][key] = newnode();
            now = next[now][key];
        }
        nd[now] = (1<<id);
    }
    void build()
    {
        queue<int> que;
        fail[root] = root;
        for(int i = 0; i < degree; i++)
        if(next[root][i] == -1)
            next[root][i] = root;
        else
        {
            fail[next[root][i]] = root;
            que.push(next[root][i]);
        }
        while(!que.empty())
        {
            int now = que.front();
            que.pop();
            if(nd[fail[now]]) nd[now] |= nd[fail[now]];
            for(int i = 0; i < degree; i++)
            if(next[now][i] == -1)
                next[now][i] = next[fail[now]][i];
            else
            {
                fail[next[now][i]] = next[fail[now]][i];
                que.push(next[now][i]);
            }
        }
    }
} actree;
int d[26][MAXL][(1<<10) +1];
const int mod = 20090717;
inline int bits(int a)
{
    int ret = 0;
    while(a) {
        ret += (a & 1);
        a >>= 1;
    }
    return ret;
}
int main()
{
    int n, m, k;
    char keyword[20];
    while(cin >> n >> m >> k)
    {
        if(n + m + k == 0) break;
        actree.init();
        for(int i = 0; i < m; i++)
        {
            scanf("%s", keyword);
            actree.insert(keyword, i);
        }
        actree.build();
        for(int i = 0; i <= n; i++)
        for(int j = 0; j < actree.L; j++)
        for(int k = 0; k <= (1 << m); k++)
        d[i][j][k] = 0;
        d[0][0][0] = 1;
        for(int i = 1; i <= n; i++)
        for(int j = 0; j < actree.L; j++)
        for(int st = 0; st <= (1 << m); st++) if(d[i-1][j][st]) /// TLE
        for(int k = 0, now; k < degree; k++) {
            now = actree.next[j][k];
            d[i][now][st | actree.nd[now]] += d[i-1][j][st];
            d[i][now][st | actree.nd[now]] %= mod;
        }
        int ans = 0;
        for(int i = 0; i < actree.L; i++)
        for(int j = 0; j <= (1 << m); j++)
        if(bits(j) >= k) { ans = (ans + d[n][i][j]) % mod; }
        cout << ans << endl;
    }
    return 0;
}