198,692 research outputs found
In pursuit of the dynamic optimality conjecture
In 1985, Sleator and Tarjan introduced the splay tree, a self-adjusting
binary search tree algorithm. Splay trees were conjectured to perform within a
constant factor as any offline rotation-based search tree algorithm on every
sufficiently long sequence---any binary search tree algorithm that has this
property is said to be dynamically optimal. However, currently neither splay
trees nor any other tree algorithm is known to be dynamically optimal. Here we
survey the progress that has been made in the almost thirty years since the
conjecture was first formulated, and present a binary search tree algorithm
that is dynamically optimal if any binary search tree algorithm is dynamically
optimal.Comment: Preliminary version of paper to appear in the Conference on Space
Efficient Data Structures, Streams and Algorithms to be held in August 2013
in honor of Ian Munro's 66th birthda
Optimal Binary Search Trees with Near Minimal Height
Suppose we have n keys, n access probabilities for the keys, and n+1 access
probabilities for the gaps between the keys. Let h_min(n) be the minimal height
of a binary search tree for n keys. We consider the problem to construct an
optimal binary search tree with near minimal height, i.e.\ with height h <=
h_min(n) + Delta for some fixed Delta. It is shown, that for any fixed Delta
optimal binary search trees with near minimal height can be constructed in time
O(n^2). This is as fast as in the unrestricted case.
So far, the best known algorithms for the construction of height-restricted
optimal binary search trees have running time O(L n^2), whereby L is the
maximal permitted height. Compared to these algorithms our algorithm is at
least faster by a factor of log n, because L is lower bounded by log n
In Search of Optimal Linkage Trees
Linkage-learning Evolutionary Algorithms (EAs) use linkage
learning to construct a linkage model, which is exploited
to solve problems efficiently by taking into account important
linkages, i.e. dependencies between problem variables,
during variation. It has been shown that when this linkage
model is aligned correctly with the structure of the problem,
these EAs are capable of solving problems efficiently by
performing variation based on this linkage model [2]. The
Linkage Tree Genetic Algorithm (LTGA) uses a Linkage Tree
(LT) as a linkage model to identify the problem's structure
hierarchically, enabling it to solve various problems very
efficiently. Understanding the reasons for LTGA's excellent
performance is highly valuable as LTGA is also able to
efficiently solve problems for which a tree-like linkage model
seems inappropriate. This brings us to ask what in fact
makes a linkage model ideal for LTGA to be used
Recommended from our members
Generation of optimal binary split trees
A binary split tree is a search structure combining features of heaps and binary search trees. Building an optimal binary split tree was originally conjectured to be intractable due to difficulties in applying dynamic programming techniques to the problem. However, two algorithms have recently been published which purportedly generate optimal trees in O(n^5) time, for records with distinct access probabilities. An extension allowing non-distinct access probabilities required exponential time. These algorithms consider a range of values when only a single value is possible, and may select an infeasible value which leads to an incorrect result. A dynamic programming method for determining the correct value is given, resulting in an algorithm which builds an optimal binary split tree in O(n^5) time for non-distinct access probabilities and Θ(n^4) time for distinct access probabilities
Subtree weight ratios for optimal binary search trees
For an optimal binary search tree T with a subtree S(d) at a distance d from the root of T, we study the ratio of the weight of S(d) to the weight of T. The maximum possible value, which we call ρ(d), of the ratio of weights, is found to have an upper bound of 2/F_d+3 where F_i is the ith Fibonacci number. For d = 1, 2, 3, and 4, the bound is shown to be tight. For larger d, the Fibonacci bound gives ρ(d) = O(ϕ^d) where ϕ ~ .61803 is the golden ratio. By giving a particular set of optimal trees, we prove ρ(d) = Ω((.58578 ... )^d), and believe a similar proof follows for ρ(d) = Ω((.60179 ... )^d). If we include frequencies for unsuccessful searches in the optimal binary search trees, the Fibonacci bound is found to be tight
Dynamic Trees with Almost-Optimal Access Cost
An optimal binary search tree for an access sequence on elements is a static tree that minimizes the total search cost. Constructing perfectly optimal binary search trees is expensive so the most efficient algorithms construct almost optimal search trees. There exists a long literature of constructing almost optimal search trees dynamically, i.e., when the access pattern is not known in advance. All of these trees, e.g., splay trees and treaps, provide a multiplicative approximation to the optimal search cost.
In this paper we show how to maintain an almost optimal weighted binary search tree under access operations and insertions of new elements where the approximation is an additive constant. More technically, we maintain a tree in which the depth of the leaf holding an element e_i does not exceed min(log(W/w_i),log n)+O(1) where w_i is the number of times e_i was accessed and W is the total length of the access sequence.
Our techniques can also be used to encode a sequence of m symbols with a dynamic alphabetic code in O(m) time so that the encoding length is bounded by m(H+O(1)), where H is the entropy of the sequence. This is the first efficient algorithm for adaptive alphabetic coding that runs in constant time per symbol
evtree: Evolutionary Learning of Globally Optimal Classification and Regression Trees in R
Commonly used classification and regression tree methods like the CART algorithm are recursive partitioning methods that build the model in a forward stepwise search. Although this approach is known to be an efficient heuristic, the results of recursive tree methods are only locally optimal, as splits are chosen to maximize homogeneity at the next step only. An alternative way to search over the parameter space of trees is to use global optimization methods like evolutionary algorithms. This paper describes the "evtree" package, which implements an evolutionary algorithm for learning globally optimal classification and regression trees in R. Computationally intensive tasks are fully computed in C++ while the "partykit" (Hothorn and Zeileis 2011) package is leveraged for representing the resulting trees in R, providing unified infrastructure for summaries, visualizations, and predictions. "evtree" is compared to "rpart" (Therneau and Atkinson 1997), the open-source CART implementation, and conditional inference trees ("ctree", Hothorn, Hornik, and Zeileis 2006). The usefulness of "evtree" is illustrated in a textbook customer classification task and a benchmark study of predictive accuracy in which "evtree" achieved at least similar and most of the time better results compared to the recursive algorithms "rpart" and "ctree".machine learning, classification trees, regression trees, evolutionary algorithms, R
- …