Competitive Online Search Trees on Trees

TL;DR

This paper introduces an online search tree data structure for tree-structured spaces that achieves an optimal competitive ratio similar to binary search trees, using novel decomposition techniques.

Contribution

It generalizes binary search trees to tree-structured spaces and presents an $O(\log \log n)$-competitive online search tree with new notions like Steiner-closed search trees.

Findings

Achieves $O(\log \log n)$-competitiveness in the new model.

Introduces Steiner-closed search trees for better decomposition.

Uses a two-level decomposition approach for analysis.

Abstract

We consider the design of adaptive data structures for searching elements of a tree-structured space. We use a natural generalization of the rotation-based online binary search tree model in which the underlying search space is the set of vertices of a tree. This model is based on a simple structure for decomposing graphs, previously known under several names including elimination trees, vertex rankings, and tubings. The model is equivalent to the classical binary search tree model exactly when the underlying tree is a path. We describe an online $O(\log \log n)$-competitive search tree data structure in this model, matching the best known competitive ratio of binary search trees. Our method is inspired by Tango trees, an online binary search tree algorithm, but critically needs several new notions including one which we call Steiner-closed search trees, which may be of independent interest. Moreover our technique is based on a novel use of two levels of decomposition, first from search space to a set of Steiner-closed trees, and secondly from these trees into paths.

Equations

$$O\left(\mathrm{OPT}(G,X)\cdot (1+\log \log n)\right).\text{qed}$$

Full text

1 Introduction

1.1 Problem and Motivation

Efficient retrieval of data from a structured, finite, universe is a fundamental computational question in computer science. A classical data structure designed to search elements of a linearly ordered set is the binary search tree, in which every node contains an element $x$ of the set, and its two subtrees are binary search trees for the elements that are respectively larger or smaller than $x$. Due to their fundamental flavor and practical importance, binary search trees are the subject of a considerable scientific literature spanning nearly eight decades of research, as well as being a basic component of software libraries.

Searching Vertices of a Tree.

We consider the problem of searching for an element that is not part of a linearly ordered set, but rather a vertex of a tree $G$. For this purpose, we generalize binary search trees to search trees on trees. In such a search tree, the root node contains a vertex $x$ of $G$, and its subtrees are search trees on each of the connected components of the forest $G\setminus x$ (see Figure 1 for an illustration). Note that the roots of the subtrees need not be adjacent to $x$ in $G$, hence this search tree forms a rooted tree on the same vertex set as $G$, with a possibly distinct edge set. We will refer to such a tree as a search tree on the tree $G$. This tree can be searched by iteratively performing node queries, starting from the root: at each node $x$, an oracle tells us that either $x$ is the vertex we look for, or in which of the remaining connected components we need to pursue the search.

Note that in the special case where the underlying tree $G$ is a path, a search tree on $G$ is simply a binary search tree on the vertices of $G$ ordered with respect to their location in the path. Search trees on trees are also special cases of trees on graphs, also known as vertex rankings and they have been studied in various areas of discrete mathematics and computer science, e.g., polyhedral combinatorics, combinatorial optimization, graph theory (we discuss some of the related work in Section 1.3).

Adaptive Binary Search Trees — BST Model of Computation.

Binary search trees (BSTs) can be viewed as a model of computation where in each operation there is a pointer that starts at the root and can be moved to adjacent nodes at unit cost; additionally a local change known as a rotation can be performed at unit cost. A sequence of search operations $X=x_{1},\dotsc,x_{m}$ to nodes of the BST is requested and the goal is to perform all searches at minimum cost. This model was formalized in [Wil89, DHIP07] and classic binary search trees such as Red-Black trees [GS78] and AVL trees [AVL62] fit in this model. In the offline version of this model, the sequence $X$ is known in advance and the rotations performed might be based on the knowledge of next requests. On the other hand, in the online version, each request $x_{i}$ is revealed after the previous search $x_{i-1}$ has been performed.

In [ST85], Sleator and Tarjan conjectured that there exists a single online BST-model algorithm whose runtime over every sufficiently long sequence of searches is within a constant factor of the optimal offline BST-model algorithm on that sequence. This notion of optimality, called dynamic optimality is much stronger than other typical types of optimality, including those that are stated in terms of a distribution of operations.

Sleator and Tarjan [ST85] introduced the Splay Tree, a self-adjusting BST-model algorithm that uses a small set of restructuring heuristics to move the searched node item to the root. They conjectured that the splay tree was dynamically optimal in the BST model, a conjecture that remains open. While constant-factor competitiveness remains elusive in the BST model, a breakthrough in the theory of binary search trees was achieved by Demaine, Harmon, Iacono, and Pǎtraşcu [DHIP07], who introduced the tango trees, which were proved to be $O(\log\log n)$-competitive. (See 1.3.4 for a discussion of the history of binary search trees in the context of our result).

Adaptive Search Trees on Trees.

Interestingly, while numerous questions on the optimal design of search trees on trees have been addressed (see Section 1.3), adaptivity by changing the search tree on tree has never been considered. This can be achieved, just in the same way as in binary search trees, via an elementary rotation operation. These rotations generalize rotations on binary search trees, as illustrated in Figure 2(b).

In this paper, we introduce a natural generalization of the BST computation model involving unit-cost finger moves and rotations, which we call the general search tree model (GST), and consider the design of competitive online search trees on trees in this model. It is tempting to consider known adaptive binary search tree techniques and try to generalize them to search trees on trees. On the other hand, search trees on trees are much more subtle and many nice properties of BSTs do not generalize. As a result several “natural” attempts to generalize the techniques developed for BSTs, seem to fail, as we discuss in detail in Section 1.4. Thus we need several new ideas and techniques in order to design competitive online adaptive search trees.

1.2 Our Results

In this work we define a model of computation for search trees on trees, the general search tree model (GST). This model generalizes the BST model, which corresponds to the special case where the underlying tree is a path. We obtain both lower and upper bounds for this model, matching the ones known for the BST model.

Lower Bound.

We obtain a lower bound on the cost of any algorithm in the GST model, by generalizing the interleave lower bound of binary search trees [Wil89, DHIP07] to search trees on trees.

Upper Bound.

Our main result is an online algorithm for executing search sequences in search trees on trees that is $O(\log\log n)$-competitive, that is, whose running time in the GST model is at most a factor $O(\log\log n)$ away from that of any other algorithm, even knowing all search requests in advance. This matches the best competitive factor known so far for binary search trees.

The basic idea is to connect the cost of the algorithm to the interleave lower bound and show that each time this lower bound increases by 1, the algorithm incurs a cost at most $O(\log\log n)$. This is based on the paradigm developed by Demaine, Harmon, Iacono and Pǎtraşcu for Tango trees [DHI*+*09] to achieve competitive ratio $O(\log\log n)$ for binary search trees. However substantially more involved ideas and techniques are needed to obtain the generalization. First, we develop a notion of Steiner-closed search trees that seems to be independently useful. Moreover the results on BSTs rely crucially on the fact that a subset of $k$ vertices (defining a preferred path, see Section 4) can be stored easily in a BST data structure (like red-black trees) that supports split and merge in $O(\log k)$ time. On the other hand, in search trees there is no straightforward analogue. We need a subtle two-level decomposition involving link-cut trees [ST83, Tar83] and show that the resulting data structure is a valid search tree on tree.

Organization.

In the next subsection, we detail a number of related works. In Section 1.4 we provide a comparison between binary search trees and search trees on trees, mentioning the main properties that do not generalize and showing that search trees on trees have a much more rich and subtle structure. In Section 2, we give the basic definitions related to search trees and introduce the precise computation model involved. In Section 3, we show how to generalize the interleave lower bound of binary search trees to search trees on trees. The description of our $O(\log\log n)$-competitive algorithm is given in Section 4.

1.3 Related Work

1.3.1  Search trees, vertex rankings, and related notions

The structure we refer to as search trees on trees, and more generally search trees on graphs, has been studied for decades under many different names. They are known as elimination trees [Pot88, AH94, BGHK95], vertex rankings [Sch89, DKKM99, BDJ*+*98], and tubings [CD06, MP15], among others.

The minimum height of a search tree on a graph $G$ is known in the graph theory community as the tree-depth of $G$. We refer to the text of Nešetřil and Ossona de Mendez [NOdM12] for details on the equivalence between the various definitions of tree-depth as well as its connections with other structural parameters of graphs.

Many previous works have been dedicated to constructing minimum-height, and therefore worst-case optimal search trees [Pot88, AH94, DKKM99]. Most relevant to our result, it was shown by Schäffer that a minimum-height search tree on a tree, hence the tree-depth of a tree, can be found in linear time [Sch89].

1.3.2  Other search tree models

More recently, different models were proposed for searching for elements in tree and graph-structured universes. Our definition of search trees is based on vertex queries: every node of the search tree is associated with a vertex of the searched graph. In contrast, edge queries have also been studied [BFN99, OP06, MOW08, CKL*+*16, CJLM11, CJLM14], in which every node of the search tree is associated with an edge of the graph, and the oracle points to one of the two connected components containing the sought vertex. This is sometimes cast as searching in a partial order. A dynamic variant, supporting insertion and deletion of elements, has been proposed by Heeringa et al. [HIT11]. Another model that was recently proposed for searching a graph involves an oracle that given a vertex, returns the first edge incident to this vertex on a shortest path to the sought vertex [EKS16].

1.3.3  Polyhedral combinatorics

The associahedra are polytopes whose vertices are in bijection with binary search trees on $n$ elements, and edges correspond to pairs of binary search trees that differ by one single rotation [Tam51, Sta63, Lee89, CSZ15]. From a classical Catalan bijection, their skeletons are also flip graphs of triangulations of a convex polygon on $n+2$ vertices. Graph associahedra were studied independently by Carr and Devadoss [CD06], and Postnikov [Pos09]. Just like in associahedra, the vertices of a graph associahedron defined from a graph $G$ are in bijection with the search trees on $G$, and its skeleton is the rotation graph of the search trees on $G$, that is, two vertices are connected by an edge of the polytope if and only if the search trees differ by a single rotation. The search trees and the rotations are essentially what is referred to by Carr and Devadoss [CD06] as tubings and flips, respectively. In Postnikov [Pos09], and Postnikov, Reiner, Williams [PRW08], the search trees are called $\mathcal{B}$-trees.

Sleator and Tarjan raised the question of the diameter of the associahedron: the largest rotation distance between any two binary search trees on $n$ elements. Together with Thurston, they proved that it was $2n-6$ for sufficiently large values of $n$ [STT86]. A few years ago, Pournin gave a combinatorial proof of this result and established it for every value of $n$ [Pou14]. A similar diameter question was studied for graph associahedra by Manneville and Pilaud [MP15]. They asked the question of the worst-case diameter of tree associahedra, hence the maximum rotation distance between two search trees on a tree. Cardinal, Langerman, and Perez-Lantero proved that the correct bound was $\Theta(n\log n)$ [CLP18]. This body of work provides us with the same theoretical background on search trees on graphs and trees as the combinatorics of associahedra does on binary search trees.

1.3.4  Dynamic optimality of binary search trees

Our work most prominently relies on insights and progress on the so-called dynamic optimality conjecture for binary search trees which posits the existence of $O(1)$-competitive online binary search trees. Here we consider the total number of elementary operations, finger moves and rotations, required to search a given sequence of nodes in the tree, and wish this number to lie within a constant factor of that of any other algorithm, even when the latter has access to the sequence of queries in advance. We refer to Iacono for a survey on this question [Iac13].

It is famously conjectured that splay trees have the dynamic optimality property. This remains unproven, although a number of weaker runtime bounds, such as the static optimality property [ST85] (splay trees are as good as the best static BST), the working set property [ST85] (searching an item is fast if it has been searched recently), and the dynamic finger property [CMSS00, Col00] (searching an item is fast if it is close in key-space to the previous search), are known to hold. The crucial Access Lemma of splay trees and the conditions under which it holds have been extensively analyzed [Sub96, GM04, CGK*+*15b].

More recently, the geometric view on binary search trees was introduced by Demaine, Harmon, Iacono, Kane, and Pǎtraşcu [DHI*+*09]. In this view, optimality of binary search trees is cast as a geometric problem on point sets in the plane. It also introduces the online greedy binary search trees, an online version of the greedy algorithm introduced independently by Lucas [Luc88] and Munro [Mun00], conjectured to be dynamically optimal as well. Recently, greedy has been proven to satisfy the dynamic finger property [IL16], a generalization of static optimality and dynamic finger which is related to the idea of lazy search introduced in [BDIL16], as well as certain so-called pattern avoiding search sequences [CGK*+*15a].

Although both splay trees and the greedy algorithm are conjectured to be $O(1)$-competitive, the best known upper bound on their competitive ratio is $O(\log n)$. The best competitive ratio known is $O(\log\log n)$, first achieved by Demaine et. al. [DHIP07] using tango trees. Tango trees are designed to approximately match the so-called interleave lower bound, a variant of a lower bound from Wilber [Wil89]. Based on this idea several other $O(\log\log n)$-competitive BST algorithms were later developed [WDS06, Geo08], shown to satisfy several additional properties like the working set bound. It is this structure that we are able to generalize to search trees on trees.

1.4 From Binary to General Search Trees

It is tempting to think that generalizing the results from the binary search tree model to trees on trees is straightforward. It is not. In this section we give several examples of standard and well-known properties of BSTs that do not carry over to search trees on trees and a brief overview of our approach to circumvent the obstacles in the generalization. In fact, given those major differences, it came as a surprise to us that an algorithmic result matching the best known for BSTs can be achieved.

Optimal Static Trees.

Given a probability distribution of the searches constructing a static BST that minimizes the cost of an expected search is a well-studied and frequency taught problem, occupying a section in the ubiquitous CLRS text [CLRS09]. A quadratic-time algorithm due to Knuth [Knu71] is a classic application of dynamic programming and a linear-time algorithm proposed in [Fre75] and fully analyzed in [Meh77] comes within an additive constant of optimal. However, for trees-on-trees we have no polynomial algorithm or approximation, and attempts to generalize algorithms for trees fail; for example picking as the root the centroid in the distribution and recursing (as in [Meh75]) does not always approximate the optimal tree within a constant factor; dynamic programming also does not have an obvious polynomial-time solution as the number of connected subtrees of a tree is exponential (as opposed to the quadratic number of connected subpaths of a path).

Furthermore, in BST information theory [Sha48] applies and it is well-known that the entropy of the distribution is a lower bound on the search cost due. This is not the case for search trees on trees; this is easily seen in, for example a $(n-1)$-star with equal probabilities, by choosing the center of the star as the root every search can be completed in two steps, while entropy gives the higher $\log_{2}n$. Informally, this is because in binary search trees one comparison gives one bit of information, but in the GST model a comparison gives an amount of information that varies with the degree of the node.

Geometric View.

The geometric view also constitutes a major contribution to the theory of binary search trees [DHI*+*09]. In this setting, searches to nodes of a binary search trees are pictured as points in the plane, with one dimension being key value and the other time, and any execution of a binary search tree algorithm on this query sequence is pictured as a superset of these points, that satisfy the a geometric condition known as arboral setisfaction. The proof of equivalence between this point set and a binary search tree algorithm relies crucially on the fact that any binary search tree is at rotation distance at most linear from any other [STT86]. This is not true for search trees on trees: there exist pairs of search trees on a tree $G$ of $n$ vertices that are at rotation distance $\Omega(n\log n)$ [CLP18]. It is because of this that extending the geometric view to the trees-on-trees setting fails, even when one dimension is viewed as being tree-shaped.

Splay Trees and Greedy.

One might also ask whether there is a natural generalization of the splay tree algorithm to search trees on trees. Even taking into account the most relaxed conditions for the access lemma to hold [Sub96, CGK*+*15b], the question remains unclear due to entropy not being a lower bound. Additionally, a natural adaption of the reconfiguration heuristic of splay trees to the trees-on-trees setting results in a structure that can be as bad as possible, even on a star graph. It is also unclear how we can generalize greedy binary search trees — another candidate for dynamic optimality [Iac13] — to the tree setting as the online variant depends on the transformations inherent in the geometric view.

Our Approach.

It is in this context of the failure of so much of the machinery that has been developed over the past fifty years of BST research to carry over to the GST model that we surprisingly are able to develop a $O(\log\log n)$-competitive algorithm in the GST model. Our result is inspired by the BST-model Tango trees, but as the reader shall discover we need a number of new observations, such as the notion of Steiner-closed, which are specific to the GST model. Crucial to obtaining our result is observing that while entropy-based lower bounds fail in the GST model, we are able to adapt one of the lower bounds due to Wilber [Wil89] to the GST model. This lower bound is then matched by a factor $O(\log\log n)$ to our data structure using a two-level decomposition. We first decompose a balanced search tree into preferred paths which are represented by search trees. By resorting to Sleator and Tarjan’s link-cut trees [ST83] for handling the changes in preferred paths, we end up with a two-level decomposition into paths, which is eventually managed by splay trees.

2 Computation model

We proceed by defining our rotation-based search tree model.

Definition 1** (Search tree on a tree).**

A rooted tree $T$ is a valid search tree on a given unrooted tree $G=(V,E)$ if the root $r$ of $T$ stores a vertex of $G$ and the rooted subtrees of $T\setminus r$ are valid search trees on the connected components of $G\setminus r$.

Note that in the above definition the trees $T$ and $G$ do not have degree restrictions. While $T$ is rooted, there is no order among the children of a node. Observe that in case the tree $G$ is a path, then a search tree $T$ of $G$ is a binary search tree (BST) with respect to the total order implied by the path. Thus, search trees on trees are a natural generalization of binary search trees. Throughout the rest of the paper we assume a fixed tree $G$ unless otherwise indicated and $n$ denotes the number of vertices in $G$.

Definition 2** (Rotation).**

A rotation on a non-root node $v$ of $T$ is a local change which yields another search tree constructed as follows: Let $p$ be the parent of $v$ in $T$. Swap $p$ and $v$ in $T$. All children of $p$ remain children of $p$. For a child $u$ of $v$, let $S_{u}$ be the set of nodes in its subtree. For at most one child $u$ of $v$, there might be a node of $S_{u}$ adjacent to $p$ in $G$; then $u$ becomes a child of $p$; all other children of $v$ remain children of $v$.

We refer to Figures 2(b) and 3 for a visual explanation. The following is a direct observation.

Observation 1**.**

If $T$ is a valid search tree on $G$, and $v$ is a nonroot node of $T$, then the tree obtained after a rotation on $v$ is a valid search tree on $G$

Definition 3** (GST model of computation).**

In the GST model of computation, we are given a tree $G$ and we maintain a tree $T$ which is valid search tree on $G$. At each time, there is a single node pointer at $T$. At unit cost we can perform the following operations:

Move the pointer to a child or the parent of the current node. 2. 2.

Rotate the current node $v$.

A search operation for $v\in V$ is any sequence of unit-cost operations where the pointer starts at the root $r$ of $T$ and points to $v$ at some point during the execution of the operation.

Using this definition, it is easy to see that the GST model is a generalization of the binary search tree (BST) model of computation.

Observation 2** (Relation with BST model).**

If the tree $G$ is a path, any valid search tree $T$ on $G$ is a binary search tree, search tree rotations correspond to BST rotations, and the GST model of computation is equivalent to the BST model of computation as formulated in [DHIP07].

A sequence $X=x_{1},x_{2},\ldots x_{m}$ is a valid search sequence in a tree $G=(V,E)$ if all $x_{i}\in V$. The main goal of this work is to examine the complexity of executing a search sequence in the GST model.

Definition 4** (Optimal).**

Let $OPT(G,X)$ be the optimal cost of any GST-model algorithm to execute the sequence of searches $X$ starting from any initial search tree $T$ on $G$.

Note that while we formally care about rotations and pointer moves only, we are mostly interested in practical algorithms, for which the overall cost, including additional bookkeeping operations, is kept within a reasonable factor of the GST cost.

The notion of preferred child of a node in a search tree will be crucial for both the lower and the upper bound.

Definition 5** (Preferred Child).**

Let $P$ be a valid search tree on $G$. Let $y$ be a non-leaf node of $P$, with children $y_{1},\dotsc,y_{d}$. At each time $t\in[1,m]$, we define the preferred child of $y$ to be the child $y_{i}$ whose subtree $P(y_{i})$ contains the most recent searched vertex in $x_{1},\ldots x_{t}$ that is in a node of $P(y)$ (or is undefined if none of these searches are in $P(y)$). In case last request in $P(y)$ is to $y$, we set preferred child of $y$ to be $y_{1}$.

Note that the preferred child of a node changes throughout the execution of sequence $X$. Understanding and characterizing those changes is an essential part of both the lower bound and the construction of our data structure.

3 Lower bound

In this section we give a lower bound on the optimal cost of executing a sequence of searches in vertices of a tree $G$ in the search tree model (GST), by generalizing the interleave lower bound of [DHIP07] for binary search trees.

In the following definitions assume a fixed tree $G=(V,E)$ on $n$ vertices and let $X=x_{1},x_{2},\ldots x_{m}$ be a request sequence of searches drawn from $V$. We begin by defining the interleave bound.

Definition 6** (Interleave Bound).**

Let $P$ be a valid search tree on $G$. The interleave bound of a node $y$ of $P$ is the number of times the preferred child of $y$ changes over time $1,2,\ldots m$. The interleave bound $I(G,P,X)$ is the sum of the interleave bounds of the nodes.

Note that in the definition above, $P$ is a fixed search tree and does not change throughout the execution of $X$. We show that the interleave bound value of any fixed tree $P$ can be used to obtain a lower bound on $\operatorname{OPT}(G,X)$, the optimal cost to execute $X$ in the GST model.

Theorem 3.1** (Interleave Lower Bound in the GST model).**

Let $P$ be a valid search tree on $G$. For any search sequence $X$ in the GST model of computation, we have that $OPT(G,X)\geq I(G,P,X)/2-n$.

Proof.

Let $\operatorname{ALG}$ be any GST-model algorithm. At a high-level, the proof consists of two main steps:

1. (i)

We show that if for a fixed node $y$ in $P$ the interleave bound value is $q$, then there are at least $q/2-1$ unit-cost operations performed by $\operatorname{ALG}$. We charge those operations to node $y$. 2. (ii)

We show that for two different nodes $y\neq z$ of $P$, the unit-cost operations charged to $y$ and $z$ are disjoint.

It is easy to see that those two steps imply the theorem; by summing overall nodes $y$ of $P$, we get that $\operatorname{ALG}$ has cost at least $I(G,P,X)/2-n$.

Notation and Definitions

Before proving parts (i) and (ii) we introduce some definitions and notation. Let $T_{t}$ be the tree maintained by $\operatorname{ALG}$ after the $t$th search for $t=1,\dotsc,m$.

In all following definitions, we fix $y$ to be a node of $P$ of degree $d$ with children $y_{1},\dotsc,y_{d}$ (ordered arbitrarily but consistently throughout the whole execution). Let $P(y)$ denote the subtree of $P$ rooted at $y$. For $i=1,\dotsc,d$, let $\ell_{i}$ be the node of subtree $P(y_{i})$ with the smallest depth in tree $T_{t}$ (assuming that $y\in P(y_{1})$), for any $1\leq t\leq m$.

Definition 7** (Dominating node and dominating subtree).**

Let $\ell_{i_{t}}$ be the node with smallest depth in $T_{t}$ among $\ell_{1},\dotsc,\ell_{d}$, for some $1\leq i_{t}\leq d$. Then, $\ell_{i_{t}}$ is the lowest common ancestor in $T_{t}$ of all nodes stored in $P(y)$. We call $\ell_{i_{t}}$ the dominating node of $P(y)$ in $T_{t}$ and $P(y_{i_{t}})$ the dominating subtree of $P(y)$.

Note that as the tree $T_{t}$ evolves over time, the dominating subtree of $y$ might change. We couple this definition with the definition of transition points.

Definition 8** (Transition point).**

Let $\ell_{i_{t}}$ be the dominating node of $P(y)$ in $T_{t}$. For each $i\neq i_{t}$, we call $\ell_{i}$ to be the transition point of $y$ for $P(y_{i})$ at time $t$.

Note that at each given time $t$ we have exactly $d-1$ transition points of $y$, one corresponding to each $P(y_{i})$, for $i\neq i_{t}$. In the proof of step (i), we will charge $y$ only for touches of $\operatorname{ALG}$ to its transition points.

Properties of transition points.

We now state some basic observations following from the definition of transition points which will be crucial in our proof.

Observation 3**.**

A transition point of a node $y\in P$ can not be the root of $T_{t}$, since $\ell_{i_{t}}$ is its ancestor. Thus whenever $\operatorname{ALG}$ has to touch a transition point of $y$, it incurs a cost of at least 1.

Observation 4**.**

Let $\ell_{i_{t}}$ be the dominating node of $P(y)$ in $T_{t}$. If the request $x_{t+1}$ is to a node of subtree $P(y_{i})$ for some $i\neq i_{t}$, then the transition point $\ell_{i}$ has to be touched by $\operatorname{ALG}$.

Proof of Step (i).

Assume that the interleave bound for $y$ equals $q$. Consider the subsequence of requests $x_{j_{1}},\dotsc,x_{j_{q}}$ where the preferred child of $y$ changes. Clearly, any two consecutive requests $x_{j_{k}},x_{j_{k+1}}$ are from different subtrees $P(y_{k}),P(y_{k+1})$.

Requests in non-dominating subtrees: Each time a node from a non-dominating subtree $P(y_{i})$ is requested, the transition node $\ell_{i}$ has to be touched (by Observation 4). Thus at least one unit-cost operation has to be performed (by Observation 3). We charge this operation to $y$.

Requests in dominating subtrees: Let $x_{j_{k}},x_{j_{k+1}}$ be two consecutive requests such that in both requests a node from the dominating subtree is requested. Since the subtrees $P(y_{k})$ and $P(y_{k+1})$ are different, that means the dominating subtree changed at least once during $(j_{k},j_{k+1})$; $P(y_{k+1})$ was not a dominating subtree at time $j_{k}$, but it is at time $j_{k+1}$, thus at some time point during $(j_{k},j_{k+1})$ there should have been a rotation between the lowest common ancestor of points of $P(y_{k+1})$ (which was a transition point of $y$) and the dominating point of $P(y)$. We get that the transition point of $y$ for $P(y_{k+1})$ is touched at least once during $(j_{k},j_{k+1})$ and we charge one to this touch.

Counting the cost: Let $q_{1}$ (resp. $q_{2}$) be the number of requests to non-dominating (resp. dominating) subtrees of $P(y)$. Note that $q_{1}+q_{2}=q$. To get an overall bound on the number of unit-cost operations charged to $y$, we perform a simple case analysis on values of $q_{1},q_{2}$.

In case $q_{2}\leq\lceil q/2\rceil$, we count only the unit-cost operations charged for requests on non-dominating subtrees. There are $q_{1}$ of them. We have that $q_{1}=q-q_{2}\geq q/2-1$.

On the other hand, in case $q_{2}>\lceil q/2\rceil$, we count all requests charged. There are $q_{1}$ requests to non-dominating subtrees. Among the requests to dominating subtrees, the ones that are preceded by a request to a non-dominating subtree (there are $q_{1}$ of them) are not charged. All the others (there are $q_{2}-q_{1}$ of them) are charged. We get that the total charge to $y$ is at least $q_{1}+(q_{2}-q_{1})=q_{2}\geq q/2-1$.

Overall we charged at least $q/2-1$ requests.

Proof of Step (ii).

We prove the following lemma.

Lemma 3.2**.**

At any given time $t$, each node $v$ of $T_{t}$ can be a transition node of at most one node $y$ of $P$.

Proof.

Take two nodes $y$ and $z$ of $P$. If trees $P(y)$ and $P(z)$ are disjoint, then clearly all transition points of $y$ and $z$ are different. Otherwise, if $P(y)$ and $P(z)$ intersect, one of $y,z$ is an ancestor of the other in $P$. Assume without loss of generality that $y$ is an ancestor of $z$. If the dominating subtree for $y$ is the subtree including $P(z)$, then all transition points of $y$ are not in $P(z)$. Otherwise, there is a transition point $\ell$ for $y$ in the subtree of $P(y)$ which includes $P(z)$. Observe that $\ell$ is the lowest common ancestor of all points of $P(z)$ it $T_{t}$, so it can not be a transition point for $z$. ∎

Since preferred child changes for nodes $y$ of $P$ are charged to touches of transition points for $y$, this implies that by summing overall nodes, no unit cost operation is counted twice. We conclude that the cost of $\operatorname{ALG}$ is at least $I(G,P,X)/2-n.\qed$

4 Tango Trees on Trees

In this section, we develop a dynamic search tree data structure that achieves a competitive ratio of $O(\log\log n)$, for search sequences of length $\Omega(n)$. To achieve this, we connect the cost of our algorithm to the interleave lower bound for search trees presented in Section 3.

Preferred paths.

A crucial ingredient in building our data structure is the notion of a preferred path. Let $P$ be a fixed valid search tree of a tree $G$. We define a preferred path in $P$ as follows: Start from a node that is not the preferred child of its parent (or start from the root) and perform a walk by following the preferred child of the current node, until reaching a leaf. If the preferred child is undefined, pick one arbitrarily.

Note that each change of preferred child during a search sequence results to changes in the preferred paths of $P$. Let $y$ be a node in a preferred path $\Pi$. If $y$ changes preferred child from $y_{j}$ to $y_{j^{\prime}}$, then $\Pi$ splits into two paths $\Pi_{1}$ and $\Pi_{2}$ where $\Pi_{1}$ is from the root to $y$ and $\Pi_{2}$ is rooted at $y_{j}$ and ends at a leaf. Then, $\Pi_{1}$ is merged with the preferred path previously rooted at $y_{j^{\prime}}$

Observation 5**.**

During a search sequence $X$, there are at most $I(G,P,X)+n$ preferred path changes.

The additive $n$ stems from the fact that when the preferred child of a node $v$ is undefined, we pick one of them arbitrarily in order to form a preferred path. Thus when the preferred child of $v$ is defined for first time, a preferred path change might occur. Over all nodes there are at most $n$ such preferred path changes.

High-level overview.

We fix a search tree $P$ of $G$ which we will call reference tree, with the property that the height of $P$ is $O(\log n)$. Note that the reference search tree is used only for the analysis, we do not need to actually store it.

At a high-level, we show that for each preferred path of $P$ “touched”, we can perform search and all update operations (cutting and merging preferred paths) with an overhead factor $O(\log\log n)$. This implies that we have a dynamic search tree execution with cost $O(\log\log n\cdot(I(G,P,X)+n))$, due to Observation 5. This combined with Theorem 3.1 implies that the cost of our dynamic search tree data structure is $O(\log\log n)\cdot\operatorname{OPT}(G,X)$ for sufficiently long sequences.

In traditional tango trees, the preferred paths are represented by binary search trees, such as red-black trees [DHIP07], or splay trees [WDS06]. This is possible because the sets of nodes on a preferred path are totally ordered. In contrast, in our case, the sets of nodes on a preferred path no longer are totally ordered. We enforce a property on the nodes of a preferred path that we call the Steiner-closed property. Surprisingly, this property ensures that the nodes of a preferred path correspond to trees that are obtained as minors of $G$. Thus, to perform the cutting and merging of preferred paths, we need a data structure that allows us to manipulate arbitrary trees. It turns out that Sleator and Tarjan’s link-cut trees are precisely what we need [ST83, Tar83].

Roadmap.

The rest of this section is organized as follows. In subsection 4.1, we introduce the notion of Steiner-closed sets and Steiner-closed trees. In subsection 4.2 we show that there exists a Steiner-closed reference tree $P$ of depth $O(\log n)$, and that the nodes contained in a preferred path form a tree obtained as a minor of $G$. In subsection 4.3, we show that the changes of preferred paths can be implemented using link-cut trees. Finally, in subsection 4.4 we summarize our overall structure and prove that our data structure is $O(\log\log n)$-competitive.

4.1 Steiner closed sets and trees

In the following, for two vertices $a$ and $b$ in $G$, let $P(a,b)$ be the the set of vertices on the path from $a$ to $b$. We first define the notion of convex hull on a set of vertices of a tree.

Definition 9** (Convex Hull).**

Given a tree $G=(V,E)$, for a set $S\subseteq V$ of vertices, we define the convex hull $\CH(S)$ be the subgraph of $G$ induced by the vertices on all paths $P(a,b)$, for all pairs of points $a,b$ in $S$.

We now introduce the notion of Steiner-closed which is critical for our result.

Definition 10** (Steiner-closed set).**

A set $S$ is a Steiner-closed set of vertices of a tree $G$ provided that every vertex in $\CH(S)\setminus S$ has degree exactly two in $\CH(S)$.

Definition 11** (Steiner-closed tree).**

A search tree $T$ of a tree $G$ is a Steiner-closed tree provided that the set of nodes on the path in $T$ from the root to an arbitrary node in $T$ is a Steiner-closed set with respect to $G$.

The following is one of the key properties of Steiner-closed trees that lets us manipulate them efficiently. Essentially, we show that there are not many structural changes that occur in $G$ when splitting and merging paths from the root in a Steiner-closed search tree $T$ of $G$.

Lemma 4.1**.**

Let $\Pi=p_{0},\ldots,p_{j}$ be a path from the root $p_{0}$ to a node $p_{j}$ in a Steiner-closed search tree $T$ of tree $G$. For any $i\in\{1,\ldots,j\}$, let $\Pi^{\prime}=p_{i},\ldots,p_{j}$. Removing $\CH(\Pi^{\prime})$ from $\CH(\Pi)$ results in at most 2 connected components.

Proof.

Let $\Pi^{\prime\prime}=p_{0},\ldots,p_{i-1}$. Since $T$ is Steiner-closed, we note that by definition, $\CH(\Pi^{\prime\prime})$ is a Steiner-closed set with respect to $G$. For sake of a contradiction, suppose that removing $\CH(\Pi^{\prime})$ from $\CH(\Pi)$ in $G$ results in at least 3 connected components. Let $C_{1},C_{2}$ and $C_{3}$ be 3 of these components. Since $\CH(\Pi^{\prime})$ is a subtree of $\CH(\Pi)$ let $c_{i}c_{i}^{\prime}$ with $i\in\{1,2,3\}$ be the cut edges that connect $C_{i}$ to $\CH(\Pi^{\prime})$ with $c_{i}\in C_{i}$ and $c_{i}^{\prime}\in\CH(\Pi^{\prime})$. Let $P(c_{1},c_{2})$ be the path in $\CH(\Pi)$ from $c_{1}$ to $c_{2}$ and $P(c_{1},c_{3})$ the path from $c_{1}$ to $c_{3}$. Let $v$ be the first vertex where $P(c_{1},c_{2})$ and $P(c_{1},c_{3})$ diverge. Note that $v\not\in\Pi^{\prime\prime}$. However, $v\in\CH(\Pi^{\prime\prime})$ since $c_{1},c_{2}$ and $c_{3}$ are in $\Pi^{\prime\prime}$. Moreover, $v$ has degree at least 3 in $\CH(\Pi^{\prime\prime})$ which contradicts the fact that $\Pi^{\prime\prime}$ is a Steiner-closed set in $G$. ∎

A static Steiner-closed tree.

Our next lemma shows that given any arbitrary search tree $T$ on a tree $G$, we can transform it to a Steiner-closed tree $T^{\prime}$ of height at most twice the height of $T$.

Lemma 4.2**.**

Given a valid search tree $T$ on a tree $G$, we can create another valid search tree $T^{\prime}$ of $G$, such that $T^{\prime}$ is Steiner-closed and $\operatorname{height}(T^{\prime})\leq 2\operatorname{height}(T)$ .

Proof.

We show how to transform an arbitrary valid search tree $T$ of a tree $G$ into a Steiner-closed search tree $T^{\prime}$ where the depth of any node in $T^{\prime}$ is at most twice its depth in $T$. We perform a depth-first search on $T$ and build our Steiner-closed tree incrementally. Let $r$ be the root of $T$. For any non-root node $v$ with parent $p(v)$, let $S_{v}$ be the set of elements in the path from the root $r$ to $v$. At each step $i$ we transform the tree $T_{i}$ into the tree $T_{i+1}$ such that $T_{0}=T$ and $T_{final}=T^{\prime}$.

We describe one step of our transformation. Suppose the current tree is $T_{i}$ and our DFS visits a node $v\in T$ such that: (i) the set $S_{p(v)}$ is Steiner-closed in $G$ and (ii) the set $S_{v}$ is not Steiner-closed. This means that $\CH(S_{v})$ contains a unique vertex $s\in\CH(S_{v})\setminus S$ with degree at least 3. Observe that the vertices on the path between $p(v)$ and $v$ in $G$ are contained in the subtree rooted at $v$ in $T_{i}$. Since $s$ is on this path, it is in the subtree rooted at $v$ in $T_{i}$. We obtain $T_{i+1}$ by rotating $s$ up the tree until it is between $p(v)$ and $v$, that is, we make it a parent of $v$ and a child of $p(v)$. Note that in $T_{i+1}$ the path from $v$ up to root is now Steiner-closed  by construction. We then continue our DFS traversal from node $s$.

Let $v_{s}$ be the child of $v$ in $T_{i}$ such that $s$ is in the subtree rooted at $v_{s}$. Let also $v_{1},\dotsc,v_{d}$ be the other children of $v$. Since we perform single rotations to move $s$ up until it becomes a parent of $v$, it is easy to see that by switching from $T_{i}$ to $T_{i+1}$, the depth of all nodes in subtrees rooted at $v_{1},\dotsc,v_{d}$ increases by 1 and the depth of all other nodes of $T_{i}$ does not increase. Thus, for a node $w$ in a subtree rooted at $v_{j}$, $1\leq j\leq d$, we have that the depth of $w$ increases by 1, the new root-to-$w$ path is the same as before augmented by node $s$ and the path from root to $v$ is Steiner-closed. This implies that all possible depth increases of $w$ will be caused by nodes in the path between $v$ and $w$. Summing overall changes, we get that for any node of the tree at depth $d$ in $T_{0}$, its depth can increase by 1 at most $d$ times, i.e., its depth at $T^{\prime}$ is at most $2d$.

At the end of this process, $T^{\prime}$ is Steiner-closed by construction. Since the depth of every node at most doubles, the height of $T^{\prime}$ is at most twice the height of $T$. ∎

4.2 Building the Reference tree

To build our reference tree we use as a building block the centroid decomposition $C$ of $G$.

Lemma 4.3**.**

Given a tree $G$, there is a search tree $C$ of $G$ with height at most $\log_{2}n+1$. The tree $C$ is a centroid decomposition tree obtained by recursive application of Jordan’s theorem [Jor69, Har69]: Given a tree $G$ with $n$ vertices, there exists a vertex whose removal partitions the tree into components, each with at most $n/2$ vertices.

The centroid decomposition of a tree $G$ can be seen as the generalization of balanced binary search trees with height $O(\log n)$. Figure 6 shows an example. A centroid decomposition can be computed in time $O(n\log n)$, since we need $O(n)$ to find the centroid of a tree on $n$ vertices. Using Lemma 4.3 and Lemma 4.2 we get the following corollary.

Corollary 4.4**.**

For any tree $G$ on $n$ vertices, there exists a valid search tree $P$ on $G$ which is Steiner-closed and it has height at most $2\log n+2$.

This is because the centroid decomposition $C$ has height $\log n+1$, thus the tree $P$ can be obtained by applying Lemma 4.2 for $T=C$. The tree $P$ will be our reference tree in the rest of this paper. We need to show that each preferred path of $P$ can be stored in a search tree. To do that, we first observe that all preferred paths of $P$ are Steiner-closed.

Observation 6**.**

If a search tree $T$ of a tree $G$ is Steiner-closed, then for all nodes $v$ in $T$, the subtree $T_{v}$ rooted at $v$ is also Steiner-closed.

This comes from the fact that the subtree rooted at $v$ contains a connected component obtained after the removal of vertices in the path from the root of $T$ to the parent of $v$. Since $T$ is Steiner-closed, then $T_{v}$ should also be Steiner-closed. This observation implies that all preferred paths of $P$ are Steiner-closed. The next lemma shows that a Steiner-closed set $S$ corresponds to a tree on $S$ which is a obtained by contracting edges of $G$. Let $\bar{P}(a,b)$ denote the set of nodes $v\neq\{a,b\}$ of the path from $a$ to $b$.

Definition 12**.**

For a Steiner-closed set of vertices $S$ of $G$, let $G(S)$ to be the graph with vertex set $S$ where two vertices $a,b\in S$ are connected by an edge if and only if no $c\in S$ is in $\bar{P}(a,b)$.

Our next Lemma directly follows from Definition 10.

Lemma 4.5**.**

For any Steiner-closed set $S$, $G(S)$ is a tree.

It now remains to show how to maintain the trees $G(S)$ corresponding to the preferred paths of $P$.

4.3 Maintaining preferred paths with link-cut trees

We now show that a collection of Steiner-closed preferred paths, each of which has length at most $k$, can be stored in a data structure supporting search, cut and merge at a cost of $O(\log k)$ in the GST model of computation. Our goal is to use this for the preferred paths of $P$ of length $k=O(\log n)$, to get the $O(\log k)=O(\log\log n)$ bound.

During an execution of a search sequence we need to perform the following operations on preferred paths:

1. (i)

Search for a node in a preferred path $\Pi$. 2. (ii)

Cut a preferred path $\Pi$ into two paths, one consisting of nodes of depth smaller than $d$ in $P$ and the other of nodes of depth at least $d$. We denote this operation $\operatorname{Cut}(\Pi,d)$. 3. (iii)

Merge two preferred paths $\Pi_{1}$ and $\Pi_{2}$, where the bottom node of $\Pi_{1}$ is the parent of the top node of $\Pi_{2}$.

Let $\Pi$ be a preferred path containing a Steiner-closed set of nodes $S$. In order to split $\Pi$ into two paths, we split $G(S)$ into two trees $G(S_{1})$ and $G(S_{2})$, where $S_{1}$ and $S_{2}$ are the nodes in $\Pi_{1}$ and $\Pi_{2}$. From Observation 6, we know that the bottom part $\Pi_{2}$ is also Steiner-closed, which implies $G(S_{2})$ is a tree. The path $\Pi_{1}$ is clearly Steiner-closed  since $P$ is Steiner-closed. In fact, from the Steiner-closed property and Lemma 4.1, we have that $G(S_{2})$ can be obtained from $G(S)$ by cutting at most two edges of $G(S)$.

Conversely, if we merge two preferred paths $\Pi_{1}$ and $\Pi_{2}$ into one path $\Pi$, where the bottom of $\Pi_{1}$ is connected to the top of $\Pi_{2}$ in $P$, we need to construct the tree $G(S)$, where $S$ is the union of the sets of nodes $S_{1}$ and $S_{2}$ in the paths $\Pi_{1}$ and $\Pi_{2}$. Again $G(S_{2})$ can be merged with $G(S_{1})$ to yield $G(S)$ by cutting $G(S_{1})$ at at most two places, and linking the two trees by adding two edges.

Basic operations that need to be supported in logarithmic time.

We need to implement a data structure supporting the above operations on the forest of trees $G(S)$ at $O(\log k)$ cost in the GST model. Each of these operations can be split into a constant number of one of these two operations: cut a tree into two by removing an edge, and link two trees into one by adding an edge. In what follows, we refer to the trees $G(S)$, for each set $S$ of nodes in a preferred path of $P$, as the represented trees.

Here we resort to the classical link-cut trees data structure from Sleator and Tarjan[ST83]. Link-cut trees can be used to implement link and cut operations on a forest of unrooted trees in amortized time proportional to the logarithm of the size of the largest tree in the forest. We refer to Tarjan’s textbook for details [Tar83].

The link-cut tree data structure implements a heavy-path decomposition on the represented trees. Each heavy path in this decomposition is in turn represented by a splay tree [ST85]. Note that this decomposition should not be confused with the decomposition of $P$ into preferred paths; we are performing two levels of decomposition into paths. Link-cut trees effectively reduce the problem of maintaining the forest of trees to binary search tree operations. Our data structure eventually consists of a hierarchy of splay trees, each representing a path in a tree $G(S)$, which in turn corresponds to a path in the reference tree $P$.

We now have to check that the whole structure is indeed a search tree on $G$, and that the binary search tree operations are indeed proper elementary operations in the GST model. This we can observe by considering the first preferred path $\Pi$ in $P$ with nodes $S$, and the first heavy path in the decomposition of $G(S)$, stored as a splay tree. Searching in such a splay tree amounts to searching along a path of $G(S)$, whose convex hull is a path in $G$. Recalling our Observation 2, this is a proper search in the GST model. The search now proceeds by searching the next heavy paths in $G(S)$, and maybe switch to other preferred paths of $P$. Overall, this is a proper search in $G$. Similarly, rotations in the splay trees are rotations of the search tree on $G$ as defined in the GST model.

4.4 Our Algorithm

Let us first sum up the overall data structure. Given the graph $G$, we construct a balanced Steiner-closed search tree $P$ on $G$, which we refer to as the reference tree. We dynamically maintain a decomposition of $P$ into preferred paths. Each such preferred path with nodes $S$ corresponds to an unrooted tree $G(S)$, which is a minor of $G$. As searches are performed, preferred paths are updated, and these updates correspond to linking and cutting trees $G(S)$. For this, we use link-cut trees. Those in turn decompose the trees $G(S)$ into paths and reduce the operations to link and cut on paths. These operations can be handled by splay trees. Together, they form a search tree on $G$.

Bounding the cost.

We now compare the cost of our Tango Search Tree data structure to $\operatorname{OPT}(G,X)$. The following lemma makes the essential connection between the number of preferred paths touched during a search and the cost of our algorithm.

Lemma 4.6**.**

Let $\ell$ be the number of preferred child changes during a search. Then the cost of this search is $O((\ell+1)(1+\log\log n))$.

Proof.

During the search, the pointer touches exactly $\ell+1$ preferred paths. We account separately for the search cost and the update cost.

For each preferred path touched, the search cost is $O(\lceil\log\log n\rceil)$. Thus the total search cost is clearly $O((\ell+1)(1+\log\log n))$.

We now account for the update cost. Recall that we can cut and merge preferred paths on $k$ nodes in time $O(1+\log k)$. Since each preferred path has at most $O(\log n)$ nodes, we can perform those updates in time $O(1+\log\log n)$. There are $\ell$ preferred path changes, and for each change we perform one cut and and one merge operation, we get that the total time for merging and cutting is $O(\ell\cdot(1+\log\log n))$. The lemma follows. ∎

We now combine this lemma with Theorem 3.1 to get the competitive ratio of Tango Search Tree.

Theorem 4.7**.**

For any search sequence of length $m=\Omega(n)$, Tango Search Tree are $O(\log\log n)$-competitive.

Proof.

We account only for the cost occurred during searches, since the cost of transforming the input tree into a valid Tango Search Tree is just a fixed additive term which does not depend on the input sequence.

By Observation 5 we have that the total number of preferred path changes is at most $I(G,P,X)+n$. Using Lemma 4.6 and summing up over all search requests, we get that the cost of Tango Search Tree is $O((I(G,P,X)+n+m)(1+\log\log n))$.

By Theorem 3.1 this is bounded by $O((\operatorname{OPT}(G,X)+n+m)\cdot(1+\log\log n))$. Note that $\operatorname{OPT}(G,X)\geq m$. Since $m=\Omega(n)$, we have that $\operatorname{OPT}(G,X)+n+m=O(\operatorname{OPT}(G,X))$. We get that the total cost is upper bounded by

[TABLE]