Czekaj...Wczytywanie... Nie jesteś zalogowany | zaloguj się

## Wydział Matematyki, Informatyki i Mechaniki Uniwersytetu Warszawskiego

• Skala szarości
• Wysoki kontrast
• Negatyw
• Reset

# Aktualności — Wydarzenia

Sem. Algorytmika

## Efficient Computation of 2-Covers of a String

Prelegent: Juliusz Straszyński

2020-12-17 12:15

Quasiperiodicity is a generalization of periodicity that has been researched for almost 30 years. The notion of cover is the classic variant of quasiperiodicity. A cover of a text T is a string whose occurrences in T cover all positions of T.

There are several algorithms computing covers of a text in linear time. In this paper we consider a natural extension of cover. For a text T, we call a pair of strings a 2-cover if they have the same length and their occurrences cover the text T. We give an algorithm that computes all 2-covers of a string of length n in \mathcal{O}(n \log n \log \log n + \textsf{output}) expected time or \mathcal{O}(n \log n \log^2 \log n / \log \log \log n + \textsf{output}) worst-case time, where \textsf{output} is the size of output.

If (X,Y) is a 2-cover of T, then either X is a prefix and Y is a suffix of T, in which case we call (X,Y) a ps-cover, or one of X, Y is a border (that is, both a prefix and a suffix) of T, and then we call (X,Y) a b-cover. A string of length n has up to n ps-covers; we show an algorithm that computes all of them in \mathcal{O}(n \log \log n) expected time or \mathcal{O}(n \log^2 \log n / \log \log \log n) worst-case time. A string of length n can have \Theta (n^2) non-trivial b-covers; our algorithm can report one b-cover per length (if it exists) or all shortest b-covers in \mathcal{O}(n \log n \log \log n) expected time or \mathcal{O}(n \log n \log^2 \log n / \log \log \log n) worst-case time. All our algorithms use linear space.

The problem in scope can be generalized to \lambda > 2 equal-length strings, resulting in the notion of \lambda-cover. Cole et al. (2005) showed that the \lambda-cover problem is NP-complete. Our algorithms generalize to \lambda-covers, with (the first component of) the algorithm’s complexity multiplied by n^{\lambda-2}.