Longest Common Prefixes with k-Mismatches and Applications

String Processing and Information Retrieval

et al. 2018

Self Cite

Although real-world text datasets, such as DNA sequences, are far from being uniformly random, average-case string searching algorithms perform significantly better than worst-case ones in most applications of interest. In this paper, we study the problem of computing the longest prefix of each suffix of a given string of length n over a constantsized alphabet that occurs elsewhere in the string with k-errors. This problem has already been studied under the Hamming distance model. Our first result is an improvement upon the state-of-the-art average-case time complexity for non-constant k and using only linear space under the Hamming distance model. Notably, we show that our technique can be extended to the edit distance model with the same time and space complexities. Specifically, our algorithms run in O(n log k n log log n) time on average using O(n) space. We show that our technique is applicable to several algorithmic problems in computational biology and elsewhere.

Section: Introductionmentioning

confidence: 88%

Section: Genome Mappability Data Structurementioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Longest Common Prefixes with k-Errors and Applications

Ayad

Barton

String Processing and Information Retrieval

et al. 2018

Self Cite

“…If d = m, we have successfully spelled S m 1 arriving at an explicit node v or an implicit node along an edge (u, v). In this case, we increment A [1] by C(v) if and only if d H (S m 1 , T m 1 ) = k. If D(v) = m, we follow its suffix link arriving by construction to a node of depth m − 1; if not, we follow the suffix link of its parent u and traverse the edges down until we reach depth m − 1. (Note that we know which edges we need to traverse by looking at S.) From this point onward, we process substring S m i , for all 2 ≤ i ≤ n − m + 1, analogously.…”

Section: O(n Log K+1 N)-time and O(n)-space Algorithmmentioning

confidence: 99%

Efficient Computation of Sequence Mappability

Alzamel

String Processing and Information Retrieval

Iliopoulos

et al. 2018

Self Cite

Sequence mappability is an important task in genome re-sequencing. In the (k, m)-mappability problem, for a given sequence T of length n, our goal is to compute a table whose ith entry is the number of indices j = i such that length-m substrings of T starting at positions i and j have at most k mismatches. Previous works on this problem focused on heuristic approaches to compute a rough approximation of the result or on the case of k = 1. We present several efficient algorithms for the general case of the problem. Our main result is an algorithm that works in O(n min{m k , log k+1 n}) time and O(n) space for k = O(1). It requires a careful adaptation of the technique of Cole et al. [STOC 2004] to avoid multiple counting of pairs of substrings. We also show O(n 2 )-time algorithms to compute all results for a fixed m and all k = 0, . . . , m or a fixed k and all m = k, . . . , n − 1. Finally we show that the (k, m)-mappability problem cannot be solved in strongly subquadratic time for k, m = Θ(log n) unless the Strong Exponential Time Hypothesis fails.

“…For k = O(1) and constant-sized alphabets, there is an algorithm requiring O(min{nm k , n log k+1 n}) time and O(n) space [7]. In [8] the authors introduced an efficient construction of a genome mappability array B k in which B k [μ] is the smallest length m such that at least μ of the length-m factors of x do not occur elsewhere in x with at most k mismatches. The construction algorithm was later improved in [9].…”

Section: Introductionmentioning

confidence: 99%

Faster algorithms for 1-mappability of a sequence

Alzamel

Theoretical Computer Science

Iliopoulos

et al. 2020

Self Cite

In the k-mappability problem, we are given a string x of length n and integers m and k, and we are asked to count, for each length-m factor y of x, the number of other factors of length m of x that are at Hamming distance at most k from y. We focus here on the version of the problem where k = 1. There exists an algorithm to solve this problem for k = 1 requiring time O(mn log n/ log log n) using space O(n). Here we present two new algorithms that require worst-case time O(mn) and O(n log n log log n), respectively, and space O(n), thus greatly improving the previous result. Moreover, we present another algorithm that requires average-case time and space O(n) for integer alphabets of size σ if m = (log σ n). Notably, we show that this algorithm is generalizable for arbitrary k, requiring average-case time O(kn) and space O(n) if m = (k log σ n), assuming that the letters are independent and uniformly distributed random variables. Finally, we provide an experimental evaluation of our average-case algorithm demonstrating its competitiveness to the state-of-the-art implementation.