HDU3341 Lost's revenge(AC自动机&&dp)

一看到ACGT就会想起AC自动机上的dp，这种奇怪的联想可能是源于某道叫DNA什么的题的。

题意，给你很多个长度不大于10的小串，小串最多有50个，然后有一个长度<40的串，然后让你将这个这个长度<40的串经过重新排列之后，小串在里面出现的次数总和最大。譬如如果我的小串是AA,AAC，长串是CAAA，我们重新排列成AAAC之后，AA在里面出现了2次，AAC出现了1次，总和是3次，这个数字就是我们要求的。

思路：思路跟HDU4758 walk through squares很像的，首先对每个小串插Trie树，建自动机，然后要做一下预处理，对于每个状态预处理出到达该状态时匹配了多少个小串，方法就是沿着失配边将cnt加起来。然后对于每个状态，如果它不存在某个字母的后继，就沿着失配边走找到存在该字母的后继，这样预处理后，后面的状态转移起来就比较方便。然后定义状态dp[A][C][G][T][sta]表示已经匹配的A,C,G,T对应为A,C,G,T个，在自动机上的状态为sta时所能匹配到的最大的状态数。然后转移就好。

Trick的部分是，虽然A,C,G,T所能产生的状态数最大是11*11*11*11(即40平均分的时候的情况)，但是因为有可能有些字母出现40次，所以开的时候要dp[41][41][41][41][550],想到这里我就不知道怎么写了－ －0。后来发现其实可以先hash一下，对于sta[i][j][k][t]＝用一个数字s代表其状态，然后开一个数组p[s][0~3]存的是该状态对应的A,C,G,T数，然后再转移就好。

不过貌似跑的有点慢，3s多，感觉挺容易TLE的。

#pragma warning(disable:4996)

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<vector>

#include<cmath>

#include<iostream>

#include<queue>

#define maxn 1500

using namespace std;



char str[50][15];

char T[50];

int n;



void convert(char *s){

	int len = strlen(s);

	for (int i = 0; i < len; i++){

		if (s[i] == 'A') s[i] = 'a';

		else if (s[i] == 'C') s[i] = 'b';

		else if (s[i] == 'G') s[i] = 'c';

		else s[i] = 'd';

	}

}



struct Trie{

	Trie *fail, *go[4];

	int cnt; bool flag;

	void init(){

		memset(go, 0, sizeof(go)); fail = NULL; cnt = 0; flag = false;

	}

}pool[maxn],*root;

int tot;



void insert(char *c){

	int len = strlen(c); Trie *p = root;

	for (int i = 0; i < len; i++){

		if (p->go[c[i] - 'a'] != 0) p = p->go[c[i] - 'a'];

		else{

			pool[tot].init();

			p->go[c[i] - 'a'] = &pool[tot++];

			p = p->go[c[i] - 'a'];

		}

	}

	p->cnt++;

}



void getFail()

{

	queue<Trie*> que;

	que.push(root);

	root->fail = NULL;

	while (!que.empty()){

		Trie *temp = que.front(); que.pop();

		Trie *p = NULL;

		for (int i = 0; i < 4; i++){

			if (temp->go[i] != NULL){

				if (temp == root) temp->go[i]->fail = root;

				else{

					p = temp->fail;

					while (p != NULL){

						if (p->go[i] != NULL){

							temp->go[i]->fail = p->go[i]; break;

						}

						p = p->fail;

					}

					if (p == NULL) temp->go[i]->fail = root;

				}

				que.push(temp->go[i]);

			}

		}

	}

}



int dfs(Trie *p){

	if (p == root) return 0;

	if (p->flag == true) return p->cnt;

	p->cnt += dfs(p->fail); p->flag = true;

	return p->cnt;

}



int sta[45][45][45][45];

int p[15000][4];

int stanum;

int dp[15000][520];

int A, B, C, D;



int main()

{

	int ca = 0;

	while (cin >> n&&n)

	{

		tot = 0; root = &pool[tot++]; root->init();

		for (int i = 0; i < n; i++){

			scanf("%s", str[i]); convert(str[i]);

			insert(str[i]);

		}

		scanf("%s", T); A = B = C = D = 0; int len = strlen(T);

		for (int i = 0; i < len; i++){

			if (T[i] == 'A') A++;

			else if (T[i] == 'C') B++;

			else if (T[i] == 'G') C++;

			else D++;

		}

		getFail();

		for (int i = 0; i < tot; i++) dfs(&pool[i]);

		for (int i = 0; i < tot; i++){

			Trie *p = &pool[i];

			for (int k = 0; k < 4; k++){

				if (p->go[k] == NULL){

					Trie *temp = p; temp = temp->fail;

					while (temp != NULL){

						if (temp->go[k] != NULL) {

							p->go[k] = temp->go[k]; break;

						}

						temp = temp->fail;

					}

					if (temp == NULL) p->go[k] = root;

				}

			}

		}

		stanum = 0;

		for (int i = 0; i <= A; i++){

			for (int j = 0; j <= B; j++){

				for (int k = 0; k <= C; k++){

					for (int t = 0; t <= D; t++){

						sta[i][j][k][t] = stanum;

						p[stanum][0] = i; p[stanum][1] = j;

						p[stanum][2] = k; p[stanum][3] = t; stanum++;

					}

				}

			}

		}

		memset(dp, -1, sizeof(dp)); int a, b, c, d;

		dp[0][0] = 0;

		for (int i = 0; i < stanum; i++){

			a = p[i][0]; b = p[i][1]; c = p[i][2]; d = p[i][3];

			for (int j = 0; j < tot; j++){

				if (dp[i][j] == -1) continue;

				if (a + 1 <= A) dp[sta[a + 1][b][c][d]][pool[j].go[0] - pool] =

					max(dp[sta[a + 1][b][c][d]][pool[j].go[0] - pool], dp[i][j] + pool[j].go[0]->cnt);



				if (b + 1 <= B) dp[sta[a][b + 1][c][d]][pool[j].go[1] - pool] =

					max(dp[sta[a][b + 1][c][d]][pool[j].go[1] - pool], dp[i][j] + pool[j].go[1]->cnt);



				if (c + 1 <= C) dp[sta[a][b][c + 1][d]][pool[j].go[2] - pool] =

					max(dp[sta[a][b][c + 1][d]][pool[j].go[2] - pool], dp[i][j] + pool[j].go[2]->cnt);



				if (d + 1 <= D) dp[sta[a][b][c][d + 1]][pool[j].go[3] - pool] =

					max(dp[sta[a][b][c][d + 1]][pool[j].go[3] - pool], dp[i][j] + pool[j].go[3]->cnt);

			}

		}

		int ans = 0; int fin = sta[A][B][C][D];

		for (int i = 0; i < tot; i++){

			ans = max(ans, dp[fin][i]);

		}

		printf("Case %d: %d\n", ++ca, ans);

	}

	return 0;

}