7 research outputs found
Longest substring palindrome after edit
It is known that the length of the longest substring palindromes (LSPals) of a given string T of length n can be computed in O(n) time by Manacher\u27s algorithm [J. ACM \u2775]. In this paper, we consider the problem of finding the LSPal after the string is edited. We present an algorithm that uses O(n) time and space for preprocessing, and answers the length of the LSPals in O(log (min {sigma, log n })) time after single character substitution, insertion, or deletion, where sigma denotes the number of distinct characters appearing in T. We also propose an algorithm that uses O(n) time and space for preprocessing, and answers the length of the LSPals in O(l + log n) time, after an existing substring in T is replaced by a string of arbitrary length l
Small-Space LCE Data Structure with Constant-Time Queries
The longest common extension (LCE) problem is to preprocess a given string w of length n so that the length of the longest common prefix between suffixes of w that start at any two given positions is answered quickly. In this paper, we present a data structure of O(z tau^2 + frac{n}{tau}) words of space which answers LCE queries in O(1) time and can be built in O(n log sigma) time, where 1 leq tau leq sqrt{n} is a parameter, z is the size of the Lempel-Ziv 77 factorization of w and sigma is the alphabet size. The proposed LCE data structure not access the input string w when answering queries, and thus w can be deleted after preprocessing. On top of this main result, we obtain further results using (variants of) our LCE data structure, which include the following:
- For highly repetitive strings where the ztau^2 term is dominated by frac{n}{tau}, we obtain a constant-time and sub-linear space LCE query data structure.
- Even when the input string is not well compressible via Lempel-Ziv 77 factorization, we still can obtain a constant-time and sub-linear space LCE data structure for suitable tau and for sigma leq 2^{o(log n)}.
- The time-space trade-off lower bounds for the LCE problem by Bille et al. [J. Discrete Algorithms, 25:42-50, 2014] and by Kosolobov [CoRR, abs/1611.02891, 2016] do not apply in some cases with our LCE data structure
Parallel Longest Increasing Subsequence and van Emde Boas Trees
This paper studies parallel algorithms for the longest increasing subsequence
(LIS) problem. Let be the input size and be the LIS length of the
input. Sequentially, LIS is a simple problem that can be solved using dynamic
programming (DP) in work. However, parallelizing LIS is a
long-standing challenge. We are unaware of any parallel LIS algorithm that has
optimal work and non-trivial parallelism (i.e., or
span).
This paper proposes a parallel LIS algorithm that costs work,
span, and space, and is much simpler than the previous
parallel LIS algorithms. We also generalize the algorithm to a weighted version
of LIS, which maximizes the weighted sum for all objects in an increasing
subsequence. To achieve a better work bound for the weighted LIS algorithm, we
designed parallel algorithms for the van Emde Boas (vEB) tree, which has the
same structure as the sequential vEB tree, and supports work-efficient parallel
batch insertion, deletion, and range queries.
We also implemented our parallel LIS algorithms. Our implementation is
light-weighted, efficient, and scalable. On input size , our LIS
algorithm outperforms a highly-optimized sequential algorithm (with cost) on inputs with . Our algorithm is also much faster
than the best existing parallel implementation by Shen et al. (2022) on all
input instances.Comment: to be published in Proceedings of the 35th ACM Symposium on
Parallelism in Algorithms and Architectures (SPAA '23