POJ 3691 and Hduoj 2457 DNA repair

POJ 3691 DNA repair

Hduoj 2457 DNA repair

        AC自动机+DP。先建立AC自动机，再来看DP。和前面类似考虑方程的时候我们可以结合字符串的长度与AC自动机的状态，来写方程。设dp[i][j]是单词长度为i走到j时最少需要修改单词的个数。那么考虑状态的转化，由于要不含致病基因，那么也就是状态不能走到叶节点。考虑状态j是由那些转化而来的？这些状态转化只决定于AC自动机，我们在构建AC自动机的时候利用虚节点来确定每一个状态当遇到某个字符时状态的转化结果。考虑k是j的前一个状态，如果修改第i个字符可以由k走到j，那么有dp[i][j] = dp[i-1][k] + 1,如果不用修改第i个字符可以由k走到j，那么有dp[i][j] = dp[i-1][k] ,由于是要求最小的，所以我们只需要取这些之中的最小即可。

/*
Author    :csuchenan
LANG      :c++
Algorithm : DP + AC
*/
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std ;
#define INF 0x3c3c3c3c
#define maxn 1010

int  next[maxn][4] ;
int  fail[maxn] ;
bool flag[maxn] ;
int  dp[1001][maxn] ;
char target[1001] ;
int cnt ;
int N ;

void init(){
	memset(next , 0 , sizeof(next)) ;
	memset(flag , 0 , sizeof(flag)) ;
	memset(fail , 0 , sizeof(fail)) ;
	memset(dp  , 0x3c , sizeof(dp)) ;
	cnt = 0 ;
}

int hash(char c){
	switch(c){
		case 'A' : return 0 ;
		case 'C' : return 1 ;
		case 'G' : return 2 ;
		case 'T' : return 3 ;
	}
}

void insert(char * str){
	char *p = str ;
	int b ;
	int c(0) ;

	while(*p){
		b = hash(*p) ;
		if(!next[c][b])
			next[c][b] = ++ cnt ;
		c = next[c][b] ;
		p ++ ;
	}
	flag[c] = 1 ;
}

bool read(){
	scanf("%d" , &N) ;
	if(!N)
		return 0 ;

	init() ;
	char str[25] ;

	for(int k = 1 ; k <= N ; k ++){
		scanf("%s" , str) ;
		insert(str) ;
	}
	scanf("%s" , target + 1) ;
	return 1 ;
}

void build_ac(){
	queue<int> Q ;
	int cur(0)  ;
	int child   ;
	int tmp , k ;

	fail[cur] = 0 ;
	Q.push(cur) ;

	while(!Q.empty()){
		cur = Q.front() ;
		Q.pop() ;

		for(k = 0 ; k < 4 ; k ++){
			child = next[cur][k] ;
			if(child){
				Q.push(child) ;
				if(!cur)
					fail[child] = 0 ;
				else{
					tmp = fail[cur] ;
					for( ; tmp && !next[tmp][k] ; tmp = fail[tmp])
						;
					if(next[tmp][k])
						fail[child] = next[tmp][k] ;
					else
						fail[child] = 0 ;
				}
				if(flag[ fail[child] ])
					flag[child] = 1 ;
			}
			else{
				next[cur][k] = next[ fail[cur] ][k] ;
			}
		}
	}
}

inline int min(int a , int b){
	return a < b ? a : b ;
}

void solve(){

	build_ac() ;
	int k ;
	int i ;
	int j ;

	dp[0][0] = 0 ;
	int len = strlen(target + 1) ;
	for(int i = 1 ; i <= len ; i ++){
		for(int j = 0 ; j <= cnt ; j ++){
			if(flag[j])
				continue ;
			for(int k = 0 ; k < 4 ; k ++){
				int cur = next[j][k] ;

				if(flag[cur])
					continue ;

				if(k == hash(target[i]) )
					dp[i][cur] = min(dp[i][cur] , dp[i-1][j]) ;
				else
					dp[i][cur] = min(dp[i][cur] , dp[i-1][j] + 1) ;
			}
		}
	}
	int ans = INF ;
	for(i = 0 ; i <= cnt ; i ++){
		if(flag[i])
			continue ;
		ans = min(ans , dp[len][i]) ;
	}
	printf("%d\n" , ans==INF ? -1 : ans) ;
}

int main(){
    int t(0) ;
	while(read()){
		printf("Case %d: ", ++t) ;
		solve() ;
	}
	return 0 ;
}