Eduardo Sany Laber

Searching in random partially ordered sets

We consider the problem of searching for a given element in a partially ordered set. More precisely, we address the problem of computing efficiently near-optimal search strategies for typical partial orders under two classical models for random partial orders, the random graph model and the uniform model.We shall show that the problem of determining an optimal strategy is NP-hard, but there are simple, fast algorithms able to produce near-optimal search strategies for typical partial orders under the two models of random partial orders that we consider. We present a (1 + o(1))- approximation algorithm for typical partial orders under the random graph model (constant p) and present a 6.34-approximation algorithm for typical partial orders under the uniform model. Both algorithms run in polynomial time.

Efficient algorithms for the hotlink assignment problem: the worst case search

Let T be a rooted directed tree where nodes represent web pages of a web site and arcs represent hyperlinks In this case, when a user searches for an information i, it traverses a directed path in T, from the root node to the node that contains i In this context, hotlinks are defined as additional hyperlinks added to web pages in order to reduce the number of accessed pages per search In this paper, we address the problem of inserting at most 1 hotlink in each web page, so as to minimize the number of accesses in a worst case search We present a (14/3)-approximate algorithm that runs in a O(n log m) time and requires a linear space, where n and m are the number of nodes (internal and external) and the number of leaves in T, respectively We also introduce an exact dynamic programming algorithm which runs in O(n(nm)2.284) time and uses O(n(nm)1.441) space By extending the techniques presented here, a polynomial time algorithm can also be obtained when

On the hardness of the minimum height decision tree problem

{\mathcal K}=O(1)

Near linear time construction of an approximate index for all maximum consecutive sub-sums of a sequence

hotlinks may be inserted in each page The best known result for this problem is a polytime algorithm with constant approximation ratio for trees with bounded degree presented by Gerstel et al [1].

Reducing human interactions in Web directory searches

Given a set of objects O and a set of tests T, the abstract decision tree problem (DTP) is to construct a tree with minimum height that completely identifies the objects of O, by using the tests of T. No algorithm with a good approximation ratio is known to solve this problem. We give a theoretical support for this fact by showing that DTP does not admit an o(log n)-approximation algorithm unless P = NP.

A new strategy for querying priced information

We present a novel approach for computing all maximum consecutive subsums in a sequence of positive integers in near linear time. Solutions for this problem over binary sequences can be used for reporting existence (and possibly one occurrence) of Parikh vectors in a bit string. Recently, several attempts have been tried to build indexes for all Parikh vectors of a binary string in subquadratic time. However, to the best of our knowledge, no algorithm is know to date which can beat by more than a polylogarithmic factor the natural Θ(n2) exhaustive procedure. Our result implies an approximate construction of an index for all Parikh vectors of a binary string in O(n1+η) time, for any constant η>0. Such index is approximate, in the sense that it leaves a small chance for false positives, i.e., Parikh vectors might be reported which are not actually present in the string. No false negative is possible. However, we can tune the parameters of the algorithm so that we can strictly control such a chance of error while still guaranteeing strong sub-quadratic running time.

The binary identification problem for weighted trees

Consider a website containing a collection of webpages with data such as in Yahoo or the Open Directory project. Each page is associated with a weight representing the frequency with which that page is accessed by users. In the tree hierarchy representation, accessing each page requires the user to travel along the path leading to it from the root. By enhancing the index tree with additional edges (hotlinks) one may reduce the access cost of the system. In other words, the hotlinks reduce the expected number of steps needed to reach a leaf page from the tree root, assuming that the user knows which hotlinks to take. The hotlink enhancement problem involves finding a set of hotlinks minimizing this cost. This article proposes the first exact algorithm for the hotlink enhancement problem. This algorithm runs in polynomial time for trees with logarithmic depth. Experiments conducted with real data show that significant improvement in the expected number of accesses per search can be achieved in websites using this algorithm. These experiments also suggest that the simple and much faster heuristic proposed previously by Czyzowicz et al. [2003] creates hotlinks that are nearly optimal in the time savings they provide to the user. The version of the hotlink enhancement problem in which the weight distribution on the leaves is unknown is discussed as well. We present a polynomial-time algorithm that is optimal for any tree for any depth.

Efficient Implementation of the WARM-UP Algorithm for the Construction of Length-Restricted Prefix Codes

This paper focuses on competitive function evaluation in the context of computing with priced information. A function f is given together with a cost cx for each variable x of f. The cost cx has to be paid to read the value of x. The problem is to design algorithms that query the values of the variables sequentially in order to compute the function while trying to minimize the total cost incurred. Competitive analysis is employed to evaluate the performance of the algorithms. We describe a novel approach for devising efficient algorithms in this setting. We apply our approach to several classes of functions which have been studied in the literature of computing with priced information. In all cases considered, our approach provides algorithms that achieve better bounds than the best known algorithm for the same class of functions.More precisely, for the class of monotone boolean functions, we give a polynomial time algorithm with extremal competitiveness (k+l - √ min(k,l)) where k (l) denotes the minimum number of variables that one must read, in the worst case, in order to prove that the function under consideration evaluates to 1 (0). This dramatically improves upon the best known result which is an exponential time 2 max(k, l)-competitive algorithm. For the subclass of monotone boolean functions known as Threshold Trees we further improve our bounds and give a polynomial time algorithm with extremal competitive ratio 1.618 max(k, l).We then apply our methodology to classes of non-boolean functions. We consider the case of the so called Game Trees. We improve upon previously published results for this class of functions providing a polynomial time algorithm with extremal competitive ratio 1.5 γ(f), where γ(f) is a lower bound on the extremal competitive ratio of any deterministic algorithm.Finally, we consider the case when f is the function min (minimum). In this case, we are able to determine the optimal competitiveness for the problem. In fact we provide an algorithm with an (n-2)-competitive ratio, which matches the known lower bound.

Indexes for Jumbled Pattern Matching in Strings, Trees and Graphs

The Binary Identification Problem for weighted trees asks for the minimum cost strategy (decision tree) for identifying a vertex in an edge weighted tree via testing edges. Each edge has assigned a different cost, to be paid for testing it. Testing an edge e reveals in which component of T-e lies the vertex to be identified. We give a complete characterization of the computational complexity of this problem with respect to both tree diameter and degree. In particular, we show that it is strongly NP-hard to compute a minimum cost decision tree for weighted trees of diameter at least 6, and for trees having degree three or more. For trees of diameter five or less, we give a polynomial time algorithm. Moreover, for the degree 2 case, we significantly improve the straightforward O(n^3) dynamic programming approach, and provide an O(n^2) time algorithm. Finally, this work contains the first approximate decision tree construction algorithm that breaks the barrier of factor logn.

A fast and simple method for extracting relevant content from news webpages

Given an alphabet Σ = {a1, ..., an} with a corresponding list of positive weights {w1, ..., wn} and a length restriction L, the length-restricted prefix code problem is to find, a prefix code that minimizes Σni=1 wili, where li, the length of the codeword assigned to ai, cannot be greater than L, for i = 1, ..., n. In this paper, we present an efficient implementation of the WARM-UP algorithm, an approximative method for this problem. The worst-case time complexity of WARMUP is O(n log n + n log wn), where wn is the greatest weight. However, some experiments with a previous implementation of WARM-UP show that it runs in linear time for several practical cases, if the input weights are already sorted. In addition, it often produces optimal codes. The proposed implementation combines two new enhancements to reduce the space usage of WARM-UP and to improve its execution time. As a result, it is about ten times faster than the previous implementation of WARM-UP and overcomes the LRR Package Method, the faster known exact method.