ac自动机系列
hdu 2234 考研路茫茫——单词情结
求长度不超过l的串中，包含一些单词的串的个数
首先构造自动机，然后把每个包含了终结态的状态都置为终结态，比如abc b，那么ab，abc，b都是终结态，
然后构造矩阵A，Ax就是长度为一时得到的结果A^n为长度为n结果
其中x=[0,1,.........0]第一个表示终结状态，第二个表示起始状态，最后一个表示为长度小于当前长度的终结态数量之和（终结态表示这个串包含了至少一个单词）
接着构造A
对自动机上任意一个状态转移u->v如果u是终结态就不转移，否则A[v][u]++,
然后就用矩阵快速幂来求解A^n
最后的答案就是A[0][1]+A[s][1] ==== 因为只有x[1] =1其他=0，表示当前长度终结态数量+小于当前长度终结态数量 = 最后答案
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 40
int child[maxn][26],fail[maxn],state[maxn],flag[maxn];
int cnt;
void init(){
memset(child,0,sizeof(child));
memset(flag, 0,sizeof(flag));
memset(fail, 0,sizeof(fail));
cnt = 2;
for(int i = 0;i < 26;i++)
child[0][i] = 1;
}
char word[maxn];
void add(int u,int i){
int x = word[i]-'a';
if(word[i]=='\0'){
flag[u] = 1;
return ;
}
if(child[u][x]==0)child[u][x] = cnt++;
add(child[u][x],i+1);
}
#define ll unsigned __int64
int queue[100];
void build(){
int front=0,rear=0;
queue[front++] = 1;
while(front != rear){
int u = queue[rear++];
flag[u] |= flag[fail[u]];
for(int i = 0;i < 26;i++){
if(child[u][i]==0) child[u][i] = child[fail[u]][i];
else {
int v = child[u][i];
fail[v] = child[fail[u]][i];
queue[front++] = v;
}
}
}
}
struct Matrix{
ll res[30][30];
ll n;
void init(){
memset(res,0,sizeof(res));
}
};
Matrix operator*(Matrix a,Matrix b){
Matrix c;
c.init();
c.n = a.n;
for(int i = 0;i < a.n;i++){
for(int j = 0;j < a.n ;j++)
for(int k = 0;k < a.n ;k++)
c.res[i][j]+=a.res[i][k]*b.res[k][j];
}
return c;
}
int main(){
ll n,l;
while(cin>>n>>l){
init();
for(int i = 0;i < n;i++){
cin>>word;
add(1,0);
}
build();
int s = 1;
for(int i = 1;i < cnt; i++)
if(flag[i]==0)state[i]=s++;
else state[i] = 0;
Matrix a;
a.init();
for(int i = 1;i < cnt; i++){
for(int j = 0;j < 26;j++){
int u = state[child[i][j]];
int v = state[i];
if(v == 0 ) continue;
a.res[u][v]++;
}
}
a.res[0][0] = 26;
a.res[s][0] = 1;
a.res[s][s] = 1;
Matrix ans;
ans.init();
ans.n = a.n = s+1;
for(int i = 0;i < 30;i++) ans.res[i][i] = 1;
while(l){
if(l&1) ans=a*ans;
a=a*a;
l/=2;
}
ll f = ans.res[s][1]+ans.res[0][1];
printf("%I64u\n",f);
}
return 0;
}
hdu 2896 病毒侵袭
求一个串包含哪些字串，根据题目意思的话，就不用想太多了，不会有重叠情况的，
比如abc bc这种的。
解题：把字串建立ac自动机，是单词的终结态就标记为该单词的标号，
然后对于每个串走一遍自动机，如果这个标号没有出现过就加入ans
由于ans的大小<3 就直接判定就行了
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
using namespace std;
#define maxn 100007
struct Node{
int child[128];
int flag;
Node*fail;
};
Node node[maxn];
int cnt;
int newNode(){
memset(node[cnt].child,-1,sizeof(node[cnt].child));
node[cnt].flag = 0;
return cnt++;
}
vector<int>ans;
char word[maxn];
int super,root;
void insert(int u,int p,int flag){
if(word[p] == '\0'){
node[u].flag = flag;
return ;
}
int l = word[p];
if(node[u].child[l] == -1){
node[u].child[l] = newNode();
}
insert(node[u].child[l],p+1,flag);
}
int queue[maxn];
void build(){
for(int i = 0;i < 128;i++)
node[super].child[i] = root;
node[root].fail = &node[super];
int front = 0,rear=0;
queue[front++] = root;
while(front > rear){
int u = queue[rear++];
for(int i = 0;i < 128;i++){
if(node[u].child[i] == -1){
node[u].child[i] = node[u].fail->child[i];
}
else {
node[node[u].child[i]].fail = &node[node[u].fail->child[i]];
queue[front++] = node[u].child[i];
}
}
}
}
void find(){
int len=strlen(word);
int u = root;
for(int i = 0;i < len; i++){
u = node[u].child[word[i]];
if(node[u].flag != 0){
int flag = 1;
for(int i = 0;i < ans.size() ;i++)
if(ans[i] == node[u].flag) flag = 0;
if(flag == 1) ans.push_back(node[u].flag);
}
if(ans.size() == 4)return ;
}
}
int main(){
int total,n;
while(scanf("%d",&n)!=EOF){
cnt = 0;
super = newNode();
root = newNode();
for(int i = 1;i <= n;i++){
scanf("%s",word);
insert(root,0,i);
}
build();
scanf("%d",&n);
int total = 0;
for(int i = 1;i <= n;i++){
scanf("%s",word);
ans.clear();
ans.push_back(0);
find();
if(ans.size() > 1){
sort(ans.begin(),ans.end());
printf("web %d:",i);
for(int j = 1;j < ans.size();j++)
printf(" %d",ans[j]);
printf("\n");
total++;
}
}
printf("total: %d\n",total);
}
return 0;
}
hdu 2222 Keywords Search
求一个串包含几个单词，解法：构建ac自动机是单词结尾的标记一下
然后走ac自动机，走到一个状态访问fail节点，如果mark！=-就加上mark，然后mark=-1
这样经过的状态就不会重复计算了，
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
struct Node{
Node*ch[26],*fail;
int mark,id;
}word[600001];
int cnt;
Node*newNode(){
memset(&word[cnt],0,sizeof(word[0]));
word[cnt].id = cnt;
return &word[cnt++];
}
void insert(Node*root,char*s){
if(*s==0){root->mark++;return;}
int id = *s-'a';
if(root->ch[id] == 0) root->ch[id] = newNode();
insert(root->ch[id],s+1);
}
Node *super,*root;
void build(Node*root){
for(int i = 0;i < 26;i++)
super->ch[i] = root;
root->fail = super;
queue<Node*>Q;
Q.push(root);
while(!Q.empty()){
Node* q = Q.front();
Q.pop();
for(int i = 0;i < 26; i++){
if(q->ch[i] != NULL){
Q.push(q->ch[i]);
q->ch[i]->fail = q->fail->ch[i];
//cout<<(char)(i+'a')<<endl;
}
else q->ch[i] = q->fail->ch[i];
}
}
}
int autofind(char *s){
int ans = 0,id;
Node*rt = root,*p;
while(*s){
id = *s - 'a';
if(rt->ch[id] != root) rt = rt->ch[id];
else{
while(rt != root && rt->ch[id] == root)
rt = rt->fail;
}
p = rt;
while(p != root && p->mark != -1){
ans += p->mark;
p->mark = -1;
p = p->fail;
}
s++;
}
return ans;
}
char a[1000009];
int main(){
int t,n;
scanf("%d",&t);
while(t--){
cnt = 0;
super = newNode();
root = newNode();
scanf("%d",&n);
while(n--){
scanf("%s",a);
insert(root,a);
}
build(root);
scanf("%s",a);
int ans = autofind(a);
printf("%d\n",ans);
}
return 0;
}