Yuto Nakashima
Kyushu University
Network
Latest external collaboration on country level. Dive into details by clicking on the dots.
Publication
Featured researches published by Yuto Nakashima.
SIAM Journal on Computing | 2017
Hideo Bannai; Tomohiro I; Shunsuke Inenaga; Yuto Nakashima; Masayuki Takeda; Kazuya Tsuruta
We give a new characterization of maximal repetitions (or runs) in strings based on Lyndon words. The characterization leads to a proof of what was known as the “runs” conjecture [R. M. Kolpakov an...
Theoretical Computer Science | 2016
Tomohiro I; Yuto Nakashima; Shunsuke Inenaga; Hideo Bannai; Masayuki Takeda
We present two efficient algorithms which, given a compressed representation of a string w of length N, compute the Lyndon factorization of w. Given a straight line program (SLP) S of size n that describes w, the first algorithm runs in O ( n 2 + P ( n , N ) + Q ( n , N ) n log ź n ) time and O ( n 2 + S ( n , N ) ) space, where P ( n , N ) , S ( n , N ) , Q ( n , N ) are respectively the pre-processing time, space, and query time of a data structure for longest common extensions (LCE) on SLPs. Given the Lempel-Ziv 78 encoding of size s for w, the second algorithm runs in O ( s log ź s ) time and space.
string processing and information retrieval | 2012
Yuto Nakashima; Tomohiro I; Shunsuke Inenaga; Hideo Bannai; Masayuki Takeda
The position heap is a text indexing structure for a single text string, recently proposed by Ehrenfeucht et al. [Position heaps: A simple and dynamic text indexing data structure, Journal of Discrete Algorithms, 9(1):100-121, 2011]. In this paper we introduce the position heap for a set of strings, and propose an efficient algorithm to construct the position heap for a set of strings which is given as a trie. For a fixed alphabet our algorithm runs in time linear in the size of the trie. We also show that the position heap can be efficiently updated after addition/removal of a leaf of the input trie.
Information Processing Letters | 2015
Yuto Nakashima; Tomohiro I; Shunsuke Inenaga; Hideo Bannai; Masayuki Takeda
We propose the first linear time algorithm to compute LZ78 trie over an integer alphabet.We propose a linear time algorithm to construct the position heap of a trie.LZ78 tries and position heaps can be superimposed on the corresponding suffix trees.Both of them can be computed by nearest marked ancestor queries on suffix trees. We present the first worst-case linear-time algorithm to compute the Lempel-Ziv 78 factorization of a given string over an integer alphabet. Our algorithm is based on nearest marked ancestor queries on the suffix tree of the given string. We also show that the same technique can be used to construct the position heap of a set of strings in worst-case linear time, when the set of strings is given as a trie.
string processing and information retrieval | 2016
Golnaz Badkobeh; Travis Gagie; Szymon Grabowski; Yuto Nakashima; Simon J. Puglisi; Shiho Sugimoto
Two strings X and Y are considered Abelian equal if the letters of X can be permuted to obtain Y (and vice versa). Recently, Alatabbi et al. (2015) considered the longest common Abelian factor problem in which we are asked to find the length of the longest Abelian-equal factor present in a given pair of strings. They provided an algorithm that uses \(O(\sigma n^2)\) time and \(O(\sigma n)\) space, where n is the length of the pair of strings and \(\sigma \) is the alphabet size. In this paper we describe an algorithm that uses \(O(n^2\log ^2n\log ^*n)\) time and \(O(n\log ^2n)\) space, significantly improving Alatabbi et al.’s result unless the alphabet is small. Our algorithm makes use of techniques for maintaining a dynamic set of strings under split, join, and equality testing (Melhorn et al., Algorithmica 17(2), 1997).
string processing and information retrieval | 2013
Tomohiro I; Yuto Nakashima; Shunsuke Inenaga; Hideo Bannai; Masayuki Takeda
We present two efficient algorithms which, given a compressed representation of a string w of length N, compute the Lyndon factorization of w. Given a straight line program (SLP)
Theoretical Computer Science | 2017
Yuto Nakashima; Takashi Okabe; Tomohiro I; Shunsuke Inenaga; Hideo Bannai; Masayuki Takeda
\mathcal{S}
mathematical foundations of computer science | 2014
Yuto Nakashima; Takashi Okabe; Tomohiro I; Shunsuke Inenaga; Hideo Bannai; Masayuki Takeda
of size n and height h that describes w, the first algorithm runs in O(nh(n + logN logn)) time and O(n 2) space. Given the Lempel-Ziv 78 encoding of size s for w, the second algorithm runs in O(s logs) time and space.
symposium on theoretical aspects of computer science | 2017
Juha Kärkkäinen; Dominik Kempa; Yuto Nakashima; Simon J. Puglisi; Arseny M. Shur
The Lyndon factorization of a string w is a unique factorization \(\ell_1^{p_1}, \ldots, \ell_m^{p_m}\) of w s.t. l1, …, l m is a sequence of Lyndon words that is monotonically decreasing in lexicographic order. In this paper, we consider the reverse-engineering problem on Lyndon factorization: Given a sequence S = ((s 1, p 1), …, (s m , p m )) of ordered pairs of positive integers, find a string w whose Lyndon factorization corresponds to the input sequence S, i.e., the Lyndon factorization of w is in a form of \(\ell_1^{p_1}, \ldots, \ell_m^{p_m}\) with |l i | = s i for all 1 ≤ i ≤ m. Firstly, we show that there exists a simple O(n)-time algorithm if the size of the alphabet is unbounded, where n is the length of the output string. Secondly, we present an O(n)-time algorithm to compute a string over an alphabet of the smallest size. Thirdly, we show how to compute only the size of the smallest alphabet in O(m) time. Fourthly, we give an O(m)-time algorithm to compute an O(m)-size representation of a string over an alphabet of the smallest size. Finally, we propose an efficient algorithm to enumerate all strings whose Lyndon factorizations correspond to S.
combinatorial pattern matching | 2018
Kotaro Aoyama; Yuto Nakashima; Tomohiro I; Shunsuke Inenaga; Hideo Bannai; Masayuki Takeda
The Lyndon factorization of a string w is a unique factorization \(\ell_1^{p_1}, \ldots, \ell_m^{p_m}\) of w s.t. l1, …, l m is a sequence of Lyndon words that is monotonically decreasing in lexicographic order. In this paper, we consider the reverse-engineering problem on Lyndon factorization: Given a sequence S = ((s 1, p 1), …, (s m , p m )) of ordered pairs of positive integers, find a string w whose Lyndon factorization corresponds to the input sequence S, i.e., the Lyndon factorization of w is in a form of \(\ell_1^{p_1}, \ldots, \ell_m^{p_m}\) with |l i | = s i for all 1 ≤ i ≤ m. Firstly, we show that there exists a simple O(n)-time algorithm if the size of the alphabet is unbounded, where n is the length of the output string. Secondly, we present an O(n)-time algorithm to compute a string over an alphabet of the smallest size. Thirdly, we show how to compute only the size of the smallest alphabet in O(m) time. Fourthly, we give an O(m)-time algorithm to compute an O(m)-size representation of a string over an alphabet of the smallest size. Finally, we propose an efficient algorithm to enumerate all strings whose Lyndon factorizations correspond to S.