Efficiently computing runs on a trie

TL;DR

This paper introduces an efficient method to compute and bound the number of runs in tries, a type of rooted edge-labeled tree, with a new algorithm achieving near-linear time complexity.

Contribution

The paper establishes an upper bound on the number of runs in tries and presents an $O(n \log \log n)$ time algorithm for their enumeration.

Findings

Number of runs in a trie is less than the number of edges.

Asymptotic lower bound on maximum run density in tries is approximately 0.993238.

Proposed algorithm runs in $O(n \log \log n)$ time and uses $O(n)$ space.

Abstract

A maximal repetition, or run, in a string, is a maximal periodic substring whose smallest period is at most half the length of the substring. In this paper, we consider runs that correspond to a path on a trie, or in other words, on a rooted edge-labeled tree where the endpoints of the path must be a descendant/ancestor of the other. For a trie with $n$ edges, we show that the number of runs is less than $n$. We also show an asymptotic lower bound on the maximum density of runs in tries: $\lim_{n\rightarrow\infty}\rho_\mathcal{T}(n)/n \geq 0.993238$ where $\rho_{\mathcal{T}}(n)$ is the maximum number of runs in a trie with $n$ edges. Furthermore, we also show an $O(n\log \log n)$ time and $O(n)$ space algorithm for finding all runs.

Equations

$$\frac{{\rho }_{\mathcal{T}}(n)}{n}\ge \frac{2282327k}{n}\ge \frac{2282327k}{284250(k+1)}.$$

$$\{LC{E}_{PT}(l_1,v_1,w_1),\dots ,LC{E}_{PT}(l_k,v_k,w_k)\}$$

$$\{LC{E}_{PT}(l_1^{\prime },v_1^{\prime },w_1^{\prime }),\dots ,LC{E}_{PT}(l_k^{\prime },v_k^{\prime },w_k^{\prime })\}$$

$$S_1=\{(s_t,c_t,t)\mid t\in T,s_t=anc(b^{4/5},t)\},$$

$$S_2=\{(w_i,c_{e_i},\perp )\mid i\in \{1,\dots ,k\}\},$$

$$S_3=\{(s_{t,j},c_{t,j},t)\mid t\in T,j\in \{1,\dots ,\sqrt{x}\},s_{t,j}=anc(j\cdot x^2,t)\}$$

$$S_4=\{(w_i^{\prime \prime \prime },c_i^{\prime \prime \prime },\perp )\mid i\in \{1,\dots ,k\}\}.$$

Full text

††journal: Theoretical Computer SCience

1 Introduction

Repetitions are fundamental characteristics of strings, and their combinatorial properties as well as their efficient computation has been a subject of extensive studies. Maximal periodic substrings, or runs, is one of the most important types of repetitions, since they essentially capture all occurrences of consecutively repeating substrings in a given string. One of the reasons which makes runs important and interesting is that the number of runs contained in a given string of length $n$ is $O(n)$ [1], in fact, less than $n$ [2], and can be computed in $O(n)$ time [1, 3]. Note that the total number of occurrences of squares in a string can be $\Theta(n^{2})$, or $\Theta(n\log n)$ for only primitive squares.

In this paper, we consider runs that correspond to a path on a trie, or in other words, on a rooted edge-labeled tree where the endpoints of the path must be a descendant/ancestor of the other. The contributions of this paper are threefold. For a trie with $n$ edges, we show:

Upper bound: $\rho(n)\leq n$, where $\rho(n)$ is the maximum number of runs in a trie with $n$ edges.

• 2.

Lower bound: $\lim_{n\rightarrow\infty}\rho_{\mathcal{T}}(n)/n\geq 0.993238$.

• 3.

Algorithm: $O(n\log\log n)$ time and $O(n)$ space algorithm for computing all runs in a trie, assuming an integer alphabet.

A preliminary version of this paper which described an $O(n(\log\log n)^{2})$ time and $O(n)$ space algorithm appeared in [4]. The running time has been improved to $O(n\log\log n)$. This paper also gives tighter lower bounds than in [4].

1.1 Related Work

A similar problem was considered in [5, 6, 7], but differs in three aspects: they consider distinct repetitions with integer powers on an unrooted (or undirected) tree. In this work, we consider occurrences of repetitions with maximal (possibly fractional) powers on a rooted (or directed) tree.

Funakoshi et al. [8] show how to compute all maximal palindromes and all distinct palindromes in tries, in $O(n\log h)$ time, where $h$ is the height of the trie. Interestingly, the upper bound on the number of maximal palindromes and distinct palindromes in a trie are also known to be $O(n)$, but a linear time algorithm has not yet been discovered.

2 Preliminaries

2.1 Strings, Periods, Maximal Repetitions, Lyndon Words

Let $\Sigma=\{1,\ldots,\sigma\}$ denote the alphabet. We consider an integer alphabet, i.e., $\sigma=n^{c}$ for some constant $c$. $\Sigma^{*}$ is the set of strings over $\Sigma$. For any string $w\in\Sigma^{*}$, let $w[i]$ denote the $i$th symbol of $w$, and $|w|$ the length of $w$. For any $1\leq i\leq j\leq|w|$, let $w[i..j]=w[i]\cdots w[j]$. For technical reasons, we assume that $w$ is followed by a distinct character (i.e. $w[|w|+1]$) in $\Sigma$ that does not occur in $w[1..|w|]$.

A string is primitive, if it is not a concatenation of 2 or more complete copies of the same string. A string $w=u^{2}$, for some string $u$, is called a square, and in particular, if $u$ is primitive, then $w$ is called a primitively rooted square. An integer $1\leq p\leq|w|$ is called a period of $w$, if $w[i]=w[i+p]$ for all $1\leq i\leq|w|-p$. The smallest period of $w$ will be denoted by $\mathit{per}(w)$. For any period $p$ of $w$, there exists a string $x$, called a border of $w$, such that $|x|=|w|-p$ and $w=xy=zx$ for some $y,z$. A string is a repetition, if its smallest period is at most half the length of the string. A maximal repetition, or run, is a maximal periodic substring that is a repetition, i.e., a maximal repetition of a string $w$ is an interval $[i..j]$ of positions where $\mathit{per}(w[i..j])\leq(j-i+1)/2$, and $\mathit{per}(w[i..j])\neq\mathit{per}(w[i^{\prime}..j^{\prime}])$ for any $1\leq i^{\prime}\leq i$ and $j\leq j^{\prime}\leq n$ such that $i^{\prime}\neq i$ or $j^{\prime}\neq j$. In other words, a run contains at least two consecutive occurrences of a substring of length $p$, and the periodicity does not extend to the left or right of the run. The smallest period of the run will be called the period of the run. The fraction $(j-i+1)/p\geq 2$ is called the exponent of the run.

Let $\prec_{0}$ denote an arbitrary total ordering on $\Sigma$, as well as the lexicographic ordering on $\Sigma^{*}$ induced by this ordering. We also consider the reverse ordering $\prec_{1}$ on $\Sigma$ (i.e., $\forall a,b\in\Sigma,a\prec_{0}b\iff b\prec_{1}a$), and the induced lexicographic ordering on $\Sigma^{*}$. For $\ell\in\{0,1\}$, let $\bar{\ell}=1-\ell$. A string $w$ is a Lyndon word w.r.t. to a given lexicographic ordering, if $w$ is lexicographically smaller than any of its proper suffixes. A well known fact is that a Lyndon word cannot have a non-empty proper border, since a non-empty proper border of a word is a suffix that is lexicographically smaller than the word itself.

Crochemore et al. observed that in any run $[i..j]$ with period $p$, and any lexicographic ordering, there exists a substring of length $p$ in the run, that is a Lyndon word [9, 10]. Such Lyndon words are called L-roots. Below, we briefly review the main result of [2] which essentially tied longest Lyndon words starting at specific positions within the run, to L-roots of runs. This will be the basis for our new results for tries.

Lemma 1** (Lemma 3.2 of [2])**

For any position $1\leq i\leq|w|$ of string $w$, let $\ell\in\{0,1\}$ be such that $w[k]\prec_{\ell}w[i]$ for $k=\min\{k^{\prime}\mid w[k^{\prime}]\neq w[i],k^{\prime}>i\}$. Then, the longest Lyndon word that starts at position $i$ is $w[i..i]$ w.r.t $\prec_{\ell}$, and $w[i..j]$ for some $j\geq k$ w.r.t. $\prec_{\bar{\ell}}$.111Note that $j$ becomes $|w|+1$ when $i=|w|$.

Lemma 2** (Lemma 3.3 of [2])**

Let $r=[i..j]$ be a run in $w$ with period $p$, and let $\ell\in\{0,1\}$ be such that $w[j+1]\prec_{\ell}w[j+1-p]$. Then, any L-root $w[i^{\prime}..j^{\prime}]$ of $r$ with respect to $\prec_{\ell}$ is the longest Lyndon word with respect to $\prec_{\ell}$ that is a prefix of $w[i^{\prime}..|w|]$.

Since an L-root cannot be shared by two different runs, it follows from Lemma 2 that the number of runs is at most $2n$, since each position can be the starting point of at most two L-roots that correspond to distinct runs. In [2], a stronger bound of $n$ was shown from the observation that each run contains at least one L-root that does not begin at the first position of the run, and that the two longest Lyndon words starting at a given position for the two lexicographic orders cannot simultaneously be such L-roots of runs. This is because if $w[i^{\prime}..i^{\prime}]$ and $w[i^{\prime}..j^{\prime}]$ were L-roots and the runs start before position $i^{\prime}$, then, from the periods of the two runs, it must be that $w[i^{\prime}-1]=w[i^{\prime}]=w[j^{\prime}]$ contradicting that $w[i^{\prime}..j^{\prime}]$ is a Lyndon word and cannot have a non-empty border. In Section 3.1, we will see that the last argument does not completely carry over to the case of tries, but show that we can still improve the bound again to $n$.

The above lemmas also lead to a new linear time algorithm for computing all runs, that consists of the following steps:

compute the longest Lyndon word that starts at each position for both lexicographic orders $\prec_{0}$ and $\prec_{1}$, 2. 2.

check whether there is a run for which the longest Lyndon word corresponds to an L-root.

There are several ways to compute the first step in amortized constant time for each position, but it can essentially be reduced to computing the next smaller values (NSV) in the inverse suffix array of the string. We describe the algorithm in more detail in Section 3.2, and will see that the amortization of the standard algorithm does not carry over to the trie case. We give a new linear time algorithm using the static tree set-union data structure (more specifically, decremental nearest marked ancestor queries) [11], which does carry over to the trie case.

The second step can be computed in constant time per candidate L-root with linear time-preprocessing, by using longest common extension queries (e.g. [12]) in the forward and reverse directions of the string. Unfortunately again, this does not directly carry over to the trie case because, as far as we know, longest common extension queries on trees can be computed in constant time only in the direction toward the root of the trie, when space is restricted to linear in the size of the trie. We show that the longest common extension query in the opposite direction can be reduced to what are called path-tree LCE queries [13]. A naive application of this data structure results in an $O(n(\log\log n)^{2})$ time and $O(n)$ space algorithm. In Section 3.3, we will show how to adapt the method of [13] so that a batch of $O(n)$ path-tree LCE queries can be computed in $O(n\log\log n)$ total time.

2.2 Common Suffix Trie

A trie is a rooted tree with labeled edges, such that each edge to the children of a node is labeled with distinct symbols. A trie can be considered as representing a set of strings obtained by concatenating the labels on a root to leaf path. Note that for a trie with $n$ edges, the total length of such strings can be quadratic in $n$. An example can be given by the set of strings $X=\{xc_{1},xc_{2},\cdots xc_{n}\}$ where $x\in\Sigma^{n-1}$ is an arbitrary string and $c_{1},\dots,c_{n}\in\Sigma$ are pairwise distinct characters. Here, the size of the trie is $\Theta(n)$, while the total length of strings is $\Theta(n^{2})$. Also notice that the total number of distinct suffixes of strings in $X$ is also $\Theta(n^{2})$. However if we consider the strings in the reverse direction, i.e., consider edges of the trie to be directed toward the root, the number of distinct suffixes is linear in the size of the tree. Such tries are called common suffix tries [14]. We will use the terms parent/child/ancestor/descendant with the standard meaning based on the undirected trie, e.g., the root is an ancestor of all nodes in the trie. For any node $u$ of the trie, $\mathit{par}(u)$ will denote its parent node. For any integer $l\geq 0$, $\mathit{anc}(l,u)$ denotes the $l$-th ancestor of $u$, i.e. $\mathit{par}^{l}(u)=\mathit{anc}(l,u)$. Note that a trie can be pre-processed in linear time so that for any node $v$ and integer $l$, $\mathit{anc}(l,v)$ can be computed in constant time (e.g. [15]).

For any nodes $u,v$ of the trie where $u$ is an ancestor of $v$, or vice versa, let $u\rightsquigarrow v$ denote the path from $u$ to $v$, and let $\mathit{str}(u,v)$ denote the string obtained by concatenating the labels on $u\rightsquigarrow v$. For technical reasons, we assume that the root node has an auxiliary parent node $\bot$, where the edge is labeled by a distinct character in $\Sigma$ that is not used elsewhere in the trie. We denote by $\mathit{suf}(v)$ the string obtained by concatenating the labels on the path $v\rightsquigarrow\bot$, i.e., $\mathit{suf}(v)=\mathit{str}(v,\bot)$. Such strings will be called a suffix of the trie.

3 Runs in a Trie

3.1 The Number of Runs in a Trie

We first define runs on a trie. Let $v$ be an ancestor of $u$. A path $u\rightsquigarrow v$ is a run on a trie $T$ if $\mathit{str}(u,v)$ is a repetition and is maximal. More precisely, $\mathit{per}(\mathit{str}(u,v))\leq|\mathit{str}(u,v)|/2$, and for any descendant $u^{\prime}$ of $u$ and ancestor $v^{\prime}$ of $v$, $\mathit{per}(\mathit{str}(u,v))\neq\mathit{per}(\mathit{str}(u^{\prime},v^{\prime}))$ if $u^{\prime}\neq u$ or $v^{\prime}\neq v$. Let $\rho_{\mathcal{T}}(n)$ denote the maximum number of runs in a trie with $n$ edges.

Noticing that the parent of any node in the trie is unique, it is easy to see that analogies of Lemmas 1 and 2 hold for tries. Thus, we have the following.

Corollary 3

For any node $v$ except the root or $\bot$, let $\ell\in\{0,1\}$ be such that $\mathit{suf}(v)[k]\prec_{\ell}\mathit{suf}(v)[1]$ for $k=\min\{k^{\prime}\mid\mathit{suf}(v)[k^{\prime}]\neq\mathit{suf}(v)[1],k^{\prime}>1\}$. Then, the longest Lyndon word that is a prefix of $w_{v}$ is $\mathit{suf}(v)[1..1]$ w.r.t. $\prec_{\ell}$ and $\mathit{suf}(v)[1..j]$ w.r.t. $\prec_{\bar{\ell}}$ for some $j\geq k$.

Corollary 4

Let $r=u\rightsquigarrow v$ be a run with period $p$ in the trie and $\ell\in\{0,1\}$ be such that $\mathit{suf}(u)[x+1]\prec_{\ell}\mathit{suf}(u)[x-p+1]$, where $x=|\mathit{str}(u,v)|$. Then, any L-root $\mathit{str}(u^{\prime},v^{\prime})$ of the run with respect to $\prec_{\ell}$ is the longest Lyndon word that is a prefix of $\mathit{suf}(u^{\prime})$.

Since we assumed that the edge labels of the children of a given node in a trie are distinct, a given L-root can only correspond to one distinct run; i.e., the extension of the period in both directions from an L-root is uniquely determined. Therefore, the argument for standard strings carries over to the trie case, and it follows that the number of runs must be less than $2n$. We further observe the following

Theorem 5

$\rho_{\mathcal{T}}(n)<n$.

Proof 1

Suppose $\mathit{str}(u^{\prime},\mathit{par}(u^{\prime}))$ and $\mathit{str}(u^{\prime},v^{\prime})$ are simultaneously L-roots of runs respectively w.r.t. $\prec_{\ell}$ and $\prec_{\bar{\ell}}$, and that they do not start at the beginning of the runs. Let $p=|\mathit{str}(u^{\prime},v^{\prime})|$. If $u^{\prime}$ has only one child, this leads to a contradiction using the same argument as the case for strings; i.e., if $u$ is the child of $u^{\prime}$, then, from the periods of the two runs, $\mathit{str}(u,u^{\prime})=\mathit{suf}(u^{\prime})[1]=\mathit{suf}(u^{\prime})[p]$ contradicting that $\mathit{suf}(u^{\prime})[1..p]=\mathit{str}(u^{\prime},v^{\prime})$ is a Lyndon word and cannot have a non-empty border. Thus, $u^{\prime}$ must have at least two children, $w,w^{\prime}$, where $\mathit{str}(w,u^{\prime})=\mathit{suf}(u^{\prime})[1]$ and $\mathit{str}(w^{\prime},u^{\prime})=\mathit{suf}(u^{\prime})[p]$. Let $k$ be the number of branching nodes in the trie. Then, the number of leaves is at least $k+1$. Since a run cannot start before a leaf node, this means that a longest Lyndon word starting at a leaf cannot be an L-root that does not start at the beginning of the run. Therefore, although there can be at most $k$ nodes such that both longest Lyndon words are such L-roots, there exist at least $k+1$ nodes where both are not. Thus, the theorem holds.

In a similar way to Theorem 3.6 of [2], we can bound the sum of exponents of all runs in a trie.

Corollary 6

The sum of exponents of all runs in a trie with $n$ edges is less than $3n$.

Proof 2

A given run $r$ with exponent $e_{r}$ contains at least $\lfloor e_{r}-1\rfloor\geq 1$ occurrences of its L-roots that do not start at the beginning of the run, each corresponding to a longest Lyndon word starting at that position. From the proof of Theorem 5, the total number of these L-roots is less than $n$. Let $\mathit{Runs}$ denote the set of all runs in the trie. Then, $\sum_{r\in\mathit{Runs}}(e_{r}-2)\leq\sum_{r\in\mathit{Runs}}\lfloor e_{r}-1\rfloor<n$, and the Corollary follows.

Next, we consider lower bounds. Since a string can be considered as a special case of a trie with no branching nodes, lower bounds on strings directly carries over to tries. The best known lower bound for strings is $0.94457564n$ [16]. However, we can improve this bound for tries with the following idea: given a run-rich (binary) string, consider an occurrence of substring bab. If we add a branching edge labeled with a as a child of a, we can create a new run aa. Since this creates at least one new run with a single new edge, we increase the overall ratio of runs. This can be done for occurrences of aba as well (by adding b), and as many times as possible.

Using the run-rich string t184973 available at [17], we can construct a trie $T$ that contains $282327$ runs with $284249$ edges (more precisely, there were $90922$ positions where adding an edge resulted in 1 new run, and $8354$ positions that resulted in 2 new runs). By simply concatenating the string t184973 $k$ times (with a delimiter in between) and constructing the trie $T$ for each copy (and connecting them), we can obtain a trie with $282327k$ runs and $284250k$ edges. For any length $n$ that is not a multiple of $284250$, let $k=\lfloor n/284250\rfloor$. Then, since it is possible to add arbitrary edges to a given trie without reducing the number of runs, there exists a trie with at least $2282327k$ runs with $n<284250(k+1)$ edges. Thus,

[TABLE]

Since $k\rightarrow\infty$ as $n\rightarrow\infty$, we have $\lim_{n\rightarrow\infty}\rho_{\mathcal{T}}(n)/n\geq 2282327/284250\approx 0.993238$.

Theorem 7

$\lim_{n\rightarrow\infty}\rho_{\mathcal{T}}(n)/n\geq 2282327/284250\approx 0.993238$.

Note that our aim here was to demonstrate that tries with $n$ edges can contain more runs than strings of length $n$. A more careful application of the above idea will most certainly lead to better lower bounds.

3.2 Computing Longest Lyndon Words

Next, we consider the problem of computing, for any node $v$ of the trie, the longest Lyndon word that is a prefix of $\mathit{suf}(v)$. We first describe the algorithm for strings, which is based on the following lemma.

Lemma 8

For any string $w$ and position $1\leq i<|w|$, the longest Lyndon word starting at $i$ w.r.t. $\prec$ is $w[i..j-1]$, where $j$ is such that $j=\min\{k>i\mid w[k..|w|]\prec w[i..|w|]\}$.

Proof 3

Let $j=\min\{k>i\mid w[k..|w|]\prec w[i..|w|]\}$. By definition, we have $w[k..|w|]\succ w[i..|w|]$ for any $i<k<j$. For any such $k$, $w[k..|w|]=w[k..j-1]w[j..|w|]\succ w[i..i+(j-1-k)]w[i+(j-k)..j-1]w[j..|w|]=w[i..|w|]$. If the longest common prefix of $w[k..|w|]$ and $w[i..|w|]$ is longer than or equal to $w[k..j-1]$, this implies $w[j..|w|]\succ w[i+(j-k)..j-1]w[j..|w|]\succ w[i..|w|]$, a contradiction. Therefore, the longest common prefix of $w[k..|w|]$ and $w[i..|w|]$ must be shorter than $w[k..j-1]$, implying that $w[i..j-1]\prec w[k..j-1]$. Thus, $w[i..j-1]$ is a Lyndon word. Suppose $w[i..k]$ is a Lyndon word for some $k\geq j$. Then, $w[i..k]\prec w[j..k]$. Since $|w[i..k]|>|w[j..k]|$, $w[i..k]$ cannot be a prefix of $w[j..k]$ which implies $w[i..|w|]\prec w[j..|w|]$, contradicting the definition of $j$. Thus, $w[i..j-1]$ is the longest Lyndon word starting at $i$.

From Lemma 8, 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$. The inverse suffix array $\mathit{ISA}[1..|w|]$ of $w$ is an array of integers such that $\mathit{ISA}[i]=j$ when $w[i..|w|]$ is the lexicographically $j$th smallest suffix of $w$. That is, the $j$ in Lemma 8 can be restated as $j=\min\{k>i\mid\mathit{ISA}[k]<\mathit{ISA}[i]\}$. This can be restated as the problem of finding the next smaller value (NSV) for each position of the $\mathit{ISA}$, for which there exists a simple linear time algorithm (e.g. [18]) as show in Algorithm 1.

The linear running time can be shown with a simple amortized analysis; in the while loop, $\mathit{NSV}[x]$ is only accessed once for any position $x$ since $\mathit{NSV}[i]$ is set to a larger value and thus will subsequently be skipped.

Since, as before, the parent of a node is unique, Lemma 8 carries over to the trie case. We can assign the lexicographic rank $\mathit{ISA}[u]$ of $\mathit{suf}(u)$ to each node $u$ in linear time from the suffix tree of the trie, which is a compacted trie containing all and only suffixes of the trie.

Theorem 9** (suffix tree of a trie [14, 19])**

The suffix tree of a trie on a constant or integer alphabet can be represented and constructed in $O(n)$ time.

The problem now is to compute, for each node $u$, the closest ancestor $v$ of $u$ such that the lexicographic rank of $\mathit{suf}(v)$ is smaller than that of $\mathit{suf}(u)$. Algorithm 1 can be modified to correctly compute the $\mathit{NSV}$ values on the trie; the for loop is modified to enumerate nodes in some order such that the parent of a considered node is already processed, and line 1 can be changed to $x=\mathit{par}(x)$. However, the amortization will not work; the existence of branching paths means there can be more than one child of a given node, and the same position (node) $x$ could be accessed in the while loop for multiple paths, leading to a super-linear running time.

To overcome this problem, we introduce a new, (conceptually) simple linear time algorithm based on nearest marked ancestor queries.

Theorem 10** (decremental nearest marked ancestor [11])**

A given tree can be processed in linear time such that all nodes are initially marked, and the following operations can be done in amortized constant time:

$\mathit{nma}(u)$: return the nearest ancestor node of $u$ that is marked.

• 2.

$\mathit{unmark}(u)$: un-mark the node $u$.

The pseudo-code of our algorithm is shown in Algorithm 2.

Theorem 11

Given a trie of size $n$, the longest Lyndon word that is a prefix of $\mathit{suf}(u)$ for each node $u$ can be computed in total $O(n)$ time and space.

Proof 4

It is easy to see the linear running time of Algorithm 2. The correctness is also easy to see, because the nodes are processed in decreasing order of lexicographic rank, and thus, all and only nodes with larger lexicographic rank are unmarked.

3.3 Computing Runs

To compute all runs in a trie, we extend the algorithm for strings to the trie case. After computing the longest Lyndon word that is a prefix of $\mathit{suf}(u)$ for each node $u$ for the two lexicographic orderings $\prec_{0}$ and $\prec_{1}$, we must next see if they are L-roots of runs by checking how long the periodicity extends. Given a longest Lyndon word $y=\mathit{str}(u,v)$ w.r.t. $\prec_{\ell}$ that starts at $u$, we can compute the longest common extension from nodes $u$ and $v$ towards the root, i.e., the longest common prefix $z$ between $\mathit{suf}(u)$ and $\mathit{suf}(v)$. To avoid outputting duplicate runs, we will process only the left-most (deepest) L-root of each run. This can be done by processing the L-roots from the leaves. Whenever $|z|\geq|y|$, this implies that the longest Lyndon word starting at $v$ is also $y$, so we mark node $v$ as not being the left-most L-root for $\ell$. Using the suffix tree of the trie, this longest common extension query can be computed in constant time after linear time preprocessing, since it amounts to lowest common ancestor queries (e.g. [20]). The central difficulty of our problem is in computing the longest common extension in the opposite direction, i.e. towards the leaves, because the paths can be branching. We cannot solve this problem by simply considering longest common extensions on the common suffix trie for the reverse strings, since, as observed in Section 2, this can lead to a quadratic blow-up in the size of the trie.

LCE queries on tries in the leaf direction, called path-tree queries, were considered by Bille et al. [13]. In a path-tree LCE query, we are given a path $u\rightsquigarrow v$, where $u$ is an ancestor of $v$, and a node $w$ and are asked to return the longest common prefix between $\mathit{str}(u,v)$ and any path from $w$ to a descendant leaf. For technical reasons, we will represent the above path-tree LCE query as $\mathit{LCE_{PT}}(|\mathit{str}(u,v)|,v,w)$, i.e., we represent the path with its length and deeper end $v$. The output of the query is the node $w^{\prime}$ that is a descendant of $w$ such that $\mathit{str}(w,w^{\prime})$ is the longest common prefix.

Bille et al. showed the following result:

Theorem 12** (Theorem 2 of [13])**

For a tree T with n nodes, a data structure of size $O(n)$ can be constructed in $O(n)$ time to answer path–tree LCE queries in $O((\log\log n)^{2})$ time.

In our case, for each (deepest) L-root $\mathit{str}(v,u)$222We write $\mathit{str}(v,u)$ here, since its reverse $\mathit{str}(u,v)$ is not a Lyndon word to be processed, we simply call one path-tree LCE query $\mathit{LCE_{PT}}(|\mathit{str}(u,v)|,v,v)$, as we know this value will be less than $|\mathit{str}(u,v)|$. Since there are $O(n)$ candidate L-roots, the computation can be done in total $O(n(\log\log n)^{2})$ time.

Finally, we show that this can be reduced to $O(n\log\log n)$ total time since all the $O(n)$ queries are known in advance, and Bille et al.’s approach can be modified to process a batch of $O(n)$ queries more efficiently.

Our algorithm closely follows the approach of [13]. For any query $\mathit{LCE_{PT}}(l,v,w)$, their approach iteratively reduces the query to another query $\mathit{LCE_{PT}}(l^{\prime},v^{\prime},w^{\prime})$ with equivalent output, such that $l^{\prime}$ becomes smaller compared to $l$. More precisely, they show:

Lemma 13** (Lemma 4 in [13])**

For a tree T with n nodes and a parameter b, a data structure of size $O(n)$ can be constructed in $O(n)$ time333In the original paper, the statement is $O(n\log n)$ time, but is apparently a typo. time, so that given a path of length $l\leq b$ ending at $u\in T$ and a subtree rooted at $v\in T$ we can reduce the query in $O(\log\log n)$ time so that the path is of length at most $b^{\frac{4}{5}}$.

A weaker version of Theorem 12 where the size and construction time is $O(n\log\log n)$ can be obtained by building and applying the data structure of Lemma 13 $O(\log\log n)$ times for $b=n,n^{4/5},n^{(4/5)^{2}},\dots,1$. In our case, we process a batch of $O(n)$ queries for each value of $b$ so the total space usage can be suppressed to $O(n)$. To achieve $O(n\log\log n)$ total running time, we shall prove the following Lemma. Note that the main difference is essentially in that while the original approach answered predecessor/successor queries for each tree-path query using predecessor/successor data structures (thus requiring an extra factor of $\log\log n$), we are able to answer them by sorting the data and all of the tree-path queries at once using radix sort.

Lemma 14

For a tree T with n nodes, and parameter b, a set

[TABLE]

of $k=O(n)$ path-tree LCE queries with $l_{i}\leq b~{}(i=1,\dots k)$ can be reduced to a set

[TABLE]

of queries such that $\mathit{LCE_{PT}}(l_{i},v_{i},w_{i})=\mathit{LCE_{PT}}(l^{\prime}_{i},v^{\prime}_{i},w^{\prime}_{i})$ and $l^{\prime}_{i}\leq b^{4/5}$ for $i=1,\dots,k$ in $O(n)$ time.

The queries are processed as follows: The first step is to determine whether the length of the LCE is less than $b^{4/5}$ or not for all $i=1,\dots,k$. To do this, we assign new names (i.e., integers of size $O(n)$) to all distinct paths of length $b^{4/5}$ in the trie. This can be done in $O(n)$ time using Theorem 9. Let

[TABLE]

where $c_{t}$ is the name assigned to the length $b^{4/5}$ path from $s_{t}$ to $t$. For path-tree query $\mathit{LCE_{PT}}(l_{i},v_{i},w_{i})$, let $e_{i}=\mathit{anc}(l_{i}-b^{4/5},v_{i})$, that is, $c_{e_{i}}$ is the name assigned to the length $b^{4/5}$ prefix of the query path. Then, it is not difficult to see that the length of the LCE is at least $b^{4/5}$ if and only if $(w_{i},c_{e_{i}},t_{i})\in S_{1}$ for some $t_{i}$, and in such case, we have $\mathit{str}(\mathit{anc}(l_{i},v_{i}),e_{i})=\mathit{str}(w_{i},t_{i})$. We can determine such $t$, if it exists, in $O(n)$ total time for all $i=1,\dots,k$ as follows. Let

[TABLE]

and sort the set $S_{1}\cup S_{2}$ (assuming $\bot$ is larger than any node) in $O(n)$ time by radix sort. Then, if it exists, $(w_{i},c_{e_{i}},t_{i})$ must be the largest element in $S_{1}$ that precedes element $(w_{i},c_{e_{i}},\bot)\in S_{2}$. This can also be computed for all $i$ in $O(n)$ total time by simple scans on the sorted set.

For queries $\mathit{LCE_{PT}}(l_{i},v_{i},w_{i})$ such that the length of the LCE is less than $b^{4/5}$, we can simply choose $l^{\prime}_{i}=b^{4/5}$, $v^{\prime}_{i}=\mathit{anc}(l_{i}-b^{4/5},v_{i})$, and $w^{\prime}_{i}=w_{i}$. Otherwise, let $l^{\prime\prime}_{i}=l_{i}-b^{4/5}$, $v^{\prime\prime}_{i}=v_{i}$, and $w^{\prime\prime}_{i}=t_{i}$. It is clear we have $\mathit{LCE_{PT}}(l_{i},v_{i},w_{i})=\mathit{LCE_{PT}}(l^{\prime\prime}_{i},v^{\prime\prime}_{i},w^{\prime\prime}_{i})$. If $l^{\prime\prime}_{i}<b^{4/5}$, then we can simply use $l^{\prime}_{i}=l^{\prime\prime}_{i}$, $v^{\prime}_{i}=v^{\prime\prime}_{i}$, and $w^{\prime}_{i}=w^{\prime\prime}_{i}$. If $l^{\prime\prime}_{i}\geq b^{4/5}$, we further reduce the query using difference covers for trees, similarly to what was done in Lemma 13, described below.

Lemma 15** (Lemma 1 and Remark of [13])**

For any tree $T$ with $n$ nodes and a parameter $x$, it is possible to mark $2n/x$ nodes of T, so that for any two nodes $u,v\in T$ at (possibly different) depths at least $x$, there exists $d\leq x$ such that the $d$-th ancestors of both $u$ and $v$ are marked. Furthermore, such $d$ can be calculated in $O(1)$ time and the set of marked nodes can be determined in $O(n)$ time. Also, if a node is marked, so are all its descendants at distance $x^{2}$, and if the depth of the node is at least $x^{2}$, so is its $x^{2}$-th ancestor at distance.

We use Lemma 15 for $x=b^{2/5}$, and further modify the queries so that we can start the LCE at marked nodes: i.e., for all $i$ such that $l^{\prime\prime}_{i}\geq b^{4/5}$, $v^{\prime\prime\prime}_{i}=v^{\prime\prime}_{i}$, $l^{\prime\prime\prime}_{i}=l^{\prime\prime}_{i}+d_{i}$, $w^{\prime\prime\prime}_{i}=\mathit{anc}(d_{i},w^{\prime\prime}_{i})$, where $d_{i}$ can be obtained in $O(1)$ time for each query. Consider all paths (called canonical paths) whose length is a multiple of $x^{2}$ and end (and consequently start) at a marked node. Since any path has length at most length $n$, there can be up to $\sqrt{x}$ canonical paths that end at a given node. Since there are $2n/x$ marked nodes, there are at most $2n/\sqrt{x}$ canonical paths. As was done for $b^{4/5}$ length paths, we rename all length $x^{2}$ paths using a suffix tree in $O(n)$ time. Then, if we consider canonical paths as sequences of these names, the total length for all canonical paths is $O(n)$ since each of them has length at most $\sqrt{x}$. Thus, we can sort all (renamed) canonical paths in $O(n)$ time (e.g. Lemma 8.7 of [21]). We can also compute in $O(n)$ total time, the longest common prefix between lexicographically adjacent (renamed) canonical paths, and a range minimum query data structure so that the longest common prefix between any two (renamed) canonical paths can be computed in constant time. Let

[TABLE]

where $c_{t,j}$ is the lexicographic rank of the canonical path $s_{t,j}\rightsquigarrow t$. For any query $\mathit{LCE_{PT}}(l^{\prime\prime\prime}_{i},v^{\prime\prime\prime}_{i},w^{\prime\prime\prime}_{i})$ that is left, let $c^{\prime\prime\prime}_{i}$ be the lexicographic rank of the longest (renamed) canonical path $\mathit{anc}(l^{\prime\prime\prime}_{i},v^{\prime\prime\prime}_{i})\rightsquigarrow q_{i}$ that is a prefix of $\mathit{anc}(l^{\prime\prime\prime}_{i},v^{\prime\prime\prime}_{i})\rightsquigarrow v^{\prime\prime\prime}_{i}$. Let

[TABLE]

We can sort $S_{3}\cup S_{4}$ in $O(n)$ time using radix sort. Then, for each element $(w^{\prime\prime\prime}_{i},c^{\prime\prime\prime}_{i},\bot)\in S_{4}$, either its predecessor or successor $(s_{t,j},c_{t,j},t)\in S_{3}$ (which can be computed in $O(n)$ total time for all of them by simple scans on the sorted set), will have the longest common prefix, provided that $s_{t,j}=w^{\prime\prime\prime}_{i}$. This can be computed in constant time each using range minimum queries. Since we have computed the longest common extension where each character (name) represents a length $x^{2}$ substring, the remaining length of the LCE is at most $x^{2}=b^{4/5}$.

From the above arguments, we have proved Lemma 14 and obtain the following.

Theorem 16

For a tree T with n nodes, a batch of $O(n)$ tree-path LCE queries can be computed in $O(n\log\log n)$ total time.

4 Conclusion

We generalized the notion of runs in strings to runs in tries, and showed that the analysis of the maximum number of runs, as well as algorithms for computing runs can be extended and adapted to the trie case, but with a slight increase in running time.

Our algorithm can output all primitively rooted squares in $O(n\log n)$ time, which is tight, since there can be $\Theta(n\log n)$ primitively rooted squares in a string, e.g., Fibonacci words [22], and thus in a trie.

An obvious open problem is whether there exists a linear time algorithm for computing all runs in a trie. For strings, there exists another linear time algorithm for computing all runs that is based on the Lempel-Ziv parsing [1]. It is not clear how this algorithm could be extended to the case of tries. The case for general ordered alphabets, instead of integer alphabets, is another open problem which was recently resolved for strings by Ellert and Fischer [3].

Acknowledgements

We thank Tomohiro I for pointing out the paper of [13], which enabled us to reduce the time complexity of our initial solutions.

This work was supported by JSPS KAKENHI Grant Numbers JP18K18002 (YN), JP17H01697 (SI), JP20H04141 (HB), JP18H04098 (MT), JST ACT-X Grant Number JPMJAX200K (YN), and JST PRESTO Grant Number JPMJPR1922 (SI).