[BZOJ 3530] [Sdoi2014] 数数 【AC自动机+DP】

题目链接：BZOJ - 3530

题目分析

明显是 AC自动机+DP，外加数位统计。

WZY 神犇出的良心省选题，然而去年我太弱..比现在还要弱得多..

其实现在做这道题，我自己也没想出完整解法..

就想出了个 O(l^3) 的做法：

完全按照数位统计的思想来，先统计长度不足 len 的数字的合法种类数，这个枚举开头，然后 AC 自动机 DP 一下，用 f[i][j] 表示到了第 i 位，在第 j 个节点上的合法数字个数。这样是 O(L^2)。

然后长度等于 n 的部分，就按照数位统计，一位位向后推，然后每次 O(L^2) DP 求，这样总的复杂度是 O(L^3)。

注意不能走包含模式串的节点，首先 Trie 中模式串的节点肯定不能走，其次，如果沿着一个节点的 Fail 链一直向上走，只要链上有一个节点是不能走的，那么这个节点也就不能走了。

所以需要从每个的节点开始，逆着 Fail 的边 DFS 一下，如果当前状态下将经过的点全都 Ban 掉。但是数据好像比较弱，不加这个也是不会出问题的。

但是这样会弄错一种情况：比如有 123， 2 这两个串，然后它就沿着 -> 1 -> 2 一直向后匹配，没有匹配成功 123 ，但是其实已经包含了 2 这个串。

这样的复杂度只有70分。

正解的复杂度是 O(L^2) 的：对于长度不足 len 的数字，还是直接求，O(L^2)。

对于长度等于 len 的数字，我们就直接用一个 O(L^2) 的 DP 求出来，我们把状态增加一维， g[i][j][k] ，前两位是第 i 位，走到第 j 个节点，k 是一个 [0/1] 变量，表示这个状态是否是沿着 n 的每一位走过来。

这样我们就知道了，如果当前状态是依照 n 的每一位走过来，那么下一步就只能转移 [0, n[i+1]] 这些数字。否则可以转移所有的数字。这样就求出了小于等于 n 的所有合法数字。

总的复杂度是 O(L^2) 。

AC自动机+DP的一般做法：f[i][j] 表示走了 i 步，走到了第 j 个节点，有时还需要加第 3 维或更多。

然后 DP 的时候就是 枚举 i ，枚举 j，枚举转移到下一步的字符。

代码

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <cstdio>
#include <queue>

using namespace std;

const int MaxL = 1500 + 5, MaxNode = 15000 + 5, Mod = 1000000007;

int len, l, m, Index, Ans;
int f[MaxL][MaxNode], g[MaxL][MaxNode][2];

char S[MaxL], Ns[MaxL];

struct Trie
{
	int x, Idx;
	bool Ban;
	Trie *Fail, *Child[10];
} TA[MaxNode], *P = TA, *Root, *Zero;

Trie* NewNode(int Num = 0)
{
	++P;
	P -> x = Num;
	P -> Idx = ++Index;
	P -> Fail = NULL;
	P -> Ban = false;
	memset(P -> Child, 0, sizeof(P -> Child));
	return P;
}

void Insert(char *S, int l)
{
	int t;
	Trie *Now = Root;
	for (int i = 1; i <= l; ++i)
	{
		t = S[i] - ‘0‘;
		if (Now -> Child[t] == NULL)
			Now -> Child[t] = NewNode(t);
		Now = Now -> Child[t];
	}
	Now -> Ban = true;
}

struct Edge
{
	int v;
	Edge *Next;
} E[MaxNode], *PE = E, *Point[MaxNode];

inline void AddEdge(int x, int y)
{
	++PE; PE -> v = y;
	PE -> Next = Point[x]; Point[x] = PE;
}

bool Visit[MaxNode];

void DFS(int x, bool f)
{
	Visit[x] = true;
	TA[x].Ban = (TA[x].Ban) || f;
	for (Edge *j = Point[x]; j; j = j -> Next)
		DFS(j -> v, TA[x].Ban);
}

queue<Trie *> Q;

void Build_Fail()
{
	while (!Q.empty()) Q.pop();
	Q.push(Root);
	Trie *Now;
	while (!Q.empty())
	{
		Now = Q.front(); Q.pop();
		AddEdge(Now -> Fail -> Idx, Now -> Idx);
		for (int i = 0; i <= 9; ++i)
		{
			if (Now -> Child[i] == NULL) Now -> Child[i] = Now -> Fail -> Child[i];
			else
			{
				Now -> Child[i] -> Fail = Now -> Fail -> Child[i];
				Q.push(Now -> Child[i]);
			}
		}
	}
	for (int i = 1; i <= Index; ++i)
		if (!Visit[i]) DFS(i, TA[i].Ban);
}

void Usual_Disco()
{
	memset(f, 0, sizeof(f));
	for (int i = 1; i <= 9; ++i)
		if (Root -> Child[i] -> Ban == false)
			++f[1][Root -> Child[i] -> Idx];
	for (int i = 1; i < len; ++i)
		for (int j = 1; j <= Index; ++j)
		{
			if (TA[j].Ban) continue;
			Ans = (Ans + f[i][j]) % Mod;
			for (int t = 0; t <= 9; ++t)
				if (!TA[j].Child[t] -> Ban)
				{
					f[i + 1][TA[j].Child[t] -> Idx] += f[i][j];
					f[i + 1][TA[j].Child[t] -> Idx] %= Mod;
				}
		}
	memset(g, 0, sizeof(g));
	for (int i = 1; i < Ns[1] - ‘0‘; ++i)
		if (Root -> Child[i] -> Ban == false)
			++g[1][Root -> Child[i] -> Idx][0];
	if (Root -> Child[Ns[1] - ‘0‘] -> Ban == false)
		++g[1][Root -> Child[Ns[1] - ‘0‘] -> Idx][1];
	for (int i = 1; i <= len; ++i)
		for (int j = 1; j <= Index; ++j)
		{
			if (TA[j].Ban) continue;
			if (i == len)
			{
				Ans = (Ans + g[i][j][0]) % Mod;
				Ans = (Ans + g[i][j][1]) % Mod;
				continue;
			}
			for (int t = 0; t <= 9; ++t)
				if (!TA[j].Child[t] -> Ban)
				{
					g[i + 1][TA[j].Child[t] -> Idx][0] += g[i][j][0];
					g[i + 1][TA[j].Child[t] -> Idx][0] %= Mod;
				}
			for (int t = 0; t < Ns[i + 1] - ‘0‘; ++t)
				if (!TA[j].Child[t] -> Ban)
				{
					g[i + 1][TA[j].Child[t] -> Idx][0] += g[i][j][1];
					g[i + 1][TA[j].Child[t] -> Idx][0] %= Mod;
				}
			if (!TA[j].Child[Ns[i + 1] - ‘0‘] -> Ban)
			{
				g[i + 1][TA[j].Child[Ns[i + 1] - ‘0‘] -> Idx][1] += g[i][j][1];
				g[i + 1][TA[j].Child[Ns[i + 1] - ‘0‘] -> Idx][1] %= Mod;
			}
		}
}

int main()
{
	scanf("%s", Ns + 1);
	len = strlen(Ns + 1);
	scanf("%d", &m);
	Root = NewNode();
	Zero = NewNode();
	Root -> Fail = Zero;
	for (int i = 0; i <= 9; ++i) Zero -> Child[i] = Root;
	for (int i = 1; i <= m; ++i)
	{
		scanf("%s", S + 1);
		l = strlen(S + 1);
		Insert(S, l);
	}
	Build_Fail();
	Usual_Disco();
	Ans %= Mod;
	cout << Ans << endl;
	return 0;
}