Algoritma pencocokan string k tidak cocok cepat

Saya mencari algoritma pencocokan string k-mismatch yang cepat. Diberikan string pola P dengan panjang m, dan string teks T dengan panjang n, saya memerlukan algoritma cepat (waktu linear) untuk menemukan semua posisi di mana P cocok dengan substring T dengan paling banyak k ketidakcocokan. Ini berbeda dari masalah k-perbedaan (jarak edit). Ketidakcocokan menyiratkan substring dan pola memiliki huruf yang berbeda di sebagian besar posisi k. Saya benar-benar hanya memerlukan k = 1 (paling banyak 1 mismatch), jadi algoritma cepat untuk kasus spesifik k = 1 juga sudah cukup. Ukuran alfabet adalah 26 (teks bahasa Inggris case-insensitive), jadi kebutuhan ruang tidak boleh tumbuh terlalu cepat dengan ukuran alfabet (mis., Algoritma FAAST, saya percaya, membutuhkan ruang eksponensial dalam ukuran alfabet, dan sebagainya hanya cocok untuk sekuens protein dan gen).

Pendekatan berbasis pemrograman dinamis akan cenderung menjadi O (mn) dalam kasus terburuk, yang akan terlalu lambat. Saya percaya ada modifikasi dari algoritma Boyer-Moore untuk ini, tetapi saya tidak bisa mendapatkan kertas-kertas tersebut. Saya tidak memiliki langganan untuk mengakses jurnal atau publikasi akademis, jadi referensi apa pun harus ada dalam domain publik.

Saya akan sangat menghargai setiap petunjuk, atau referensi ke dokumen yang tersedia secara bebas, atau algoritma itu sendiri untuk masalah ini.

Array sufiks dapat digunakan untuk masalah ini. Mereka berisi posisi awal setiap sufiks dari string yang diurutkan dalam urutan leksikografis. Meskipun mereka dapat dibangun secara naif di kompleksitas, ada metode untuk membangun mereka dalam Θ ( n ) kompleksitas. Lihat misalnya ini dan ini . Mari kita sebut array sufiks SA ini.$O(n\log n)$$\Theta(n)$

Setelah susunan sufiks dibangun, kita perlu membuat susunan Longest Common Prefix (LCP) untuk susunan sufiks. Array LCP menyimpan panjang awalan umum terpanjang antara dua awalan berurutan dalam susunan sufiks (sufiks berturut-turut leksikografis). Dengan demikian, LCP [i] berisi panjang awalan umum terpanjang antara SA [i] dan SA [i + 1]. Array ini juga dapat dibangun dalam waktu linier: lihat di sini , di sini dan di sini untuk beberapa referensi yang bagus.

$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 )$

Idenya mirip dengan algoritma hash rolling Rabin-Karp untuk pencocokan substring yang tepat.

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

$k$

$k$

Saya berharap (peringatan: belum mencobanya sendiri) ini mungkin akan lebih cepat dalam praktek, dan mungkin lebih mudah untuk kode / memelihara, daripada menggunakan pendekatan berbasis pohon suffix.