18.10.29 POJ 3691 DNA repair(AC自动机+dp)

描述

Biologists finally invent techniques of repairing DNA that contains segments causing kinds of inherited diseases. For the sake of simplicity, a DNA is represented as a string containing characters ‘A‘, ‘G‘ , ‘C‘ and ‘T‘. The repairing techniques are simply to change some characters to eliminate all segments causing diseases. For example, we can repair a DNA "AAGCAG" to "AGGCAC" to eliminate the initial causing disease segments "AAG", "AGC" and "CAG" by changing two characters. Note that the repaired DNA can still contain only characters ‘A‘, ‘G‘, ‘C‘ and ‘T‘.

You are to help the biologists to repair a DNA by changing least number of characters.

输入

The input consists of multiple test cases. Each test case starts with a line containing one integers N (1 ≤ N ≤ 50), which is the number of DNA segments causing inherited diseases.
The following N lines gives N non-empty strings of length not greater than 20 containing only characters in "AGCT", which are the DNA segments causing inherited disease.
The last line of the test case is a non-empty string of length not greater than 1000 containing only characters in "AGCT", which is the DNA to be repaired.

The last test case is followed by a line containing one zeros.

输出

For each test case, print a line containing the test case number( beginning with 1) followed by the
number of characters which need to be changed. If it‘s impossible to repair the given DNA, print -1.

样例输入

2
AAA
AAG
AAAG
2
A
TG
TGAATG
4
A
G
C
T
AGT
0

样例输出

Case 1: 1
Case 2: 4
Case 3: -1

  1 #include <iostream>
  2 #include <string.h>
  3 #include <algorithm>
  4 #include <stack>
  5 #include <string>
  6 #include <math.h>
  7 #include <queue>
  8 #include <stdio.h>
  9 #include <string.h>
 10 #include <vector>
 11 #include <fstream>
 12 #include <set>
 13 #define inf 0x3f3f3f3f
 14
 15 using namespace std;
 16 const int maxn = 1005;
 17 int n,nodecou,l;
 18 char str[maxn];
 19 int gen[85],f[maxn][maxn];
 20
 21 struct node {
 22     int next[4];
 23     int prev;
 24     bool isdanger;
 25     char val;
 26     node() {
 27         memset(next, 0, sizeof(next));
 28         prev = -1;
 29         isdanger = false;
 30         val = 0;
 31     }
 32 }tree[maxn];
 33
 34 void insert() {
 35     int now = 1,l=strlen(str);
 36     for (int i = 0; i < l; i++) {
 37         int idx = gen[str[i]];
 38         if (tree[now].next[idx] == 0) {
 39             nodecou++;
 40             tree[now].next[idx] = nodecou;
 41             tree[nodecou].val = str[i];
 42         }
 43         now = tree[now].next[idx];
 44         if (i == l - 1)
 45             tree[now].isdanger = true;
 46     }
 47 }
 48
 49 void build() {
 50     for(int i=0;i<4;i++)
 51         tree[0].next[i] = 1;
 52     tree[1].prev = 0;
 53     queue<int>q;
 54     q.push(1);
 55     while (!q.empty()) {
 56         int now = q.front(); q.pop();
 57         for (int i = 0; i < 4; i++) {
 58             int child = tree[now].next[i];
 59             int prev = tree[now].prev;
 60             if (child) {
 61                 while (tree[prev].next[i] == NULL)
 62                     prev = tree[prev].prev;
 63                 tree[child].prev = tree[prev].next[i];
 64                 if (tree[tree[child].prev].isdanger)
 65                     tree[child].isdanger = true;
 66                 q.push(child);
 67             }
 68             else {
 69                 while (!tree[prev].next[i])
 70                     prev = tree[prev].prev;
 71                 tree[now].next[i] = tree[prev].next[i];
 72                 if (tree[child].isdanger)
 73                     tree[now].next[i] = 0;
 74             }
 75         }
 76     }
 77 }
 78
 79 void dp(int kase) {
 80     for (int i = 1; i <= l; i++) {
 81         for (int j = 1; j <= nodecou; j++)
 82         {
 83             for (int k = 0; k < 4; k++)
 84                 if (tree[j].next[k] && !tree[tree[j].next[k]].isdanger)
 85                     f[i][tree[j].next[k]] = min(f[i - 1][j] + (gen[str[i-1]]!=k), f[i][tree[j].next[k]]);
 86         }
 87     }
 88     int ans = inf;
 89     for (int i = 1; i <= nodecou; i++)
 90         ans = min(ans, f[l][i]);
 91     if (ans < inf)
 92         printf("Case %d: %d\n", kase, ans);
 93     else
 94         printf("Case %d: -1\n", kase);
 95 }
 96
 97 void init() {
 98     int kase = 0;
 99     while (scanf("%d",&n)) {
100         nodecou = 1;
101         if (n == 0)return;
102         kase++;
103         memset(tree, 0, sizeof(tree));
104         memset(f, 0, sizeof(f));
105         while (n--)
106         {
107             scanf("%s", str);
108             insert();
109         }
110         build();
111         scanf("%s", str);
112         l = strlen(str);
113         for (int i = 0; i <= l; i++)
114             for (int j = 1; j <= nodecou; j++)
115                 f[i][j] = inf;
116         f[0][1] = 0;
117         dp(kase);
118     }
119 }
120
121 int main()
122 {
123     gen[‘A‘] = 0, gen[‘G‘] = 1, gen[‘C‘] = 2, gen[‘T‘] = 3;
124     init();
125     return 0;
126 }

原文地址:https://www.cnblogs.com/yalphait/p/9874064.html

时间: 2024-10-07 00:37:05

18.10.29 POJ 3691 DNA repair(AC自动机+dp)的相关文章

POJ 3691 DNA repair AC自动机 + DP

题意:给你只包含‘A’,‘G’,‘T’,‘C’四个字母的n个模板串和1个文本串,问你文本串改变多少个字符就可以使得文本串中没有一个模板串 解题思路: 我们可以知道  dp[i][j] 为文本串到 第i 个字符  AC自动机状态为j的最少的变换次数(这里为什么要用AC自动机,因为end数组可以记录哪一个状态是结束的,而且处理以后可以知道那些后缀等于前缀--也就是不能到达,因为如果能够到达的话那么状态更新就会产生错误.),这样dp即可 解题代码: 1 // File Name: temp.cpp 2

HDU 2457 DNA repair AC自动机 + dp

http://acm.hdu.edu.cn/showproblem.php?pid=2457 首先把病毒串保存一下,然后对于每一个trie上的节点,跑一发AC自动机,建立一个trie图. 建立的时候,对应做一些修改. 比如,现在建立成了这个样子. 如果he是一个病毒串,那么应该相对应的,把she那个he的位置,标志上,它也是病毒串,也就是不能转移到这一个状态. 这个可以在buildfail的时候对应修改. dp, 设dp[i][j],表示处理到字符串的第i个,走到了AC自动机的第j个节点,变成了

POJ 3691 DNA repair 基于AC自动机的DP

dp[i][j] 表示长度为 i 的前缀到达第 j 个节点的最小更改数目. 很显然有dp[0][0] = 0; dp[ i ][ j ] = min(dp[ i ][ j ],dp[i-1][k] + (j == k ? 0 : 1)),当且仅当j,k满足下列条件时. j 不为某条模式串的末节点 且 j 到 root 的由失败指针组成的路径上无末节点. j 是k的儿子节点 或者 j 的父节点可由 k 沿着失败指针找到. #include <algorithm> #include <ios

[poj 3691]DNA repair

好久没刷 poj 了,今天练习 AC 自动机时去水了一发喵~ 在 poj 上 A 题的感觉并没有 BZOJ 上那么愉悦,准确的说是痛不欲生 真是应了那句老话,你再慢也有比你慢的,你再快也有比你快的…… 跪求那些 0ms 的代码啊,还有那么多人都只跑了 32ms 啊!! 果然还是我太弱了吗?一定是我还太弱了 TAT 一道裸裸的 AC 自动机上 dp 令 dp[i][j] 表示母串的前 i 个字母遍历 AC 自动机,使之到达 j 节点,至少要修改多少个字母 dp[i+1][k]=min(dp[i+1

POJ POJ 2778 DNA Sequence AC自动机 + 矩阵快速幂

首先建立Trie和失败指针,然后你会发现对于每个节点 i 匹配AGCT时只有以下几种情况: i 节点有关于当前字符的儿子节点 j 且安全,则i 到 j找到一条长度为 1的路. i 节点有关于当前字符的儿子节点 j 且 不安全,则i 到 j没有路. i 节点没有关于当前字符的儿子节点 但是能通过失败指针找到一个安全的节点j,那么 i 到 j 找到一条长度为1的路. 关于节点安全的定义: 当前节点不是末节点且当前节点由失败指针指回跟节点的路径上不存在不安全节点,那么这个节点就是安全节点. 然后问题就

POJ 3691 &amp; HDU 2457 DNA repair (AC自动机,DP)

http://poj.org/problem?id=3691 http://acm.hdu.edu.cn/showproblem.php?pid=2457 DNA repair Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 5690   Accepted: 2669 Description Biologists finally invent techniques of repairing DNA that contain

poj 3691 DNA repair(AC自动机+dp)

DNA repair Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 5877   Accepted: 2760 Description Biologists finally invent techniques of repairing DNA that contains segments causing kinds of inherited diseases. For the sake of simplicity, a

poj 2778 DNA Sequence(AC自动机+矩阵快速幂)

题目链接:poj 2778 DNA Sequence 题目大意:给定一些含有疾病的DNA序列,现在给定DNA长度,问有多少种不同的DNA序列是健康的. 解题思路:对DNA片段建立AC自动机,因为最多10个串,每个串最长为10,所以最多可能有100个节点,在长度为n时 以每个节点终止的健康字符串个数形成一个状态集,通过AC自动机形成的边可以推导出n+1的状态集,走到单词节点是 非法的,所以同样的我们可以先走到单词节点,但是从单词节点不向后转移.这样可以构造一个矩阵,剩下的就是矩阵 快速幂.注意的一

POJ 2778 DNA Sequence (AC自动机,矩阵乘法)

题意:给定n个不能出现的模式串,给定一个长度m,要求长度为m的合法串有多少种. 思路:用AC自动机,利用AC自动机上的节点做矩阵乘法. 1 #include<iostream> 2 #include<cstdio> 3 #include<cstring> 4 #include<cmath> 5 #include<string> 6 #include<algorithm> 7 #include<queue> 8 #defin