hdu 2825 Wireless Password(AC自动机+状压DP)

题目链接：hdu 2825 Wireless Password

题目大意：N，M，K，M个字符串作为关键码集合，现在要求长度为N，包含K个以上的关键码的字符串有多少个。

解题思路：AC自动机+dp，滚动数组，因为关键码个数不会超过10个，所以我们用二进制数表示匹配的状态。dp[i][j][k]

表示到第i个位置，j节点，匹配k个字符串。

#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long ll;

const int maxn = 255;
const int sigma_size = 26;
const int mod = 20090717;

inline int bitcount (int x) {
return x == 0 ? 0 : bitcount(x>>1) + (x&1);
}

struct Aho_Corasick {
int sz, g[maxn][sigma_size];
int tag[maxn], fail[maxn], last[maxn];
int dp[2][maxn][1030];

void init();
int idx(char ch);
void insert(char* str, int k);
void getFail();
void match(char* str);
int put(int u);
int solve();
}AC;

int N, M, K;

int main () {
while (scanf("%d%d%d", &N, &M, &K) == 3 && N + M + K) {
char w[30];
AC.init();
for (int i = 1; i <= M; i++) {
scanf("%s", w);
AC.insert(w, i);
}
if (K > M)
printf("0\n");
else
printf("%d\n", AC.solve());
}
return 0;
}

int Aho_Corasick::solve() {
getFail();
memset(dp[0], 0, sizeof(dp[0]));
dp[0][0][0] = 1;

for (int x = 0; x < N; x++) {
int now = x&1;
int nxt = now^1;
memset(dp[nxt], 0, sizeof(dp[nxt]));

for (int i = 0; i < sz; i++) {
for (int k = 0; k < (1<<M); k++) {
if (dp[now][i][k] == 0)
continue;

for (int j = 0; j < sigma_size; j++) {
int u = i;
while (u && g[u][j] == 0)
u = fail[u];

u = g[u][j];

int d = tag[u];
dp[nxt][u][k|d] = (dp[nxt][u][k|d] + dp[now][i][k]) % mod;
}
}
}
}

int n = 0, v[1030];
memset(v, 0, sizeof(v));
for (int i = 0; i < (1<<M); i++)
if (bitcount(i) >= K)
v[n++] = i;

int ans = 0, d = N&1;
for (int u = 0; u < sz; u++) {
for (int i = 0; i < n; i++)
ans = (ans + dp[d][u][v[i]]) % mod;
}
return ans;
}

void Aho_Corasick::init() {
sz = 1;
tag[0] = 0;
memset(g[0], 0, sizeof(g[0]));
}

int Aho_Corasick::idx(char ch) {
return ch - 'a';
}

int Aho_Corasick::put(int u) {
return 0;
}

void Aho_Corasick::insert(char* str, int k) {
int u = 0, n = strlen(str);

for (int i = 0; i < n; i++) {
int v = idx(str[i]);
if (g[u][v] == 0) {
tag[sz] = 0;
memset(g[sz], 0, sizeof(g[sz]));
g[u][v] = sz++;
}
u = g[u][v];
}
tag[u] = (1<<(k-1));
}

void Aho_Corasick::match(char* str) {
int n = strlen(str), u = 0;
for (int i = 0; i < n; i++) {
int v = idx(str[i]);
while (u && g[u][v] == 0)
u = fail[u];

u = g[u][v];
}
}

void Aho_Corasick::getFail() {
queue<int> que;

for (int i  = 0; i < sigma_size; i++) {
int u = g[0][i];
if (u) {
fail[u] = last[u] = 0;
que.push(u);
}
}

while (!que.empty()) {
int r = que.front();
que.pop();

for (int i = 0; i < sigma_size; i++) {
int u = g[r][i];

if (u == 0) {
g[r][i] = g[fail[r]][i];
continue;
}

que.push(u);
int v = fail[r];
while (v && g[v][i] == 0)
v = fail[v];

fail[u] = g[v][i];
tag[u] |= tag[fail[u]];
//last[u] = tag[fail[u]] ? fail[u] : last[fail[u]];
}
}
}