字符串上的动态规划：

按顺序处理准考证号每一位，

设f[i][j]表示：准考证号前i位中 后j位与不吉利数的前j位相同时，前i位的方案数 

那么答案ans=f[n][0]+f[n][1]+…+f[n][m-1]

f[i][j]的准确含义：

1.f[i][j]表示的每种方案不仅与其后j位有关，还应保证不含不吉利数 

2.为避免重复，f[i][j]表示的每种方案都不含长度大于j且与不吉利数的前缀相同 的后缀 

 否则就会出现：从1到m标号，不吉利数为123124时，f[i][2]计数的方案包含f[i][5]计数的方案 的情况 

状态转移：

f[i][j]只能由f[i-1][k]得到，相当于填完第i-1位后，将其后缀k(长为k的后缀)后面新添一位num，之后这个i位数的 与不吉利数前缀相同的最长后缀是：后缀j

i>=1时：f[i][j]=f[i-1][0]*a[0][j]+f[i-1][1]*a[1][j]+…+f[i-1][m-1]*a[m-1][j]

        比如：还是假设不吉利数为123124，那么 f[i][3]=f[i-1][2]+f[i-1][5]，因为 f[i-1][2]末尾的*****12不能是**12312，所以需要f[i-1][5]补充 

        但若不吉利数为123123，那么 f[i][3]=f[i-1][2]，因为 f[i][3]末尾的*****123不能是**123123

i==0时：f[0][0]=1,f[0][其他]=0

其中，a[k][j]就表示上面提到的num能取几个值，可以用kmp算法预处理出来，它是一个矩阵 

这样就可以不重不漏地计数了 

再来个矩阵加速：f[i][j]求法是个线性齐次递推式，可以构造成矩阵 

如果有问题，欢迎和我交流。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int next[25]={0},hash[155]={0};
char t[25]={0};
int m,mod;
struct juzhen
{
	int s[25][25];
	juzhen()
	{
		memset(s,0,sizeof(s));
	}
};
juzhen A,Z;
juzhen cheng(juzhen A,juzhen B) 
{
	juzhen res;
	int i,j,k;
	for(i=0;i<m;i++)
		for(j=0;j<m;j++)
		{
			for(k=0;k<m;k++)
				res.s[i][j]+=A.s[i][k]*B.s[k][j];
			res.s[i][j]%=mod;
		}
	return res;
}
juzhen ksm(juzhen A,int n)
{
	juzhen res;
	if(n==1) return A;
	res=ksm(A,n/2);
	res=cheng(res,res);
	if(n%2==1) res=cheng(res,A);
	return res;
}
int main()
{
	int n,i,j,sum,ans=0;
	scanf("%d%d%d\n",&n,&m,&mod);
	for(i=1;i<=m;i++)
		scanf("%c",&t[i]);
	next[1]=next[2]=1;
	for(i=2;i<m;i++)
	{
		j=next[i];
		while(j>1&&t[i]!=t[j]) j=next[j];
		if(t[j]==t[i]) next[i+1]=j+1;
		else next[i+1]=1;
	}
	Z.s[0][0]=1;//f[0][0]==1
	for(i=0;i<m;i++)//初始化a[][]数组 
	{
		j=i+1;
		sum=A.s[i][j]=1;
		hash[t[j]]=i+1;
		while(j!=1)
		{
			j=next[j];
			if(hash[t[j]]!=i+1)
			{
				A.s[i][j]=1;
				hash[t[j]]=i+1;
				sum++;//每个长度为j(非0)的后缀对应一种填法 
			}
		}
		A.s[i][0]=10-sum;//第i位总共10种填法，把用过的数字去掉 
	}
	Z=cheng(Z,ksm(A,n));
	for(i=0;i<m;i++)
		ans+=Z.s[0][i];
	printf("%d",ans%mod);
	return 0;
}