The skyline operator is important for multicriteria decision-making applications. Although many recent studies developed efficient methods to compute skyline objects in a given space, none of them considers skylines in multiple subspaces simultaneously. More importantly, the fundamental

The maximal vector problem is to identify the maximals over a collection of vectors. This arises in many contexts and, as such, has been well studied. The problem recently gained renewed attention with skyline queries for relational databases and with work to develop skyline algorithms that are external and relationally well behaved. While many algorithms have been proposed, how they perform has been unclear. We study the performance of, and design choices behind, these algorithms. We prove runtime bounds based on the number of vectors n and the dimensionality k. Early algorithms based on divide-and-conquer established seemingly good average and worst-case asymptotic runtimes. In fact, the problem can be solved in O(n) average-case (holding k as fixed). We prove, however, that the performance is quite bad with respect to k. We demonstrate that the more recent skyline algorithms are better behaved, and can also achieve O(kn) averagecase. While k matters for these, in practice, its effect vanishes in the asymptotic. We introduce a new external algorithm, LESS, that is more efficient and better behaved. We evaluate LESS’s effectiveness and improvement over the field, and prove that its average-case running time is O(kn). 1

The rectilinear Steiner tree problem is to find a minimum-length rectilinear interconnection of a set of points in the plane. A reduction from the rectilinear Steiner tree problem to the graph Steiner tree problem allows the use of exact algorithms for the graph Steiner tree problem to solve the rectilinear problem. Furthermore, anumber of more direct, geometric algorithms have been devised for computing optimal rectilinear Steiner trees. This paper surveys algorithms for computing optimal rectilinear Steiner trees and presents experimental results comparing nine of them: graph Steiner tree algorithms due to Beasley, Bern, Dreyfus and Wagner, Hakimi, and Shore, Foulds, and Gibbons and geometric algorithms due to Ganley and Cohoon, Salowe and Warme, and Thomborson, Alpern, and Carter. 1 Introduction The rectilinear Steiner tree (RST) problem is stated as follows: given a set T of n points called terminals in the plane, find a set S of additional points called Steiner points such tha...

An O(n log n) algorithm is presented for computing the maximum euclidean distance between two finite planar sets of n points. When the n points form the vertices of simple polygons this complexity can be reduced to O(n). The algorithm is empirically compared to the brute-force method as well as an alternate O(n 2 ) algorithm. Both the O(n log n) and O(n 2 ) algorithms run in O(n) expected time for many underlying distributions of the points. An e-approximate algorithm can be obtained that runs in O(n + 1/e) worst-case time. 1. Introduction Let S 1 = p 1 , p 2 ,..., p n and S 2 = q 1 , q 2 ,..., q n be two planar sets of n points, and let S = S 1 È S 2 . (The sets need not have equal cardinality, but this assumption simplifies notation.) A point p i is given by the cartesian coordinates x i and y i . The maximum distance between S 1 and S 2 , denoted by d max (S 1 , S 2 ), is defined as d max (S 1 , S 2 ) = {d(p i ,q j )}, i, j = 1,2,...,n, where d(p i ,q j ) is the euclidean dista...

We present SAMCRA, an exact QoS routing algorithm that guarantees to find a feasible path if such a path exists. Because SAMCRA is an exact algorithm, its complexity also characterizes that of QoS routing in general. The complexity of SAMCRA is simulated in specific classes of graphs. Since the complexity of an algorithm involves a scaling of relevant parameters, the second part of this paper analyses how routing with multiple independent link weights affects the hopcount distribution. Both the complexity and the hopcount analysis indicate that for a special class of networks, QoS routing exhibits features similar to single-parameter routing. These results suggest that there may exist classes of graphs in which QoS routing is not NP-complete.

Unlike numerical preferences, preferences on attribute values do not show an inherent total order, but skyline computation has to rely on partial orderings explicitly stated by the user. In such orders many object values are incomparable, hence skylines sizes become unpractical. However, the Pareto semantics can be modified to benefit from indifferences: skyline result sizes can be essentially reduced by allowing the user to declare some incomparable values as equally desirable. A major problem of adding such equivalences is that they may result in intransitivity of the aggregated Pareto order and thus efficient query processing is hampered. In this paper we analyze how far the strict Pareto semantics can be relaxed while always retaining transitivity of the induced Pareto aggregation. Extensive practical tests show that skyline sizes can indeed be reduced about two orders of magnitude when using the maximum possible relaxation still guaranteeing the consistency with all user preferences.

Abstract not found

Today, result sets of skyline queries are unmanageable due to their exponential growth with the number of query predicates. In this paper we discuss the incremental re-computation of skylines based on additional information elicited from the user. Extending the traditional case of totally ordered domains, we consider preferences in their most general form as strict partial orders of attribute values. After getting an initial skyline set our basic approach aims at interactively increasing the system’s information about the user’s wishes explicitly including indifferences. The additional knowledge then is incorporated into the preference information and constantly reduces skyline sizes. In fact, our approach even allows users to specify trade-offs between different query predicates, thus effectively decreasing the query dimensionality. We give theoretical proof for the soundness and consistence of the extended preference information and an extensive experimental evaluation of the efficiency of our approach. On average, skyline sizes can be considerably decreased in each elicitation step.

Consider n independent identically distributed random vectors from R d with common density f , and let E(C) be the average complexity of an algorithm that finds the convex hull of these points. Most well-known algorithms satisfy E(C) = O(n) for certain classes of densities. In this note, we show that E(C) = O(n) for algorithms that use a "throw-away" pre-processing step when f is bounded away from 0 and 1 on any nondegenerate rectangle of R 2 . 1 Introduction Let X 1 ; : : : ; X n be independent identically distributed random vectors from R d with common density f , and let C be the complexity of a given convex hull algorithms for X 1 ; : : : ; X n (thus, C is a random variable). In this note we will discuss several convex hull algorithms and the condition on f that will insure their linear average time behavior: E(C) = O(n) (1) In general, the more sophisticated algorithms satisfy (1) for a larger class of densities than do the simple algorithms. The purpose of this note is ...

Preference-based queries often referred to as skyline queries play an important role in cooperative query processing. However, their prohibitive result sizes pose a severe challenge to the paradigm‟s practical applicability. In this paper we discuss the incremental re-computation of skylines based on additional information elicited from the user. Extending the traditional case of totally ordered domains, we consider preferences in their most general form as strict partial orders of attribute values. After getting an initial skyline set our approach aims at incrementally increasing the system‟s information about the user‟s wishes. This additional knowledge then is incorporated into the preference information and constantly reduces skyline sizes. In particular, our approach also allows users to specify trade-offs between different query attributes, thus effectively decreasing the query dimensionality. We provide the required theoretical foundations for modeling preferences and equivalences, show how to compute incremented skylines, and proof the correctness of the algorithm. Moreover, we show that incremented skyline computation can take advantage of locality and database indices and thus the performance of the algorithm can be additionally increased.