A seed in a word is a relaxed version of a period in which the occurrences of the repeating subword may overlap. Our first contribution is a linear-time algorithm computing a linear-size representation of all seeds of a word (the number of seeds might be quadratic). In particular, one can easily derive the shortest seed and the number of seeds from our representation. Thus, we solve an open problem stated in a survey by Smyth from 2000 and improve upon a previous O(n log n)-time algorithm by Iliopoulos et al. from 1996. Our approach is based on combinatorial relations between seeds and subword complexity (used here for the first time in the context of seeds). In previous papers, compact representations of seeds consisted of two independent parts operating on the suffix tree of the input word and the suffix tree of its reverse, respectively. Our second contribution is a novel and significantly simpler representation of all seeds that avoids dealing with the suffix tree of the reversed word. This result is also of independent interest from a combinatorial point of view. A preliminary version of this work, with a much more complex algorithm constructing a representation of seeds on two suffix trees, was presented at the 23rd Annual ACM-SIAM Symposium on Discrete Algorithms (SODA’12).

A Linear-Time Algorithm for Seeds Computation

A k-antipower (for $k \ge 2$) is a concatenation of k pairwise distinct words of the same length. The study of antipower factors of a word was initiated by Fici et al. (ICALP 2016) and first algorithms for computing antipower factors were presented by Badkobeh et al. (Inf. Process. Lett., 2018). We address two open problems posed by Badkobeh et al. Our main results are algorithms for counting and reporting factors of a word which are k-antipowers. They work in $\mathcal {O}(nk \log k)$ time and $\mathcal {O}(nk \log k\,+\,C)$ time, respectively, where C is the number of reported factors. For $k=o(\sqrt{n/\log n})$, this improves the time complexity of $\mathcal {O}(n^2/k)$ of the solution by Badkobeh et al. Our main algorithmic tools are runs and gapped repeats. We also present an improved data structure that checks, for a given factor of a word and an integer k, if the factor is a k-antipower.

Efficient Representation and Counting of Antipower Factors in Words

Although real-world text datasets, such as DNA sequences, are far from being uniformly random, string searching average-case 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 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 $\mathcal {O}(n\frac{(c\log n)^k}{k!})$ time on average, where $c>1$ is a constant, using $\mathcal {O}(n)$ space. Finally, we show that our technique is applicable to several algorithmic problems found in computational biology and elsewhere. The importance of our technique lies on the fact that it is the first one achieving this bound for non-constant k and using $\mathcal {O}(n)$ space.

Longest Common Prefixes with k-Errors and Applications

Recently, Fici, Restivo, Silva, and Zamboni defined a $k$-anti-power to be a word of the form $w_1w_2\cdots w_k$, where $w_1,w_2,\ldots,w_k$ are distinct words of the same length. They defined $AP(x,k)$ to be the set of all positive integers $m$ such that the prefix of length $km$ of the word $x$ is a $k$-anti-power. Let ${\bf t}$ denote the Thue-Morse word, and let $\mathcal F(k)=AP({\bf t},k)\cap(2\mathbb Z^+-1)$. For $k\geq 3$, $\gamma(k)=\min(\mathcal F(k))$ and $\Gamma(k)=\max((2\mathbb Z^+-1)\setminus\mathcal F(k))$ are well-defined odd positive integers. Fici et al. speculated that $\gamma(k)$ grows linearly in $k$. We prove that this is indeed the case by showing that $1/2\leq\displaystyle{\liminf_{k\to\infty}}(\gamma(k)/k)\leq 9/10$ and $1\leq\displaystyle{\limsup_{k\to\infty}}(\gamma(k)/k)\leq 3/2$. In addition, we prove that $\displaystyle{\liminf_{k\to\infty}}(\Gamma(k)/k)=3/2$ and $\displaystyle{\limsup_{k\to\infty}}(\Gamma(k)/k)=3$.

Anti-Power Prefixes of the Thue-Morse Word

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$. The fastest known algorithm for $k=1$ requires time $\mathcal {O}(mn \log n/\log \log n)$ and space $\mathcal {O}(n)$. We present two new algorithms that require worst-case time $\mathcal {O}(mn)$ and $\mathcal {O}(n \log n \log \log n)$, respectively, and space $\mathcal {O}(n)$, thus greatly improving the state of the art. Moreover, we present another algorithm that requires average-case time and space $\mathcal {O}(n)$ for integer alphabets of size $\sigma $ if $m=\varOmega (\log _\sigma n)$. Notably, we show that this algorithm is generalizable for arbitrary k, requiring average-case time $\mathcal {O}(kn)$ and space $\mathcal {O}(n)$ if $m=\varOmega (k\log _\sigma n)$.

/pdf/faster-algorithms-for-1-mappability-of-a-sequence-3me5fe0udc.pdf

Faster Algorithms for 1-Mappability of a Sequence

A string S[1, n] is a power (or repetition or tandem repeat) of order k and period n/k, if it can be decomposed into k consecutive identical blocks each n/k letters in length. Powers and periods are fundamental structures in the study of strings and algorithms to compute them efficiently have been widely studied. Recently, Fici et al. (Proc. ICALP 2016) introduced an antipower of order k to be a string composed of k distinct blocks of the same length, n/k, called the antiperiod. Antipowers are a natural converse to powers, and are objects of combinatorial interest in their own right. In this paper, we describe efficient algorithm for computing the smallest antiperiod t of a string S of length n in O(n log∗ t) time. We also describe an algorithm to compute all the antiperiods of S that runs in O(n log n) time.

https://drops.dagstuhl.de/opus/volltexte/2019/10503/pdf/LIPIcs-CPM-2019-32.pdf/

Computing the Antiperiod(s) of a String

We propose a new algorithm for computing the longest prefix of each suffix of a given string of length n over a constant-sized alphabet of size $\sigma $ that occurs elsewhere in the string with Hamming distance at most k. Specifically, we show that the proposed algorithm requires time $\mathcal {O}(n (\sigma R)^k \log \log n (\log k+ \log \log n))$ on average, where $R=\lceil (k+2) (\log _{\sigma } n+1) \rceil $, and space $\mathcal {O}(n)$. This improves upon the state-of-the-art average-case time complexity for the case when $k=1$ [23] by a factor of $\log n / \log ^3 \log n$. In addition, we show how the proposed technique can be adapted and applied in order to compute the longest previous factors under the Hamming distance model within the same complexities. In terms of real-world applications, we show that our technique can be directly applied to the problem of genome mappability.

Longest Common Prefixes with k-Mismatches and Applications

A closed string contains a proper factor occurring as both a prefix and a suffix but not elsewhere in the string. Closed strings were introduced by Fici (WORDS 2011) as objects of combinatorial interest. In this paper, we extend this definition to k-closed strings, for which a level of approximation is permitted up to a number of Hamming distance errors, set by the parameter k. We then address the problem of identifying whether or not a given string of length n over an integer alphabet is k-closed and additionally specifying the border resulting in the string being k-closed. Specifically, we present an $\mathcal {O}(kn)$-time and $\mathcal {O}(n)$-space algorithm to achieve this along with the pseudocode of an implementation.

Efficient Identification of k-Closed Strings

Web spambots are becoming more advanced, utilizing techniques that can defeat existing spam detection algorithms. These techniques include performing a series of malicious actions with variable time delays, repeating the same series of malicious actions multiple times, and interleaving legitimate (decoy) and malicious actions. Existing methods that are based on string pattern matching are not able to detect spambots that use these techniques. In response, we define a new problem to detect spambots utilizing the aforementioned techniques and propose an efficient algorithm to solve it. Given a dictionary of temporally annotated sequences $\hat{S}$ modeling spambot actions, each associated with a time window, a long, temporally annotated sequence T modeling a user action log, and parameters f and k, our problem seeks to detect each sequence in $\hat{S}$ that occurs in T at least f times within its associated time window, and with at most k mismatches. Our algorithm solves the problem exactly, it requires linear time and space, and it employs advanced data structures and the Kangaroo method, to deal with the problem efficiently.

Efficiently Detecting Web Spambots in a Temporally Annotated Sequence

An increasing number of applications, in domains ranging from bio-medicine to business and to pervasive computing, feature data represented as a long sequence of symbols (string). Sharing these data, however, may lead to the disclosure of sensitive patterns which are represented as substrings and model confidential information. Such patterns may model, for example, confidential medical knowledge, business secrets, or signatures of activity patterns that may risk the privacy of smart-phone users. In this paper, we study the novel problem of concealing a given set of sensitive patterns from a string. Our approach is based on injecting a minimal level of uncertainty to the string, by replacing selected symbols in the string with a symbol “$*$” that is interpreted as any symbol from the set of possible symbols that may appear in the string. To realize our approach, we propose an algorithm that efficiently detects occurrences of the sensitive patterns in the string and then sanitizes these sensitive patterns. We also present a preliminary set of experiments to demonstrate the effectiveness and efficiency of our algorithm.

/pdf/towards-string-sanitization-318k5ldfyd.pdf

Hayam Alamro

Papers

Computing the Antiperiod(s) of a String

Longest Common Prefixes with k-Mismatches and Applications

Efficient Identification of k-Closed Strings

Efficiently Detecting Web Spambots in a Temporally Annotated Sequence

Towards String Sanitization