HDU - 4758 Walk Through Squares (AC自己主动机+DP)

Description

  On the beaming day of 60th anniversary of NJUST, as a military college which was Second Artillery Academy of Harbin Military Engineering Institute before, queue phalanx is a special landscape.
  
  Here is a M*N rectangle, and this one can be divided into M*N squares which are of the same size. As shown in the figure below:
  01--02--03--04
  || || || ||
  05--06--07--08
  || || || ||
  09--10--11--12
  Consequently, we have (M+1)*(N+1) nodes, which are all connected to their adjacent nodes. And actual queue phalanx will go along the edges.
  The ID of the first node,the one in top-left corner,is 1. And the ID increases line by line first ,and then by column in turn ,as shown in the figure above.
  For every node,there are two viable paths:
  (1)go downward, indicated by ‘D‘;
  (2)go right, indicated by ‘R‘;
  The current mission is that, each queue phalanx has to walk from the left-top node No.1 to the right-bottom node whose id is (M+1)*(N+1).
In order to make a more aesthetic marching, each queue phalanx has to conduct two necessary actions. Let‘s define the action:
  An action is started from a node to go for a specified travel mode.
  So, two actions must show up in the way from 1 to (M+1)*(N+1).

  For example, as to a 3*2 rectangle, figure below:
    01--02--03--04
    || || || ||
    05--06--07--08
    || || || ||
    09--10--11--12
  Assume that the two actions are (1)RRD (2)DDR

  As a result , there is only one way : RRDDR. Briefly, you can not find another sequence containing these two strings at the same time.
  If given the N, M and two actions, can you calculate the total ways of walking from node No.1 to the right-bottom node ?

 

 2
3 2
RRD
DDR
3 2
R
D 

Sample Output

 1
10 

思路：先构造一个AC自己主动机记录每一个状态包括两个串的状态，然后利用dp[i][j][k][s]表示i个R，j个D。此时AC自己主动机状态位置到k的时候，状态为s时的个数进行转移

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
const int mod = 1e9+7;

int dp[110][110][220][4];
int n,m;
int nxt[420][2],fail[420],end[420];
int root,cnt;

inline int change(char ch) {
	if (ch == 'R')
		return 0;
	else return 1;
}

inline int newNode() {
	for (int i = 0; i < 2; i++)
		nxt[cnt][i] = -1;
	end[cnt++] = 0;
	return cnt-1;
}

inline void init() {
	cnt = 0;
	root = newNode();
}

inline void insert(char buf[], int id) {
	int len = strlen(buf);
	int now = root;
	for (int i = 0; i < len; i++) {
		if (nxt[now][change(buf[i])] == -1)
			nxt[now][change(buf[i])] = newNode();
		now = nxt[now][change(buf[i])];
	}
	end[now] |= (1<<id);
}

inline void build() {
	queue<int> q;
	fail[root] = root;
	for (int i = 0; i < 2; i++)
		if (nxt[root][i] == -1)
			nxt[root][i] = root;
		else {
			fail[nxt[root][i]] = root;
			q.push(nxt[root][i]);
		}

	while (!q.empty()) {
		int now = q.front();
		q.pop();
		end[now] |= end[fail[now]];
		for (int i = 0; i < 2; i++)
			if (nxt[now][i] == -1)
				nxt[now][i] = nxt[fail[now]][i];
			else {
				fail[nxt[now][i]] = nxt[fail[now]][i];
				q.push(nxt[now][i]);
			}
	}
}

inline int solve() {
	dp[0][0][0][0] = 1;
	for (int x = 0; x <= n; x++)
		for (int y = 0; y <= m; y++)
			for (int i = 0; i < cnt; i++)
				for (int k = 0; k < 4; k++) {
					if (dp[x][y][i][k] == 0)
						continue;
					if (x < n) {
						int cur = nxt[i][0];
						dp[x+1][y][cur][k|end[cur]] += dp[x][y][i][k];
						dp[x+1][y][cur][k|end[cur]] %= mod;;
					}
					if (y < m) {
						int cur = nxt[i][1];
						dp[x][y+1][cur][k|end[cur]] += dp[x][y][i][k];
						dp[x][y+1][cur][k|end[cur]] %= mod;
					}
				}
	int ans = 0;
	for (int i = 0; i < cnt; i++) {
		ans += dp[n][m][i][3];
		ans %= mod;
	}
	return ans;
}

char str[210];

int main() {
	int t;
	scanf("%d", &t);
	while (t--) {
		scanf("%d%d", &n, &m);
		init();
		for (int i = 0; i < 2; i++) {
			scanf("%s", str);
			insert(str, i);
		}

		build();
		for (int i = 0; i <= n; i++)
			for (int j = 0; j <= m; j++) 
				for (int x = 0; x < cnt; x++)
					for (int y = 0; y < 4; y++)
						dp[i][j][x][y] = 0;

		printf("%d\n", solve());
	}
	return 0;
}