Algoritmo di corrispondenza stringhe k non corrispondente

Sto cercando un algoritmo di corrispondenza delle stringhe k-mismatch veloce. Data una stringa di modello P di lunghezza m e una stringa di testo T di lunghezza n, ho bisogno di un algoritmo veloce (tempo lineare) per trovare tutte le posizioni in cui P corrisponde a una sottostringa di T con al massimo k non corrispondenti. Questo è diverso dal problema delle differenze k (modifica distanza). Una mancata corrispondenza implica la sottostringa e il modello ha una lettera diversa nella maggior parte delle posizioni k. Ho davvero bisogno solo di k = 1 (al massimo 1 discrepanza), quindi basterà anche un algoritmo veloce per il caso specifico di k = 1. La dimensione dell'alfabeto è 26 (testo in inglese senza distinzione tra maiuscole e minuscole), quindi il requisito di spazio non dovrebbe crescere troppo velocemente con la dimensione dell'alfabeto (ad esempio, l'algoritmo FAAST, credo, occupa spazio esponenziale nella dimensione dell'alfabeto, e così è adatto solo per sequenze di proteine ​​e geni).

Un approccio basato sulla programmazione dinamica tenderà ad essere O (mn) nel peggiore dei casi, che sarà troppo lento. Credo che ci siano modifiche all'algoritmo di Boyer-Moore per questo, ma non sono in grado di mettere le mani su tali documenti. Non ho un abbonamento per accedere a riviste o pubblicazioni accademiche, quindi eventuali riferimenti dovranno essere di dominio pubblico.

Gradirei molto qualsiasi suggerimento o riferimento a documenti liberamente disponibili o l'algoritmo stesso per questo problema.

Le matrici di suffissi possono essere utilizzate per questo problema. Contengono le posizioni iniziali di ciascun suffisso della stringa ordinate in ordine lessicografico. Anche se possono essere costruiti ingenuamente nella complessità , ci sono metodi per costruirli nella complessità Θ ( n ) . Vedi per esempio questo e questo . Chiamiamo questo suffisso array SA.$O(n\log n)$$\Theta(n)$

Una volta che la matrice di suffissi è stata costruita, dobbiamo costruire una matrice di prefisso comune più lungo (LCP) per la matrice di suffissi. L'array LCP memorizza la lunghezza del prefisso comune più lungo tra due prefissi consecutivi nell'array di suffissi (suffissi lessicografici consecutivi). Pertanto, LCP [i] contiene la lunghezza del prefisso comune più lungo tra SA [i] e SA [i + 1]. Questo array può anche essere costruito in tempo lineare: vedi qui , qui e qui per alcuni buoni riferimenti.

$u$$v$$u < v$$min_{u<=k<=v-1}{LCP[k]}$$LCP$$O(n)$$O(n\log n)$$LCP[u, v]$$O(1)$

$i$$T$$LCP$$T$$i$$P$$P$$T[i]$$l_0$$T$$P$$LCP$$T[i + l_0 + 1]$$P[l_0 + 1]$$k$$LCP$$O(1)$$O(k)$ $LCP$$i$$T$$O(nk)$

$O(nk + (n+m)\log(n+m))$$O(nk + n\log n)$$m = O(n)$$O(nk)$

$\mathcal{O}(n + m )$$k$$\mathcal{O}(nk +m )$

L'idea è simile all'algoritmo di hash rolling Rabin-Karp per esatte corrispondenze di sottostringa.

$m$$2k$$m/2k$$2k$$2k$

$k$

$k$

Mi aspetto (avvertimento: non l'ho provato da solo) questo sarà probabilmente più veloce in pratica, e forse più facile da programmare / mantenere, rispetto all'uso di un approccio basato sull'albero dei suffissi.