[Paper Review] Finding Approximate Palindromes in Strings Quickly and Simply

Lloyd Allison|ArXiv.org|Dec 1, 2004

Algorithms and Data Compression8 references3 citations

TL;DR

This paper presents a simple, linear-space algorithm to find approximate palindromes in strings, such as DNA sequences, allowing up to k errors. It uses a dynamic programming approach on a diagonal-based matrix to achieve O(k·n) average-case time complexity, with a more complex variant guaranteeing the same worst-case performance using suffix trees and LCA preprocessing.

ABSTRACT

Described are two algorithms to find long approximate palindromes in a string, for example a DNA sequence. A simple algorithm requires O(n)-space and almost always runs in $O(k.n)$-time where n is the length of the string and k is the number of ``errors'' allowed in the palindrome. Its worst-case time-complexity is $O(n^2)$ but this does not occur with real biological sequences. A more complex algorithm guarantees $O(k.n)$ worst-case time complexity.

Motivation & Objective

• To develop a fast and memory-efficient algorithm for detecting approximate palindromes in biological sequences, such as DNA.
• To address the challenge of finding palindromes with up to k allowed mismatches, insertions, or deletions.
• To provide a practical solution that performs well on real biological data, especially AT-rich sequences like Plasmodium falciparum DNA.
• To offer both a simple algorithm with near-linear average-case performance and a more complex variant with guaranteed O(k·n) worst-case time.

Proposed method

• Uses a distance matrix representation on diagonals to model alignments between a string and its reverse, with NE moves for matches/mismatches and N/E moves for indels.
• Employs a reach[d][e] matrix to store the maximum diagonal distance reachable with at most e errors on diagonal d, enabling O(n)-space computation.
• Applies a greedy strategy: iteratively increases reach[d][e] as long as the ends of the aligned substrings match, extending for free without cost.
• Computes reach[d][e] via recurrence: reach[d][e] = max(reach[d-1][e-1]+x, reach[d][e-1]+1, reach[d+1][e-1]+x), where x = d & 1.
• Uses a suffix tree and LCA algorithm in the complex variant to replace the loop-based extension with a constant-time operation after preprocessing.
• Reconstructs paths (alignments) post-computation using O(k·n) space or a separate recovery process if path length is small relative to n.

Experimental results

Research questions

• RQ1 Can approximate palindromes in biological sequences be found efficiently with low space and near-linear time in practice?
• RQ2 What is the average-case time complexity of detecting approximate palindromes with k errors on real DNA sequences?
• RQ3 How does the algorithm perform on highly repetitive or AT-rich sequences that may cause worst-case behavior?
• RQ4 Can a worst-case O(k·n) time complexity be guaranteed while maintaining O(n) space usage?
• RQ5 What is the trade-off between algorithm simplicity and performance guarantees in approximate palindrome detection?

Key findings

• The simple algorithm runs in O(k·n) time on real DNA sequences such as Plasmodium falciparum chromosome 3 (1.06 Mb), processing it in 8.0s for k=10.
• For k=20 and k=40, the same sequence was processed in 10.2s and 14.3s respectively, confirming near-linear scaling with k.
• The algorithm performs fewer than 3.7(k+1)n symbol comparisons on real DNA, indicating efficient practical behavior.
• The worst-case O(n²) time complexity occurs only on pathological strings like Aⁿ or (AT)ⁿ/², which are rare in real biological data.
• The complex algorithm guarantees O(k·n) worst-case time by replacing the loop with a constant-time operation using suffix trees and LCA preprocessing.
• The algorithm correctly identifies approximate palindromes with minimal cost, preferring the cheapest alignment and decomposition.