AC自动机+矩阵（构造字符串 好）hdu2243

最新推荐文章于 2020-09-02 21:52:54 发布
最新推荐文章于 2020-09-02 21:52:54 发布
阅读量462 收藏 1
点赞数
分类专栏： 数学 AC自动机 矩阵快速幂
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010660276/article/details/39057029
版权

F.A.Q
Hand In Hand
Online Acmers
Forum | Discuss
Statistical Charts
Problem Archive
Realtime Judge Status
Authors Ranklist
 
      C/C++/Java Exams     
ACM Steps
Go to Job
Contest LiveCast
ICPC@China
Best Coder beta
VIP | STD Contests
Virtual Contests 
    DIY | Web-DIY beta
Recent Contests
BestCoder官方QQ群：385386683 欢迎加入~
寻人启事：2014级新生看过来！

考研路茫茫——单词情结

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3567    Accepted Submission(s): 1030


Problem Description
背单词，始终是复习英语的重要环节。在荒废了3年大学生涯后，Lele也终于要开始背单词了。
一天，Lele在某本单词书上看到了一个根据词根来背单词的方法。比如"ab",放在单词前一般表示"相反，变坏，离去"等。

于是Lele想，如果背了N个词根，那这些词根到底会不会在单词里出现呢。更确切的描述是：长度不超过L，只由小写字母组成的，至少包含一个词根的单词，一共可能有多少个呢？这里就不考虑单词是否有实际意义。

比如一共有2个词根 aa 和 ab ，则可能存在104个长度不超过3的单词，分别为
(2个) aa,ab,
(26个)aaa,aab,aac...aaz,
(26个)aba,abb,abc...abz,
(25个)baa,caa,daa...zaa,
(25个)bab,cab,dab...zab。

这个只是很小的情况。而对于其他复杂点的情况，Lele实在是数不出来了，现在就请你帮帮他。
 

Input
本题目包含多组数据，请处理到文件结束。
每组数据占两行。
第一行有两个正整数N和L。(0<N<6,0<L<2^31)
第二行有N个词根，每个词根仅由小写字母组成，长度不超过5。两个词根中间用一个空格分隔开。
 

Output
对于每组数据，请在一行里输出一共可能的单词数目。
由于结果可能非常巨大，你只需要输出单词总数模2^64的值。
 

Sample Input 
      
      

       
       2 3
aa ab
1 2
a
 

Sample Output 
      
      

       
       104
52


题意：求长度最多为L并且至少包含一个给出字符串的有多少个

思路：这个题跟poj2778基本一样，我们只需要先求出不包含的有多少个，然后用总的去减就可以得到结果

需要注意的：

1.因为要求长度不大于L的，所以相当于求A+A^2+A^3+...+A^L,这个有三种方法

a.可以用倍增法，二分求解

b.|A  1|                  |A^n  1+A+A^2+A^3+...+A^(n-1)|

   |0  1|的n次方为   |0                                          1|

c.这个方法刚开始没太看懂，自己摸你一下就知道了

  |a1  a2  1|

  |a3  a4  1|

  |0    0   1|的N次方的和就是1+A+A^2+A^3+...+A^n的元素的和

2.2^64取模，直接定义成unsigned long long截取就行了


a方法：

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
typedef unsigned long long LL;
const int maxn=50;
const int SIGMA_SIZE=26;
int N,L;
char s[20];

struct Matrix
{
    LL mat[30][30];
    int n;
    Matrix(int x)
    {
        memset(mat,0,sizeof(mat));
        n=x;
    }
    Matrix(){}
    Matrix operator*(Matrix a)
    {
        Matrix res(n);
        for(int k=0;k<n;k++)
        {
            for(int i=0;i<n;i++)
            {
                if(mat[i][k]==0)continue;
                for(int j=0;j<n;j++)
                {
                    //if(a.mat[j][k]==0)continue;
                    res.mat[i][j]=(res.mat[i][j]+mat[i][k]*a.mat[k][j]);
                }
            }
        }
        return res;
    }
    Matrix operator+(Matrix A)
    {
        Matrix res(A.n);
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            res.mat[i][j]=(mat[i][j]+A.mat[i][j]);
        return res;
    }
};
Matrix A;

Matrix pow_mul(Matrix A,LL x)
{
    Matrix res(A.n);
    for(int i=0;i<=res.n;i++)res.mat[i][i]=1;
    while(x)
    {
        if(x&1)res=res*A;
        A=A*A;
        x>>=1;
    }
    return res;
}
Matrix pow_sum(LL x)
{
    if(x==1)return A;
    Matrix tmp=pow_sum(x/2);
    Matrix sum=(tmp+pow_mul(A,x/2)*tmp);
    if(x&1)sum=(sum+pow_mul(A,x));
    return sum;
}
struct AC
{
    int ch[maxn][26],val[maxn];
    int fail[maxn],last[maxn];
    int sz;
    void clear(){memset(ch[0],0,sizeof(ch[0]));sz=1;}
    int idx(char x){return x-'a';}
    void insert(char *s)
    {
        int n=strlen(s);
        int u=0;
        for(int i=0;i<n;i++)
        {
            int c=idx(s[i]);
            if(!ch[u][c])
            {
                memset(ch[sz],0,sizeof(ch[sz]));
                val[sz]=0;
                ch[u][c]=sz++;
            }
            u=ch[u][c];
        }
        val[u]=1;
    }
    void getfail()
    {
        queue<int> q;
        fail[0]=0;
        int u=0;
        for(int i=0;i<SIGMA_SIZE;i++)
        {
            u=ch[0][i];
            if(u){fail[u]=last[u]=0;q.push(u);}
        }
        while(!q.empty())
        {
            int r=q.front();q.pop();
            if(val[fail[r]])val[r]=1;
            for(int c=0;c<SIGMA_SIZE;c++)
            {
                u=ch[r][c];
                if(!u){ch[r][c]=ch[fail[r]][c];continue;}
                q.push(u);
                int v=fail[r];
                while(v&&!ch[v][c])v=fail[v];
                fail[u]=ch[v][c];
                last[u]=val[fail[u]]?fail[u]:last[fail[u]];
            }
        }
    }
    Matrix getMatrix()
    {
        Matrix res(sz-1);
        for(int i=0;i<sz;i++)
            for(int j=0;j<SIGMA_SIZE;j++)
            if(!val[ch[i][j]])res.mat[i][ch[i][j]]++;
        return res;
    }
}ac;


int main()
{
    while(scanf("%d%d",&N,&L)!=EOF)
    {
        ac.clear();
        for(int i=1;i<=N;i++)
        {
            scanf("%s",s);
            ac.insert(s);
        }
        ac.getfail();
        A=ac.getMatrix();
        A=pow_sum(L);
        LL res=0;
        for(int i=0;i<A.n;i++)res+=A.mat[0][i];
        A=Matrix(2);
        A.mat[0][0]=26;
        A.mat[1][0]=A.mat[1][1]=1;
        A=pow_mul(A,L);
        LL ans=0;
        ans+=A.mat[0][0]+A.mat[1][0];
        ans--;
        cout<<ans-res<<endl;
    }
    return 0;
}
b方法： 

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
typedef unsigned long long LL;
const int maxn=50;
const int SIGMA_SIZE=26;
int N,L;
char s[20];

struct Matrix
{
    LL mat[61][61];
    int n;
    Matrix(int x)
    {
        memset(mat,0,sizeof(mat));
        n=x;
    }
    Matrix(){}
    Matrix operator*(Matrix a)
    {
        Matrix res(n);
        for(int k=0;k<n;k++)
        {
            for(int i=0;i<n;i++)
            {
                if(mat[i][k]==0)continue;
                for(int j=0;j<n;j++)
                    res.mat[i][j]=(res.mat[i][j]+mat[i][k]*a.mat[k][j]);
            }
        }
        return res;
    }
    Matrix operator+(Matrix A)
    {
        Matrix res(A.n);
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            res.mat[i][j]=(mat[i][j]+A.mat[i][j]);
        return res;
    }
};
Matrix A;

Matrix pow_mul(Matrix A,LL x)
{
    Matrix res(A.n);
    for(int i=0;i<=res.n;i++)res.mat[i][i]=1;
    while(x)
    {
        if(x&1)res=res*A;
        A=A*A;
        x>>=1;
    }
    return res;
}
struct AC
{
    int ch[maxn][26],val[maxn];
    int fail[maxn],last[maxn];
    int sz;
    void clear(){memset(ch[0],0,sizeof(ch[0]));sz=1;}
    int idx(char x){return x-'a';}
    void insert(char *s)
    {
        int n=strlen(s);
        int u=0;
        for(int i=0;i<n;i++)
        {
            int c=idx(s[i]);
            if(!ch[u][c])
            {
                memset(ch[sz],0,sizeof(ch[sz]));
                val[sz]=0;
                ch[u][c]=sz++;
            }
            u=ch[u][c];
        }
        val[u]=1;
    }
    void getfail()
    {
        queue<int> q;
        fail[0]=0;
        int u=0;
        for(int i=0;i<SIGMA_SIZE;i++)
        {
            u=ch[0][i];
            if(u){fail[u]=last[u]=0;q.push(u);}
        }
        while(!q.empty())
        {
            int r=q.front();q.pop();
            if(val[fail[r]])val[r]=1;
            for(int c=0;c<SIGMA_SIZE;c++)
            {
                u=ch[r][c];
                if(!u){ch[r][c]=ch[fail[r]][c];continue;}
                q.push(u);
                int v=fail[r];
                while(v&&!ch[v][c])v=fail[v];
                fail[u]=ch[v][c];
                last[u]=val[fail[u]]?fail[u]:last[fail[u]];
            }
        }
    }
    Matrix getMatrix()
    {
        Matrix res(sz+1);
        for(int i=0;i<sz;i++)
            for(int j=0;j<SIGMA_SIZE;j++)
            if(!val[ch[i][j]])res.mat[i][ch[i][j]]++;
        return res;
    }
}ac;

Matrix MatrixMul(Matrix A)
{
    Matrix res(A.n*2);
    for(int i=0;i<A.n;i++)
        for(int j=0;j<A.n;j++)res.mat[i][j]=A.mat[i][j];
    for(int i=0;i<A.n;i++)res.mat[i][i+A.n]=res.mat[i+A.n][i+A.n]=1;
    return res;
}
int main()
{
    while(scanf("%d%d",&N,&L)!=EOF)
    {
        ac.clear();
        for(int i=1;i<=N;i++)
        {
            scanf("%s",s);
            ac.insert(s);
        }
        ac.getfail();
        A=MatrixMul(ac.getMatrix());
        A=pow_mul(A,L);
        LL res=0;
        for(int i=0;i<A.n;i++)res+=A.mat[0][i];
        A=Matrix(2);
        A.mat[0][0]=26;
        A.mat[1][0]=A.mat[1][1]=1;
        A=pow_mul(A,L);
        LL ans=0;
        ans+=A.mat[0][0]+A.mat[1][0];
        cout<<ans-res<<endl;
    }
    return 0;
}


c方法：

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
typedef unsigned long long LL;
const int maxn=50;
const int SIGMA_SIZE=26;
int N,L;
char s[20];

struct Matrix
{
    LL mat[30][30];
    int n;
    Matrix(int x)
    {
        memset(mat,0,sizeof(mat));
        n=x;
    }
    Matrix(){}
    Matrix operator*(Matrix a)
    {
        Matrix res(n);
        for(int k=0;k<n;k++)
        {
            for(int i=0;i<n;i++)
            {
                if(mat[i][k]==0)continue;
                for(int j=0;j<n;j++)
                    res.mat[i][j]=(res.mat[i][j]+mat[i][k]*a.mat[k][j]);
            }
        }
        return res;
    }
    Matrix operator+(Matrix A)
    {
        Matrix res(A.n);
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            res.mat[i][j]=(mat[i][j]+A.mat[i][j]);
        return res;
    }
};
Matrix A;

Matrix pow_mul(Matrix A,LL x)
{
    Matrix res(A.n);
    for(int i=0;i<=res.n;i++)res.mat[i][i]=1;
    while(x)
    {
        if(x&1)res=res*A;
        A=A*A;
        x>>=1;
    }
    return res;
}
struct AC
{
    int ch[maxn][26],val[maxn];
    int fail[maxn],last[maxn];
    int sz;
    void clear(){memset(ch[0],0,sizeof(ch[0]));sz=1;}
    int idx(char x){return x-'a';}
    void insert(char *s)
    {
        int n=strlen(s);
        int u=0;
        for(int i=0;i<n;i++)
        {
            int c=idx(s[i]);
            if(!ch[u][c])
            {
                memset(ch[sz],0,sizeof(ch[sz]));
                val[sz]=0;
                ch[u][c]=sz++;
            }
            u=ch[u][c];
        }
        val[u]=1;
    }
    void getfail()
    {
        queue<int> q;
        fail[0]=0;
        int u=0;
        for(int i=0;i<SIGMA_SIZE;i++)
        {
            u=ch[0][i];
            if(u){fail[u]=last[u]=0;q.push(u);}
        }
        while(!q.empty())
        {
            int r=q.front();q.pop();
            if(val[fail[r]])val[r]=1;
            for(int c=0;c<SIGMA_SIZE;c++)
            {
                u=ch[r][c];
                if(!u){ch[r][c]=ch[fail[r]][c];continue;}
                q.push(u);
                int v=fail[r];
                while(v&&!ch[v][c])v=fail[v];
                fail[u]=ch[v][c];
                last[u]=val[fail[u]]?fail[u]:last[fail[u]];
            }
        }
    }
    Matrix getMatrix()
    {
        Matrix res(sz+1);
        for(int i=0;i<sz;i++)
            for(int j=0;j<SIGMA_SIZE;j++)
            if(!val[ch[i][j]])res.mat[i][ch[i][j]]++;
        for(int i=0;i<=sz;i++)res.mat[i][sz]=1;
        return res;
    }
}ac;


int main()
{
    while(scanf("%d%d",&N,&L)!=EOF)
    {
        ac.clear();
        for(int i=1;i<=N;i++)
        {
            scanf("%s",s);
            ac.insert(s);
        }
        ac.getfail();
        A=ac.getMatrix();
        A=pow_mul(A,L);
        LL res=0;
        for(int i=0;i<A.n;i++)res+=A.mat[0][i];
        A=Matrix(2);
        A.mat[0][0]=26;
        A.mat[1][0]=A.mat[1][1]=1;
        A=pow_mul(A,L);
        LL ans=0;
        ans+=A.mat[0][0]+A.mat[1][0];
        cout<<ans-res<<endl;
    }
    return 0;
}





u010660276
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AC自动机 C语言 ACM 字符串匹配|AC自动机C语言.rar
10-04
解耦了的AC自动机模板，可工程使用。内包含头文件与源文件与使用方法，参照使用方法即可直接调用。 纯C代码，不依赖任何外部库。
[AC自动机+矩阵快速幂] poj2778 与 hdu2243
ECNU_SF的博客
04-01 159
poj 2778link 题面   给定了 mmm 个 A, C, G, T 构成的基因片段(字符串)，让你构造一个不含这 mmm 个片段的，长度为 nnn 的由A, C, G, T构成的字符串，问有几种方式。 分析   这题刚开始以为有关动态规划哈希什么的，看了题解才发现这是AC自动机的构造神题。AC自动机的基本介绍网上有很多，这里就不赘述。   首先对于这 mmm 个字符串，可以建一个 AC 自动机，就如普通的AC自动机一样，维护 fail 数组，用 tr[i][j]tr[i][j]tr[i][j] 表
HDU 2243 AC自动机+矩阵快速幂
zhenlingcn的博客
08-10 254
题意中文题，不解释题解这道题其实和POJ 2778是一样的，只是需要对矩阵有着更深刻的理解而已。我们很容易便能像POJ 2778一样求出来不包含条件字符串的字符串方案。只是题目中要求长度小于等于L，所以我们可以在矩阵中手动加一个点，这个点允许从任何状态转移而来。这点的意义表示字符串终止。也就是说如果字符串转移到这个点时候小于L，那么字符串最终长度小于L。求出来小于等于L，不包含条件字符串的方案数以后
HDU2243 AC自动机 + 矩阵快速幂
forward77
09-02 134
题意：给定你m个模式串，问你长度小于等于L的符串中，有多少包含着这些模式串。 思路：这个题的思路求解类似于POJ2778，只不过那一题求未包含模式串，而这一题求的是包含模式串的数量，可构造字符串的总数量减去不包含模式串的字符串数量，就可以得到包含模式串的数量。 但还有一个问题就是L < 2^31,规模太大 肯定不能直接求解小于等于L的字符串的数量。 由此可得这个问题便可以用矩阵快速幂求解来完成，因此这个题目就是AC自动build一下，再加上矩阵快速幂的构造来完成的，很类似与poj2778，注意问题也和
HDU 2243 考研路茫茫――单词情结(AC自动机+矩阵快速幂)
smilestruggler_Fly To Higher
02-03 253
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2243   题目大意：   给m个字符串，求长度不超过n且包括这m个字符串的字符串个数。   题目思路：   推荐博客：传送门   跟POJ 2778非常像，之前那个题是求不包括的，这里是求包括的，那非常自然就想到可以用所有的情况数减去不包括的情况数。所有的情况数就是长度为1的所有情...
hdu 3341(ac自动机+状态压缩)
10-29
hdu 3341(ac自动机+状态压缩) 题意：容易理解... 思路：首先一开始容易想到要用到dp，开设一个dp[41][41][41][41][501]的数组来解决，但是明显内存已经超出范围了，于是就想如何减少内存呢？只要知道A、T、C、G其中...
AhoCorasickAutomation.rar_字符串字典_有限状态自动机
09-23
用来进行字符串的匹配，结合了字典树等算法，提高了时间复杂度
AC自动机_AC自动机模板_
09-30
供信息学奥林匹克竞赛选手使用 AC自动机模板
字符串处理- AC 自动机.rar
09-16
字符串处理- AC 自动机.rar
莫比乌斯函数
龙崎的专栏
06-11 4417
在数论中的积性函数：对于正整数n的一个算术函数 f(n)，若f(1)=1，且当a,b互质时f(ab)=f(a)f(b)，在数论上就称它为积性函数。若对于某积性函数 f(n) ，就算a, b不互质，也有f(ab)=f(a)f(b)，则称它为完全积性的。 φ(n) －欧拉函数，计算与n互质的正整数之数目 μ(n) －莫比乌斯函数，关于非平方数的质因子数目
2015百度之星初赛第二场（1005 dp，1004 数学）
龙崎的专栏
05-31 1290
序列变换    Accepts: 695    Submissions: 3322  Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Problem Description 我们有一个数列A1,A2...An，你现在要求修改数量最少的
hdu - 5238 Calculator（线段树+中国剩余定理）线段树好题
龙崎的专栏
06-06 1159
原来还不知道中国剩余定理能干什么用，先上几篇中国剩余定理的介绍 下面内容转自：http://wenku.baidu.com/link?url=g1Hiu6UtSoOR6Y3tiHpn5M3_HPnuoTN_xpm1GPFHAkZB-nW0m61vunMmNIqxacAke3jPmMvE_M4gWGd25D0C1ZthZTuzx-u1DHSbunP8qrS “中国剩余定理”算理及其应
hdu - 5239 Doom（线段树+数论）
龙崎的专栏
06-04 1155
Doom Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 524288/524288 K (Java/Others) Total Submission(s): 426    Accepted Submission(s): 96 Problem Description THE END IS COMINGGGGGG!
2013 ACM-ICPC吉林通化全国邀请赛（hdu 4493 - 4599）（并查集+dp+数学+判奇环+差分约束）
龙崎的专栏
07-11 1088
D-City Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65535/65535 K (Java/Others) Total Submission(s): 2437 Accepted Submission(s): 859Problem Description Luxer is a really bad guy. He d
数学（hdu3208 - Integer’s Power）
龙崎的专栏
05-03 983
Online Judge Online Exercise Online Teaching Online Contests Exercise Author F.A.Q Hand In Hand Online Acmers Forum | Discuss Statistical Charts Problem Archive Realtime Judge Statu
2015百度之星资格赛
龙崎的专栏
05-26 898
大搬家 Accepts: 1516 Submissions: 6288 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Problem Description 近期B厂组织了一次大搬家，所有人都要按照指示换到指定的座位上。指示的内容是坐在位置i上
高斯消元（开关灯问题）poj1222
龙崎的专栏
12-16 829
Online Judge Problem Set Authors Online Contests User Web Board Home Page F.A.Qs Statistical Charts Problems Submit Problem Online Status Prob.ID: Register Update your info Au
数学（乘法逆元）hdu5225
龙崎的专栏
05-10 824
Tom and permutation Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 201    Accepted Submission(s): 87 Problem Description Tom has learn
用自动机识别输入字符串
最新发布
05-18
好的，我可以为您介绍如何使用自动机来识别输入字符串。 自动机是一种计算模型，它可以接受输入字符串并根据预先定义的规则决定输入字符串是否有效。在自动机中，我们将输入字符串看作是一个字符序列，并定义一组...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值