如何匹配dna序列模式
[英]how to match dna sequence pattern
問題描述
我找不到解決這個問題的方法。
輸入輸出序列如下：
**input1 :** aaagctgctagag
**output1 :** a3gct2ag2
**input2 :** aaaaaaagctaagctaag
**output2 :** a6agcta2ag
輸入序列可以是10 ^ 6個字符，並且將考慮最大的連續模式。
例如，對於input2“agctaagcta”輸出將不是“agcta2gcta”，但它將是“agcta2”。
任何幫助贊賞。
3 個解決方案
解決方案1
10 2013-06-03 18:11:53
算法說明：
- 具有符號s（1），s（2），...，s（N）的序列S.
- 設B（i）是具有元素s（1），s（2），...，s（i）的最佳壓縮序列。
- 因此，例如，B（3）將是s（1），s（2），s（3）的最佳壓縮序列。
- 我們想知道的是B（N）。
為了找到它，我們將通過歸納進行。 我們想要計算B（i + 1），知道B（i），B（i-1），B（i-2），...，B（1），B（0），其中B（0）是空的序列，和B（1）= s（1）。 同時，這構成了解決方案最佳的證據。 ;）
要計算B（i + 1），我們將在候選人中選擇最佳序列：
最后一個塊有一個元素的候選序列：
B（i）s（i + 1）1 B（i-1）s（i + 1）2; 只有當s（i）= s（i + 1）B（i-2）s（i + 1）3時; 只有當s（i-1）= s（i）和s（i）= s（i + 1）... B（1）s（i + 1）[i-1]時... 只有當s（2）= s（3）且s（3）= s（4）且......和s（i）= s（i + 1）B（0）s（i + 1）i = s（i +1）我; 只有當s（1）= s（2）且s（2）= s（3）且......和s（i）= s（i + 1）時
最后一個塊有2個元素的候選序列：
B（i-1）s（i）s（i + 1）1 B（i-3）s（i）s（i + 1）2; 只有當s（i-2）s（i-1）= s（i）s（i + 1）B（i-5）s（i）s（i + 1）3時; 只有當s（i-4）s（i-3）= s（i-2）s（i-1）和s（i-2）s（i-1）= s（i）s（i + 1）時）...
最后一個塊有3個元素的候選序列：
...
最后一個塊有4個元素的候選序列：
...
...
候選序列，其中最后一個塊具有n + 1個元素：
S（1）S（2）S（3）.........序列s（i + 1）
對於每種可能性，當序列塊不再重復時，算法停止。 就是這樣。
psude-c代碼中的算法會是這樣的：
B(0) = “”
for (i=1; i<=N; i++) {
// Calculate all the candidates for B(i)
BestCandidate=null
for (j=1; j<=i; j++) {
Calculate all the candidates of length (i)
r=1;
do {
Candidadte = B([i-j]*r-1) s(i-j+1)…s(i-1)s(i) r
If ( (BestCandidate==null)
|| (Candidate is shorter that BestCandidate))
{
BestCandidate=Candidate.
}
r++;
} while ( ([i-j]*r <= i)
&&(s(i-j*r+1) s(i-j*r+2)…s(i-j*r+j) == s(i-j+1) s(i-j+2)…s(i-j+j))
}
B(i)=BestCandidate
}
希望這可以幫助更多。
執行所需任務的完整C程序如下所示。 它以O（n ^ 2）運行。 中心部分只有30行代碼。
編輯我重新構建了一些代碼，更改了變量的名稱並添加了一些注釋以便更具可讀性。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
// This struct represents a compressed segment like atg4, g3, agc1
struct Segment {
char *elements;
int nElements;
int count;
};
// As an example, for the segment agagt3 elements would be:
// {
// elements: "agagt",
// nElements: 5,
// count: 3
// }
struct Sequence {
struct Segment lastSegment;
struct Sequence *prev; // Points to a sequence without the last segment or NULL if it is the first segment
int totalLen; // Total length of the compressed sequence.
};
// as an example, for the sequence agt32ta5, the representation will be:
// {
// lastSegment:{"ta" , 2 , 5},
// prev: @A,
// totalLen: 8
// }
// and A will be
// {
// lastSegment{ "agt", 3, 32},
// prev: NULL,
// totalLen: 5
// }
// This function converts a sequence to a string.
// You have to free the string after using it.
// The strategy is to construct the string from right to left.
char *sequence2string(struct Sequence *S) {
char *Res=malloc(S->totalLen + 1);
char *digits="0123456789";
int p= S->totalLen;
Res[p]=0;
while (S!=NULL) {
// first we insert the count of the last element.
// We do digit by digit starting with the units.
int C = S->lastSegment.count;
while (C) {
p--;
Res[p] = digits[ C % 10 ];
C /= 10;
}
p -= S->lastSegment.nElements;
strncpy(Res + p , S->lastSegment.elements, S->lastSegment.nElements);
S = S ->prev;
}
return Res;
}
// Compresses a dna sequence.
// Returns a string with the in sequence compressed.
// The returned string must be freed after using it.
char *dnaCompress(char *in) {
int i,j;
int N = strlen(in);; // Number of elements of a in sequence.
// B is an array of N+1 sequences where B(i) is the best compressed sequence sequence of the first i characters.
// What we want to return is B[N];
struct Sequence *B;
B = malloc((N+1) * sizeof (struct Sequence));
// We first do an initialization for i=0
B[0].lastSegment.elements="";
B[0].lastSegment.nElements=0;
B[0].lastSegment.count=0;
B[0].prev = NULL;
B[0].totalLen=0;
// and set totalLen of all the sequences to a very HIGH VALUE in this case N*2 will be enougth, We will try different sequences and keep the minimum one.
for (i=1; i<=N; i++) B[i].totalLen = INT_MAX; // A very high value
for (i=1; i<=N; i++) {
// at this point we want to calculate B[i] and we know B[i-1], B[i-2], .... ,B[0]
for (j=1; j<=i; j++) {
// Here we will check all the candidates where the last segment has j elements
int r=1; // number of times the last segment is repeated
int rNDigits=1; // Number of digits of r
int rNDigitsBound=10; // We will increment r, so this value is when r will have an extra digit.
// when r = 0,1,...,9 => rNDigitsBound = 10
// when r = 10,11,...,99 => rNDigitsBound = 100
// when r = 100,101,.,999 => rNDigitsBound = 1000 and so on.
do {
// Here we analitze a candidate B(i).
// where the las segment has j elements repeated r times.
int CandidateLen = B[i-j*r].totalLen + j + rNDigits;
if (CandidateLen < B[i].totalLen) {
B[i].lastSegment.elements = in + i - j*r;
B[i].lastSegment.nElements = j;
B[i].lastSegment.count = r;
B[i].prev = &(B[i-j*r]);
B[i].totalLen = CandidateLen;
}
r++;
if (r == rNDigitsBound ) {
rNDigits++;
rNDigitsBound *= 10;
}
} while ( (i - j*r >= 0)
&& (strncmp(in + i -j, in + i - j*r, j)==0));
}
}
char *Res=sequence2string(&(B[N]));
free(B);
return Res;
}
int main(int argc, char** argv) {
char *compressedDNA=dnaCompress(argv[1]);
puts(compressedDNA);
free(compressedDNA);
return 0;
}
解決方案2
2 2013-06-02 05:26:09
忘記Ukonnen。 它是動態編程。 使用三維表：
- 序列位置
- 子序列大小
- 細分數量
術語：例如，具有a = "aaagctgctagag" ，序列位置坐標將從1到13運行。在序列位置3（字母'g'），具有子序列大小4，子序列將是“gctg”。 懂了嗎？ 至於段的數量 ，則表示為“aaagctgctagag1”由1個段（序列本身）組成。 將其表示為“a3gct2ag2”由3個段組成。 “aaagctgct1ag2”由2個段組成。 “a2a1ctg2ag2”將包含4個段。 懂了嗎？ 現在，有了這個，你開始填充一個13 x 13 x 13的三維數組，所以你的時間和內存復雜度似乎在n ** 3左右。 你確定你可以處理百萬桶序列嗎？ 我認為貪婪的方法會更好，因為大的DNA序列不太可能完全重復。 並且，我建議您將作業擴展到近似匹配，並且可以直接在期刊中發布。
無論如何，您將開始填充從某個位置（維度1）開始壓縮子序列的表格，其長度等於維度2坐標，最多具有3個維度段。 因此，您首先填充第一行，表示長度為1的子序列的壓縮，最多包含1個段：
a a a g c t g c t a g a g
1(a1) 1(a1) 1(a1) 1(g1) 1(c1) 1(t1) 1(g1) 1(c1) 1(t1) 1(a1) 1(g1) 1(a1) 1(g1)
數字是字符成本（對於這些簡單的1-char序列總是1;數字1不計入字符成本），在括號中，你有壓縮（對於這個簡單的情況也很簡單）。 第二行仍然很簡單：
2(a2) 2(a2) 2(ag1) 2(gc1) 2(ct1) 2(tg1) 2(gc1) 2(ct1) 2(ta1) 2(ag1) 2(ga1) 2(ag1)
只有一種方法可以將2個字符的序列分解為2個子序列 - 1個字符+ 1個字符。 如果它們相同，結果就像a + a = a2 。 如果它們不同，例如a + g ，則因為只允許1段序列，結果不能是a1g1 ，但必須是ag1 。 第三行最終會更有趣：
2(a3) 2(aag1) 3(agc1) 3(gct1) 3(ctg1) 3(tgc1) 3(gct1) 3(cta1) 3(tag1) 3(aga1) 3(gag1)
在這里，您始終可以選擇兩種組合壓縮字符串的方法。 例如， aag可以由aa + g或a + ag 。 但同樣，我們不能有兩個段，如aa1g1或a1ag1 ，所以我們必須滿足aag1 ，除非兩個組件都包含相同的字符，如aa + a => a3 ，字符成本2.我們可以繼續第4行：
4(aaag1) 4(aagc1) 4(agct1) 4(gctg1) 4(ctgc1) 4(tgct1) 4(gcta1) 4(ctag1) 4(taga1) 3(ag2)
這里，在第一個位置，我們不能使用a3g1 ，因為在該層只允許1個段。 但是在最后一個位置， ag1 + ag1 = ag2壓縮到字符成本3。 這樣，可以將整個第一級表一直填充到13個字符的單個子序列，並且每個子序列將具有其最佳字符成本，並且在與其關聯的最多1個段的第一級約束下具有其壓縮。 。
然后你轉到第二級，其中允許2個段......再次，從下到上，通過比較所有可能的方法，您可以確定給定級別的段計數約束下每個表坐標的最佳成本和壓縮使用已計算的位置組成子序列，直到您完全填充表格，從而計算全局最優值。 有一些細節需要解決，但很抱歉，我不打算給你編碼。
解決方案3
2
在嘗試了我自己的方式一段時間之后，我對jbaylina的贊美他的漂亮算法和C實現。 這是我在Haskell中嘗試使用jbaylina算法的版本，並在其下面進一步開發了我嘗試線性時間算法的嘗試，該算法試圖以一個一個的方式壓縮包含重復模式的片段：
import Data.Map (fromList, insert, size, (!))
compress s = (foldl f (fromList [(0,([],0)),(1,([s!!0],1))]) [1..n - 1]) ! n
where
n = length s
f b i = insert (size b) bestCandidate b where
add (sequence, sLength) (sequence', sLength') =
(sequence ++ sequence', sLength + sLength')
j' = [1..min 100 i]
bestCandidate = foldr combCandidates (b!i `add` ([s!!i,'1'],2)) j'
combCandidates j candidate' =
let nextCandidate' = comb 2 (b!(i - j + 1)
`add` ((take j . drop (i - j + 1) $ s) ++ "1", j + 1))
in if snd nextCandidate' <= snd candidate'
then nextCandidate'
else candidate' where
comb r candidate
| r > uBound = candidate
| not (strcmp r True) = candidate
| snd nextCandidate <= snd candidate = comb (r + 1) nextCandidate
| otherwise = comb (r + 1) candidate
where
uBound = div (i + 1) j
prev = b!(i - r * j + 1)
nextCandidate = prev `add`
((take j . drop (i - j + 1) $ s) ++ show r, j + length (show r))
strcmp 1 _ = True
strcmp num bool
| (take j . drop (i - num * j + 1) $ s)
== (take j . drop (i - (num - 1) * j + 1) $ s) =
strcmp (num - 1) True
| otherwise = False
輸出：
*Main> compress "aaagctgctagag"
("a3gct2ag2",9)
*Main> compress "aaabbbaaabbbaaabbbaaabbb"
("aaabbb4",7)
線性時間嘗試：
import Data.List (sortBy)
group' xxs sAccum (chr, count)
| null xxs = if null chr
then singles
else if count <= 2
then reverse sAccum ++ multiples ++ "1"
else singles ++ if null chr then [] else chr ++ show count
| [x] == chr = group' xs sAccum (chr,count + 1)
| otherwise = if null chr
then group' xs (sAccum) ([x],1)
else if count <= 2
then group' xs (multiples ++ sAccum) ([x],1)
else singles
++ chr ++ show count ++ group' xs [] ([x],1)
where x:xs = xxs
singles = reverse sAccum ++ (if null sAccum then [] else "1")
multiples = concat (replicate count chr)
sequences ws strIndex maxSeqLen = repeated' where
half = if null . drop (2 * maxSeqLen - 1) $ ws
then div (length ws) 2 else maxSeqLen
repeated' = let (sequence,(sequenceStart, sequenceEnd'),notSinglesFlag) = repeated
in (sequence,(sequenceStart, sequenceEnd'))
repeated = foldr divide ([],(strIndex,strIndex),False) [1..half]
equalChunksOf t a = takeWhile(==t) . map (take a) . iterate (drop a)
divide chunkSize b@(sequence,(sequenceStart, sequenceEnd'),notSinglesFlag) =
let t = take (2*chunkSize) ws
t' = take chunkSize t
in if t' == drop chunkSize t
then let ts = equalChunksOf t' chunkSize ws
lenTs = length ts
sequenceEnd = strIndex + lenTs * chunkSize
newEnd = if sequenceEnd > sequenceEnd'
then sequenceEnd else sequenceEnd'
in if chunkSize > 1
then if length (group' (concat (replicate lenTs t')) [] ([],0)) > length (t' ++ show lenTs)
then (((strIndex,sequenceEnd,chunkSize,lenTs),t'):sequence, (sequenceStart,newEnd),True)
else b
else if notSinglesFlag
then b
else (((strIndex,sequenceEnd,chunkSize,lenTs),t'):sequence, (sequenceStart,newEnd),False)
else b
addOne a b
| null (fst b) = a
| null (fst a) = b
| otherwise =
let (((start,end,patLen,lenS),sequence):rest,(sStart,sEnd)) = a
(((start',end',patLen',lenS'),sequence'):rest',(sStart',sEnd')) = b
in if sStart' < sEnd && sEnd < sEnd'
then let c = ((start,end,patLen,lenS),sequence):rest
d = ((start',end',patLen',lenS'),sequence'):rest'
in (c ++ d, (sStart, sEnd'))
else a
segment xs baseIndex maxSeqLen = segment' xs baseIndex baseIndex where
segment' zzs@(z:zs) strIndex farthest
| null zs = initial
| strIndex >= farthest && strIndex > 0 = ([],(0,0))
| otherwise = addOne initial next
where
next@(s',(start',end')) = segment' zs (strIndex + 1) farthest'
farthest' | null s = farthest
| otherwise = if start /= end && end > farthest then end else farthest
initial@(s,(start,end)) = sequences zzs strIndex maxSeqLen
areExclusive ((a,b,_,_),_) ((a',b',_,_),_) = (a' >= b) || (b' <= a)
combs [] r = [r]
combs (x:xs) r
| null r = combs xs (x:r) ++ if null xs then [] else combs xs r
| otherwise = if areExclusive (head r) x
then combs xs (x:r) ++ combs xs r
else if l' > lowerBound
then combs xs (x: reduced : drop 1 r) ++ combs xs r
else combs xs r
where lowerBound = l + 2 * patLen
((l,u,patLen,lenS),s) = head r
((l',u',patLen',lenS'),s') = x
reduce = takeWhile (>=l') . iterate (\x -> x - patLen) $ u
lenReduced = length reduce
reduced = ((l,u - lenReduced * patLen,patLen,lenS - lenReduced),s)
buildString origStr sequences = buildString' origStr sequences 0 (0,"",0)
where
buildString' origStr sequences index accum@(lenC,cStr,lenOrig)
| null sequences = accum
| l /= index =
buildString' (drop l' origStr) sequences l (lenC + l' + 1, cStr ++ take l' origStr ++ "1", lenOrig + l')
| otherwise =
buildString' (drop u' origStr) rest u (lenC + length s', cStr ++ s', lenOrig + u')
where
l' = l - index
u' = u - l
s' = s ++ show lenS
(((l,u,patLen,lenS),s):rest) = sequences
compress [] _ accum = reverse accum ++ (if null accum then [] else "1")
compress zzs@(z:zs) maxSeqLen accum
| null (fst segment') = compress zs maxSeqLen (z:accum)
| (start,end) == (0,2) && not (null accum) = compress zs maxSeqLen (z:accum)
| otherwise =
reverse accum ++ (if null accum || takeWhile' compressedStr 0 /= 0 then [] else "1")
++ compressedStr
++ compress (drop lengthOriginal zzs) maxSeqLen []
where segment'@(s,(start,end)) = segment zzs 0 maxSeqLen
combinations = combs (fst $ segment') []
takeWhile' xxs count
| null xxs = 0
| x == '1' && null (reads (take 1 xs)::[(Int,String)]) = count
| not (null (reads [x]::[(Int,String)])) = 0
| otherwise = takeWhile' xs (count + 1)
where x:xs = xxs
f (lenC,cStr,lenOrig) (lenC',cStr',lenOrig') =
let g = compare ((fromIntegral lenC + if not (null accum) && takeWhile' cStr 0 == 0 then 1 else 0) / fromIntegral lenOrig)
((fromIntegral lenC' + if not (null accum) && takeWhile' cStr' 0 == 0 then 1 else 0) / fromIntegral lenOrig')
in if g == EQ
then compare (takeWhile' cStr' 0) (takeWhile' cStr 0)
else g
(lenCompressed,compressedStr,lengthOriginal) =
head $ sortBy f (map (buildString (take end zzs)) (map reverse combinations))
輸出：
*Main> compress "aaaaaaaaabbbbbbbbbaaaaaaaaabbbbbbbbb" 100 []
"a9b9a9b9"
*Main> compress "aaabbbaaabbbaaabbbaaabbb" 100 []
"aaabbb4"
如何測試序列是否符合給定模式中的另一個序列？
[英]How to test if a sequence is conform to another sequence in a given pattern?
在python中折疊DNA序列的正向和反向互補的算法？
[英]Algorithm to collapse forward and reverse complement of a DNA sequence in python?
找到最長的回文 DNA 子序列，上面有最多的突變
[英]Find the longest palindromic DNA sub-sequence that has the most mutations on it
基因DNA序列優化的算法選項？ （與TSP有關，動態編程）
[英]Algorithm Options for Gene DNA Sequence Optimization? (related to TSP, dynamic programming)
聲明:本站的技術帖子網頁，遵循CC BY-SA 4.0協議，如果您需要轉載，請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.