A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2020; you can also visit the original URL.
The file type is `application/pdf`

.

## Filters

##
###
Space Efficient Construction of Lyndon Arrays in Linear Time
[article]

2019
*
arXiv
*
pre-print

We present the first

arXiv:1911.03542v2
fatcat:nygmqmb2dncr7nvnpzfrncmuoa
*linear**time*algorithm to*construct*the 2n-bit version*of*the*Lyndon**array*for a string*of*length n using only o(n) bits*of*working*space*. ... Also*in*practice, our new algorithms outperform the previous best ones by an order*of*magnitude, both*in*terms*of**time*and*space*. ... The*construction*algorithm can also produce the (non-succinct)*Lyndon**array**in**linear**time*using only O(1) words*of*working*space*. ...##
###
Space Efficient Construction of Lyndon Arrays in Linear Time

2020
*
International Colloquium on Automata, Languages and Programming
*

We show that,

doi:10.4230/lipics.icalp.2020.14
dblp:conf/icalp/BilleE0GKMR20
fatcat:vovgnfe4bzdjneygn36ukpj47i
*in*fact, o(n) additional bits are sufficient to compute the succinct 2n-bit version*of*the*Lyndon**array**in**linear**time*. ... Our*space**efficient**construction*algorithm makes the*Lyndon**array*more accessible as a fundamental data structure*in*applications like full-text indexing. ... We have shown: 14:16*Space**Efficient**Construction**of**Lyndon**Arrays**in**Linear**Time*The algorithm can easily be adapted to compute the*Lyndon**array*instead*of*the PSS tree. ...##
###
Linear Algorithms for Computing the Lyndon Border Array and the Lyndon Suffix Array
[article]

2015
*
arXiv
*
pre-print

Further, we introduce the

arXiv:1506.06983v1
fatcat:ndguexynefe5tbtngdvojio4om
*Lyndon*Suffix*Array*, and by modifying the*efficient*suffix*array*technique*of*Ko and Aluru KA03 outline a*linear**time*and*space*algorithm for its*construction*. ... We propose*linear*-*time*and*linear*-*space*algorithms for computing L β (s). binary and bounded alphabets. ...*In*order to*efficiently**construct*the*Lyndon*suffix*array*we could directly modify the*linear*-*time*and*space**efficient*method*of*Ko and Aluru [KA03] given for the original data structure -this would ...##
###
Extended suffix array construction using Lyndon factors

2018
*
Sadhana (Bangalore)
*

*In*this paper, we are extending the novel approach

*of*incremental suffix

*array*

*construction*using

*Lyndon*factorization to the

*construction*

*of*extended suffix

*array*where extended suffix

*array*is the suffix ... Incremental LCP

*construction*simultaneously saves a lot

*of*computation and hence

*time*. The proposed approach has quadratic run

*time*and the disk working

*space*requirement is O(n). ... So, we can compute SA

*in*

*linear*

*time*i.e., O(m) and O(m log m) bits

*of*

*space*using any

*of*the existing

*linear*

*time*suffix

*array*

*construction*algorithm like libdivsufsort. ...

##
###
Inducing the Lyndon Array
[article]

2019
*
arXiv
*
pre-print

Our result improves the previous best

arXiv:1905.12987v2
fatcat:6mwhqkru3ncudhsnmvco7by2z4
*space*requirement for*linear**time*computation*of*the*Lyndon**array*. ...*In*fact, all the known*linear*algorithms for*Lyndon**array*computation use suffix sorting as a preprocessing step and use O(n) words*of*working*space**in*addition to the*Lyndon**array*and suffix*array*. ... Acknowledgments The authors thank Uwe Baier for kindly providing the source codes*of*algorithms Baier-LA and Baier-LA+SA, and Prof. ...##
###
Indeterminate String Factorizations and Degenerate Text Transformations

2017
*
Mathematics in Computer Science
*

Like the original forms, indeterminate

doi:10.1007/s11786-016-0285-x
fatcat:dpic7m34xnctxlsraukgtngx6m
*Lyndon*factorization and the degenerate transform and its inverse can all be computed*in**linear**time*and*space*with respect to total input size*of*degenerate strings ... For*space**efficiency*the input to the transform can be preprocessed into*Lyndon*factors. ... For*constructing*the indeterminate suffix*array*we will apply a*linear*-*time*and*space**efficient*method such as that*of*Ko and Aluru [22] given for the original data structure. ...##
###
2D Lyndon Words and Applications
[article]

2013
*
arXiv
*
pre-print

The final algorithm achieves

arXiv:1301.0103v1
fatcat:gxb6t7y3rzcxff6cjrs2pwjppi
*linear**time*complexity even when the least common multiple*of*the periods*of*the rows is exponential*in*the matrix width. ...*Lyndon*words are used for*constructing*bases*in*free Lie algebras,*constructing*de Bruijn sequences, finding the lexicographically smallest or largest substring*in*a string, and succinct suffix-prefix ...*In*terms*of**space*, the representative 2D*Lyndon*word is stored*in*O(m log m) bits since it is an*array**of*m integers, each*of*which is between 0 and m/4. ...##
###
Sorting suffixes of a text via its Lyndon Factorization
[article]

2013
*
arXiv
*
pre-print

They are used for instance

arXiv:1306.1366v1
fatcat:f657xqdlfzdctehp7ynp4m67dy
*in*the*constructions**of*the Burrows-Wheeler transform and the suffix*array*, widely used*in*several fields*of*Computer Science. ... The process*of*sorting the suffixes*of*a text plays a fundamental role*in*Text Algorithms. ... Duval*in*[11] presents two variants*of*an algorithm*of*factorization*of*a word into*Lyndon*words*in**time**linear**in*the length*of*the word. ...##
###
Constructing the Bijective and the Extended Burrows-Wheeler Transform in Linear Time
[article]

2021
*
arXiv
*
pre-print

also be

arXiv:1911.06985v2
fatcat:bu7t7ukgvzfzdnfzuhoilfdul4
*constructed**in**linear**time*. ... Although it is known that the BWT can be*constructed**in**linear**time*for integer alphabets by using a*linear**time*suffix*array**construction*algorithm, it was up to now only conjectured that the BBWT can ... Let us start with the traditional BWT, which we can*construct*thanks to*linear**time*suffix*array**construction*algorithms [23, 17] [12] postulated that it can be built*in**linear**time*, but did not ...##
###
Minimal Suffix and Rotation of a Substring in Optimal Time

2016
*
Annual Symposium on Combinatorial Pattern Matching
*

We develop a data structure answering such queries optimally:

doi:10.4230/lipics.cpm.2016.28
dblp:conf/cpm/Kociumaka16
fatcat:5ecfttqb4rcqraxd6ezwipepxq
*in*constant*time*after*linear*-*time*preprocessing. This improves upon the results*of*Babenko et al. ... We apply these generalized queries to compute lexicographically minimal and maximal rotations*of*a given substring*in*constant*time*after*linear*-*time*preprocessing. ... Acknowledgements I would like to thank the remaining co-authors*of*[4] , collaboration with whom on earlier results about minimal and maximal suffixes sparked some*of*my ideas used*in*this paper. ...##
###
Algorithms to Compute the Lyndon Array
[article]

2016
*
arXiv
*
pre-print

Two

arXiv:1605.08935v1
fatcat:ae4wn4ijnjhj5h3t23ziynaxri
*of*these algorithms execute*in*quadratic*time**in*the worst case, the third achieves*linear**time*, but at the expense*of*prior computation*of*both the suffix*array*and the inverse suffix*array**of*x. ... We conjecture that there exists a fast and worst-case*linear*-*time*algorithm to compute the*Lyndon**array*that is also elementary (making no use*of*global data structures such as the suffix*array*). ... This work was supported*in*part by the Natural Sciences & Engineering Research Council*of*Canada. The authors wish to thank Maxime Crochemore and Hideo Bannai for helpful discussions. ...##
###
Small-Space 2D Compressed Dictionary Matching
[chapter]

2010
*
Lecture Notes in Computer Science
*

The preprocessing

doi:10.1007/978-3-642-13509-5_4
fatcat:5bh3sc3woneqtlbnhvhi7wlxim
*time**of*the algorithm is O(km 2 ),*linear**in*the uncompressed dictionary size, and the*time*for performing the search is*linear**in*the uncompressed text size, independent*of*the dictionary ... ., the extra*space*it uses is proportional to the optimal compression*of*the dictionary, which is O(km). ... Its*time*complexity is*linear**in*the size*of*the text with preprocessing*time**linear**in*the size*of*the dictionary. ...##
###
Succinct 2D Dictionary Matching

2012
*
Algorithmica
*

The

doi:10.1007/s00453-012-9615-9
fatcat:v2a5t42otfcc5oz6osg4nw5tsa
*time*complexity*of*our algorithm is close to*linear*, O(dm 2 + n 2 τ log σ ), where τ is the*time*it takes to access a character*in*the compressed self-index and σ is the size*of*the alphabet. ... This paper presents the first*efficient*2-dimensional dictionary matching algorithm that operates*in*small*space*. ... This work has been supported*in*part by the National Science Foundation Grant BD&I 0542751 and the Professional Staff Congress-City University*of*New York Research Award 63343-0041. ...##
###
Efficiently computing runs on a trie
[article]

2021
*
arXiv
*
pre-print

Furthermore, we also show an O(nloglog n)

arXiv:1901.10633v3
fatcat:4d4sgehqb5d37ip72o2wbvljf4
*time*and O(n)*space*algorithm for finding all runs. ... We also show an asymptotic lower bound on the maximum density*of*runs*in*tries: lim_n→∞ρ_𝒯(n)/n ≥ 0.993238 where ρ_𝒯(n) is the maximum number*of*runs*in*a trie with n edges. ... From Lemma 3, the longest*Lyndon*word starting at each position*of*a string w can be computed*in**linear**time*, given the inverse suffix*array**of*w. ...##
###
Computing minimal and maximal suffixes of a substring

2016
*
Theoretical Computer Science
*

As a sample application, we show that this data structure can be used to compute the

doi:10.1016/j.tcs.2015.08.023
fatcat:wutx6cblkbaplokcp56wtsb4ea
*Lyndon*decomposition*of*any substring*of*the text*in*O(kτ )*time*, where k is the number*of*distinct factors*in*the decomposition ... For the maximal suffix problem, we give a*linear*-*space*structure with O(1) query*time*and O(n) preprocessing*time*. ... The suffix tree*of*a string can be*constructed**in**linear**time*and occupies*linear**space*. Once*constructed*, it allows to retrieve the maximal and the minimal suffixes*in*constant*time*. ...
« Previous

*Showing results 1 — 15 out of 565 results*