1

Monochromatic and Bichromatic ReverseTop-k Queries

Akrivi Vlachou, Christos Doulkeridis, Yannis Kotidis, and Kjetil Nørvag

✦

Abstract —Nowadays, most applications return to the user a limitedset of ranked results based on the individual user’s preferences,which are commonly expressed through top-k queries. From the per-spective of a manufacturer, it is imperative that her products appearin the highest ranked positions for many different user preferences,otherwise the product is not visible to potential customers. In thispaper, we define a novel query type, namely the reverse top-k query,that covers this requirement: ”Given a potential product, which arethe user preferences that make this product belong to the top-k queryresult set?”. Reverse top-k queries are essential for manufacturersto assess the impact of their products in the market based on thecompetition. We formally define reverse top-k queries and introducetwo versions of the query, monochromatic and bichromatic. First, weprovide a geometric interpretation of the monochromatic reverse top-k query to acquire an intuition of the solution space. Then, we studyin detail the case of bichromatic reverse top-k query, and we proposetwo techniques for query processing, namely an efficient threshold-based algorithm and an algorithm based on materialized reverse top-k views. Our experimental evaluation demonstrates the efficiency ofour techniques.

Index Terms —reverse top-k query, top-k query, user preferences

1 INTRODUCTION

Recently, the support for rank-aware query processinghas attracted much attention in the database researchcommunity. Top-k queries retrieve only a ranked setof k objects that best match the user preferences, thusavoiding overwhelming result sets. Since most appli-cations return to the user only a limited set of rankedresults based on the individual user’s preferences, itis imperative for a manufacturer that her productsappear in the highest ranked positions for manydifferent user preferences, otherwise the product isnot visible to potential customers. In this paper, weassume that users express their preferences throughlinear top-k queries, which are defined by assigning a

• A. Vlachou, C. Doulkeridis and K. Nørvag are with the Department ofComputer Science, Norwegian University of Science and Technology,Norway.E-mails: {vlachou, cdoulk, noervaag}@idi.ntnu.no

• Y. Kotidis is with the Department of Informatics, Athens Universityof Economics and Business, Greece.E-mail: kotidis@aueb.gr

weight to each of the scoring attributes, indicating theimportance of each attribute to the user. This modelis in agreement with the notion of preference [1], [2]and is widely adopted in related work.

In this paper, we define a novel query type, namelythe reverse top-k query, which can be expressed asfollows: ”Given a potential product, which are theuser preferences for which this product is in thetop-k query result set?”. We formally define re-verse top-k queries and study two versions of thequery: monochromatic and bichromatic reverse top-kqueries. In the former, there is no knowledge of userpreferences and the aim is to estimate the impact of apotential product in the market. In the latter, a datasetwith user preferences is given and a reverse top-kquery returns those preferences that rank a potentialproduct highly. To the best of our knowledge, this isthe first work that addresses this problem.Contributions. First, we introduce and formallydefine a novel query type called reverse top-kquery (Section 3) and present two versions, namelymonochromatic and bichromatic. We analyze the ge-ometrical properties for the 2-dimensional case of themonochromatic reverse top-k query and provide analgorithmic solution (Section 4). Furthermore, we dis-cuss the geometric interpretation of the solution spacefor higher dimensionality. Then, we study in detail thecase of bichromatic reverse top-k query. Such a query,if computed in a straightforward manner, requiresevaluating a top-k query for each user preference inthe database, which is prohibitively expensive evenfor moderate datasets. Instead, we propose an efficientand progressive threshold-based algorithm, calledRTA, for processing bichromatic reverse top-k queriesfor arbitrary data dimensionality (Section 5). RTAeagerly discards candidate user preferences, withoutprocessing the respective top-k queries. In addition,we present an indexing structure based on spacepartitioning, which materializes reverse top-k views,in order to further improve reverse top-k query pro-cessing (Section 6). We discuss the construction, usageand maintenance of the index based on materializedreverse top-k views. We conduct a thorough exper-imental evaluation that demonstrates the efficiency

2

of our algorithms (Section 7). It is noteworthy thatour algorithms consistently outperform a brute forcealgorithm by 1 to 3 orders of magnitude in terms ofrequired number of top-k evaluations. Finally, Sec-tion 8 reviews the related work and we conclude inSection 9.

This paper extends our preliminary work [3] andprovides a more thorough study of the problem. Fur-thermore, we present new experimental results thatlead to interesting findings and conclusions.

2 PRELIMINARIES

Given a data space D defined by a set of d dimensions{d1, ..., dd} and a dataset S on D with cardinality |S|,an object p ∈ S can be represented as a d-dimensionalpoint p = {p[1], . . . , p[d]} where p[i] is a value ondimension di. We assume that each dimension rep-resents a numerical scoring attribute, therefore thevalues p[i] in any dimension di are numerical non-negative values. Furthermore, without loss of gen-erality, we assume that smaller scoring values arepreferable.

Top-k queries are defined based on a scoring func-tion f that aggregates the individual scores into anoverall scoring value, that in turn enables the ranking(ordering) of the data points. The most importantand commonly used case of scoring functions is theweighted sum function, also called linear. Each di-mension di has an associated query-dependent weightw[i] indicating di’s relative importance for the query.The aggregated score fw(p) for data point p is de-fined as a weighted sum of the individual scores:

fw(p) =∑d

i=1 w[i]×p[i], where w[i] ≥ 0 (1 ≤ i ≤ d), ∃jsuch that w[j] > 0. The weights represent the relativeimportance between different dimensions, and with-

out loss of generality we assume that∑d

i=1 w[i] = 1.The weights indicate the user preferences, becausethey alter the ranking of the data points and thereforethe top-k result set. A linear top-k query can berepresented by a vector w and the result of a top-kquery is a ranked list of the k points with the bestscoring values fw.

Definition 1: (Top-k query) Given a positive integerk and a user-defined weighting vector w, the resultset TOPk(w) of the top-k query is a set of points suchthat TOPk(w) ⊆ S, |TOPk(w)| = k and ∀p1, p2 : p1 ∈TOPk(w), p2 ∈ S − TOPk(w) it holds that fw(p1) ≤fw(p2).

In a d-dimensional Euclidean space, there existsa one-to-one correspondence between a weightingvector w and a hyperplane ℓ which is perpendicularto w. We call the (d-1)-dimensional hyperplane, whichis perpendicular to vector w and contains a pointp as the query plane of w crossing p, and denote itas ℓw(p). All points lying on the query plane ℓw(p),have the same scoring value equal to the score fw(p)of point p. Fig. 1 (left) depicts an example, where

1

1

2 3 4 5 6 7 8 9 10

2 3 4 5 6 7 8 9

10

price

age

p 1 p 9

p 2

p 4

p 7

p 8

p 10

p 3

p 6

p 5

user preferences

user w[price] w[age] Bob Tom

0.9

Max

0.1 0.8 0.2

0.5 0.5

top-1(score) p 1 (2.5) p 2 (2.2) p 2 (2.5)

w[price]

w[age]

5/6 1/7

1

1

Bob

Tom

Max H w (p 2 )

f w (p 2 ) w = [0.5,0.5]

Fig. 1. Example of reverse top-k query.

the query plane (equivalent to a query line in 2d) isperpendicular to the weighting vector w = [0.5, 0.5].All points pi lying on the query line have a scorevalue fw(pi) = fw(p2) = 2.5. Furthermore, the rankof a point p based on a weighting vector w is equalto the number of the points enclosed in the half-space defined by ℓw(p) that contains the origin of thedata space. Hence, p2 is the top-1 result for the query0.5 × x + 0.5 × y. In the rest of the paper, we referto this half-space as query space of w defined by p anddenote it as Hw(p).

3 REVERSING TOP-k QUERIES

In this section, we introduce the concept of the reversetop-k query through an example and point out thedifferences to existing query types.

3.1 Example of Reverse Top- k Query

Given a database of products, a reverse top-k queryreturns those users (represented by weighting vec-tors) that rank a potential product highly. Considerfor example a database containing information aboutdifferent cars, depicted in Fig. 1 (left). For each car,the price and the age are recorded and minimumvalues on each dimension are preferable. Differentusers have different preferences about a potential carand Fig. 1 (right) also depicts a set of user preferences.For example, Bob prefers a cheap car, and does notcare much about the age of the car. Therefore, thebest choice (top-1) for Bob is the car p1 which hasthe minimum score (namely 2.5) for the particularweights. On the other hand, Tom prefers a newer carrather than a cheap car. Nevertheless, for both Tomand Max the best choice would be car p2.

A reverse top-k query (RTOPk) is defined by a user-specified product p and returns the weighting vectorsw for which p is in the top-k result set. There existtwo different versions of the reverse top-k query: themonochromatic, which does not require any knowl-edge of user preferences, and the bichromatic, whichassumes that a dataset of preferences is given. Inour example, the bichromatic reverse top-1 result setof p1 contains the weighting vector (0.9, 0.1) defined

3

1

1

2 3 4 5 6 7 8 9 10

2 3 4 5 6 7 8 9

10

price

age

p 1 p 9

p 2

p 4 p 7

p 8

p 10

p 3

p 6

p 5

q

(a) RNN vs RTOPk.

1

1

2 3 4 5 6 7 8 9 10

2 3 4 5 6 7 8 9

10

price

age

p 1 p 9

p 2

p 4 p 7

p 8

p 10

p 3

p 6

p 5

q

(b) RSKY vs RTOPk.

Fig. 2. Differences to existing query types.

by Bob. Notice that for p2, two weighting vectorsbelong to the bichromatic reverse top-1 result set{(0.5, 0.5), (0.2, 0.8)}, namely the preferences of Tomand Max. In fact, all weighting vectors with w[price]in the range of [17 , 5

6 ] belong to the bichromatic reversetop-1 result set of p2. This segment of line w[price] +w[age] = 1 is the result set of the monochromaticreverse top-k query for the query point p=p2.

Conceptually, the solution space of reverse top-kqueries is the space defined by the weights w[price]and w[age]. Monochromatic reverse top-k queries re-turn partitions of the solution space and are usefulfor estimating the impact of a product when no userpreferences are given, but the distribution of them isknown. In our example, under assumption of uniformdistribution of user preferences, the impact of p2 inthe market can be estimated as ( 5

6 −17 )×100% = 69%.

On the other hand, bichromatic reverse top-k querieshave even wider applicability, as they identify usersthat are interested in a particular product, given aknown set of user preferences. For instance, the beststrategy for a profile-based marketing service wouldbe to advertise car p1 to Bob and car p2 to Tom andMax. Notice that an empty result set for a product(i.e., car p3) indicates that it is not interesting for anycustomer based on her preferences. Summarizing, forthe bichromatic version of the reverse top-k query,the result set contains a finite number of weightingvectors, while the monochromatic version identifiesthe partitions of the solution space that satisfy thequery.

3.2 Differences to Existing Query Types

The reverse nearest neighbor query (RNN) [4] and thereverse skyline query (RSKY) [5] have been proposedfor supporting decision making. In the following, wepoint out the differences between these query typesand RTOPk queries.

Reverse top-k queries differ from reverse nearestneighbor queries [4]. Given a query point q themonochromatic RNN query retrieves all data pointswhich have q as nearest neighbor. In the case of thecar database, this is equivalent to finding all carsthat are closer to the query point than to any other

point of the dataset. For example, in Fig. 2(a), aRNN query returns p2 (assuming Euclidean distance),while the result set of RTOPk query for k = 1 isdefined by the line segment [ 17 , 5

6 ] in the space ofthe weighting vectors. The bichromatic versions ofthese query types are also different. In our runningexample, the bichromatic RTOPk query returns allweighting vectors w ∈ W such that w[price] ∈ [ 17 , 5

6 ].On the other hand, the bichromatic RNN is definedbased on two datasets A, B, and returns all pointsthat belong to A, that are closer to q than any pointof B. Thus, while a monochromatic/bichromatic RNNquery retrieves a set of points that are closer to thequery point than any other data point, the RTOPkquery retrieves a set of weighting vectors or partitionsof the solution space defined by the weights w[i].An alternative definition of RTOPk query is, given aquery point q, find the distance functions (in termsof weighting vectors) for which q belongs to the k-nearest neighbors of the point positioned at the originof the data space.

The reverse skyline query [5], [6] has been proposedto explore the dominance relationships between prod-ucts relatively to the user preferences. The user prefer-ences are described by a data point that represents theideal (non-existing) product for the user. In contrast,the RTOPk query assumes that the user preferencesare expressed as weights that define the relative im-portance of each dimension. Given a query point, theRSKY query retrieves all data points for which thequery point belongs to their dynamic skyline resultset1. Thus, the RSKY query retrieves the data pointsthat are at least in one dimension more similar (interms of absolute difference of attribute values) to qthan all other data points. For example, in Fig. 2(b),the dynamic skyline of p2 is depicted (gray squarepoints). Since the dynamic skyline query is defined byabsolute differences, q belongs to the dynamic skylineof p2, if and only if only p2 and no other data pointis enclosed in the depicted rectangle. As q belongsto the dynamic skyline, p2 is in the result set of thereverse skyline of q. In the case of bichromatic reverseskyline, two datasets A, B are given, each of themcontaining data points sharing the same attributes (inour example price and age). Then, given a query pointq, the goal is to find all points belonging to A thatare more similar in at least one dimension to q thanany point of B. Both monochromatic and bichromaticRSKY queries differ from RTOPk queries, since in theformer the result set is a set of data points to which qis more similar than all other points in at least onedimension, while in the latter user preferences arereturned that define linear scoring functions for whichq is highly ranked.

1. A point pi dynamically dominates p′i

based on point q, if ∀dj ∈D: |pi[j] − q[j]| ≤ |p′

i[j] − q[j]|, and on at least one dimension

dj ∈ D: |pi[j] − q[j]| < |p′i[j] − q[j]|.

4

4 MONOCHROMATIC RTOPk QUERIES

We commence by providing a formal definition ofmonochromatic reverse top-k for a query point q andan integer k.

Definition 2: (Monochromatic Reverse top-k) Given apoint q and a positive number k, as well as a datasetS, the result set of the monochromatic reverse top-k query (mRTOPk(q)) of point q is the locus2, i.e.,a collection of d-dimensional vectors {wi}, for which∃p ∈ TOPk(wi) such that fwi

(q) ≤ fwi(p).

Let us assume that W denotes the set of all validassignments of w. Fig. 3 shows the data and solutionspace of a 2-dimensional monochromatic reverse top-

k query. All valid weighting vectors (∑d

i=1 w[i] = 1and w[i] ∈ [0, 1]) of the reverse top-k query form theline w[1] + w[2] = 1 in the 2-dimensional solutionspace that is defined by the axis w[1] and w[2]. Sincethe number of possible vectors w is infinite, it isnot possible to enumerate all possible assignments ofw ∈ W . On the other hand, the solution space W canbe split into a finite set of partitions Wi (

⋃

Wi = W ,⋂

Wi = ∅), such that the query point q has the sameranking position for all weighting vectors w ∈ Wi.For the 2-dimensional case, each partition Wi is a linesegment of the line w[1] + w[2] = 1. Then, the resultset of the monochromatic reverse top-k is a set ofpartitions Wi of the solution space W :

mRTOPk(q) = {Wi : ∃wj ∈ Wi ∧ q ∈ TOPk(wj)}For the sake of brevity, in the rest of this paper wedenote a query point q ∈ TOPk(wi), instead of ∃p ∈TOPk(wi) such that fwi

(q) ≤ fwi(p).

In this paper, we assume that any Wi,Wj ∈mRTOPk(q) are non-adjacent partitions, therefore apartition Wi is the maximum partition of the solutionspace in which the rank of q does not change. Themain topic of this section is to identify the parti-tions that form the result set of a monochromaticreverse top-k query. We first present an algorithmfor computing the mRTOPk(q) in the 2-dimensionalcase. Then, we discuss the case of datasets of higherdimensionality.

4.1 Monochromatic RTOP k Query for 2d

Properties of monochromatic RTOPk query. In thefollowing, we present some useful properties ofRTOPk queries and discuss how the boundaries of thepartitions Wi can be determined. We assume that thean ordering w1, . . . , w|W | of the weighting vectors of|W |, such that a weighting vector wi precedes anothervector wj , if wi[1] < wj [1]. Thus, the weighting vectorswi are ordered based on increasing angle of wi withthe y-axis.

Lemma 1: Given two points p and q such thatfw1

(q) ≤ fw1(p), there exists at most one weighting

2. In mathematics, locus is the set of points satisfying a particularcondition, often forming a curve of some sort.

1

1

2 3 4 5 6 7 8 9 10

2 3 4 5 6 7 8 9

10

x

y

w pq

w qr

p 3

p 2

r

p 7

p 4

p 1

q

p 6

p 5 p

(a) Data space

mRTOP 1 (q )

w[1]

w[2]

w pq [2]

w qr [2]

w qr

[1] w pq

[1]

1

1

(b) Solution space.

Fig. 3. Monochromatic reverse top-k query.

vector w such that fwi(q) < fwi

(p) for wi < w, andfwi

(q) > fwi(p) for wi > w.

Based on the above lemma, the relative order of pand q changes for weighting vectors with smaller andlarger angles than w. If p had a lower rank than qfor vectors with smaller angle than w, then p has ahigher rank for vectors with larger angle than w. Ifthere exists such a weighting vector, then we denoteit as wpq and refer to it as the weighting vector for whichthe relative order of q and p changes.

Lemma 2: Given two points p and q, if there existsa weighting vector wpq for which the relative order ofp and q changes, then it holds that fwpq

(q) = fwpq(p).

Equivalently, wpq is the weighting vector that isperpendicular to the line segment pq, with wpq[1] =

λpq

λpq−1 , where λpq = q[2]−p[2]q[1]−p[1] is the slope of line

segment pq. The above equation is derived by theproperty that wpq ⊥ pq.

The boundaries of any partition Wi are defined byweighting vectors wpq for which the relative order ofq and points p ∈ S changes (additionally, the first andlast partition are defined by the weighting vectors[0, 1] and [1, 0] respectively). Intuitively, as long asthe relative order between any two points does notchange, the top-k result is not affected and thus therank of q remains the same.

Lemma 3: There exists at most one partition Wi,such that for all the weighting vectors w ∈ Wi it holdsthat q ∈ TOP1(w).

Since the relative order between q and any datapoint p changes only once, if the rank of p becomeshigher than q, then it cannot change again for the nextvectors. Thus, q cannot be in the top-1 result set forany w > wpq. Therefore, the result set mRTOP1(q)contains at most one partition Wi of W .Example of mRTOPk(q) for k=1. Consider for exam-ple the dataset depicted in Fig. 3(a). Since the onlypoints that belong to the convex hull [7] are p, qand r, we conclude that (1) only these points belongto the top-1 result set for any weighting vector, and(2) there exists at least one weighting vector wi forwhich q ∈ TOP1(wi), and based on Lemma 3 exactlyone partition Wi ∈ mRTOP1(q). The boundaries ofthe partition Wi are defined by the weighting vectors

5

1

1

2 3 4 5 6 7 8 9 10

2345678910

p2

q

x

y

p1

lw1(q)

lw2(q)

lw3(q)

(a) Multiple partitions.

1

1

2 3 4 5 6 7 8 9 10

2345678910

p4

q

x

y

p2

p1

p5

p6

p3

w4

w3

w2

w1

(b) mRTOPk(q) algorithm.

Fig. 4. Examples of mRTOPk(q) queries.

wpq , wqr for which the relative order between q andp or r changes. All weighting vectors w for whichthe following inequality holds are in the reverse top-1 result set of q: wqr[1] ≤ w[1] ≤ wpq[1]. The resultset of mRTOP1(q) is a segment (partition) of the linew[1] + w[2] = 1 in the 2-dimensional solution spacedefined by wpq and wqr, as shown in Fig. 3(b).

Even though the result set mRTOPk for k = 1contains at most one partition, for a reverse top-kquery with k > 1, the result set may contain morethan one partitions Wi. Consider for example thethree data points in Fig. 4(a) and assume we areinterested to compute the mRTOPk(q) for k=2. Querypoint q is in the top-2 result set for both weightingvectors w1 and w3. However, when weighting vectorw2 is considered, with angle between w1 and w3, it isobvious that q no longer belongs to the top-2. Thus, inthis small example, the monochromatic reverse top-kquery would return two partitions Wi.

Monochromatic RTOPk algorithm. Algorithm 1 de-scribes the monochromatic reverse top-k algorithm forthe 2-dimensional case. Data points that are domi-nated3 by q are always ranked after q for any weight-ing vector w, while points that dominate q are rankedbefore q for any weighting vector w. For example inFig. 4(b), p5 is worse (ranked lower) than q, whereasp6 is better (ranked higher) than q for any w. Pointsof the dataset that are neither dominated by nor dom-inate q are ranked higher than q for some weightingvectors and lower than q for other vectors. Thus, ouralgorithm examines4 only such incomparable points{pi} to q (line 5), because they alter the rank of q. Theboundaries of the partitions of mRTOPk are definedby a subset of the weighting vectors wi = wpiq,therefore we keep them in list W ′ (line 7). Then, weidentify the partitions for which q belongs to the top-k, by processing W ′, as explained in the followingexample.

In Fig. 4(b), after the sorting by increasing valueof wi[1] (line 10) the set W ′ is {w1, w2, w3, w4} cor-

3. A point p dominates q (p ≺ q) , if ∀di ∈ D, p[i] ≤ q[i]; and onat least one dimension dj ∈ D, p[j] < q[j].

4. This is similar to the approach in [2], which is used to computea robust layered index.

Algorithm 1 Monochromatic RTOPk Algorithm.

1: Input: S, q2: Output: mRTOPk(q)3: W ′ ← ∅, R← ∅, RES ← ∅4: for (∀pi ∈ S) do5: if (q 6≺ pi and pi 6≺ q) then

6: wi[1]←λpiq

λpiq−1, wi[2]← 1− wi[1]

7: W ′ ←W ′ ∪ {wi}8: end if9: end for

10: sort W ′ based on increasing value of wi[1]11: w0 ← [0, 1], w|W ′|+1 ← [1, 0]12: R← {p : p lies in Hw0

(q)}13: kw ← |R| //number of points in R14: for (∀wi ∈W ′) do15: if (kw ≤ k) then16: RES ← RES ∪ {(wi, wi+1)}17: end if18: if (pi+1 ∈ R) then19: kw ← kw − 120: else21: kw ← kw + 122: end if23: end for24: return RES

responding to the lines p1q, p2q, p3q, p4q respectively.Then, vectors w0 and w5 are added to W ′. For the firstweighting vector w0 all data points that lie in Hw0

(q)are retrieved (line 12). Recall that the rank kw of q withrespect to w0 is determined by the number of pointscontained in Hw0

(q) (line 13). In our example, the setR is {p4, p6, p1} and therefore the rank of q is 4. Therank of q cannot change before w1. If we assume thatk=3, then for the first partition W0=[w0, w1] the rankof q is higher than k and the partition W0 can be safelydiscarded. Then, the next partition is W1 = [w1, w2].Since p1 ∈ R (line 18), this means that the relativeorder of the points p1 and q changes in W1, andnow the rank of q is 3. Therefore, W1 is added tomRTOP3(q) (line 16). Similarly, we can compute therank of q for all Wi. In our example, W1 is the onlypartition that qualifies for the mRTOP3(q) result set.Notice that adjacent partitions can be easily detectedand merged into one partition.

Given a query point q, let I ⊂ S be the set ofincomparable points to q. Then, Algorithm 1 producesat most |I| + 1 partitions. Since adjacent partitionsare merged, in worst case every second partitionwill be in the result set of mRTOPk(q). Thus, themaximum number of partitions in mRTOPk(q) is⌈

|I|+12

⌉

. If all data points are incomparable to q then

|I| = |S|, which leads to an upper bound for thenumber of partitions. Notice that the expected numberof incomparable points is much smaller. For example,assuming uniform data distribution and given that0 ≤ p[i] ≤ 1,∀p ∈ S and 1 ≤ i ≤ 2, the expectednumber of incomparable points |I| is equal to theaggregate area of the upper left quadrant and lowerright quadrant defined by q multiplied with |S|:

6

1 1

1

w W A

W B

W C

W[2]

W[3] W[1]

(a) Partitioning for S1.

W B W C

1 1

1 W[2]

W A

W[3] W[1]

w

(b) Partitioning for S2.

Fig. 5. Solution space for 3-dimensional data.

|I| = |S| − |S| · q[1] · q[2] − |S| · (1 − q[1]) · (1 − q[2])= |S| · (q[1] + q[2] − 2 · q[1] · q[2])

4.2 Higher Dimensional Data

In higher dimensions (d>2), all valid weighting vec-tors of the RTOPk query form a (d-1)-dimensionalhyperplane that contains the points wi[j]=0 ∀j 6= iand wi[j]=1 for j=i and 1 ≤ i ≤ d. A monochro-matic RTOPk query returns the partitions Wi of thehyperplane, for which the query point q is in theTOPk(w),∀w ∈ Wi. In the following, we provide anexample for finding the partitions for d>2.

Let us consider a 3-dimensional dataset S1 con-taining only three points A=[1, 0, 0], B=[0, 1, 0] andC=[0, 0, 1]. We denote as WA, WB and WC the par-titions for which A, B and C are the top-1 data pointrespectively. Similar to the 2-dimensional case, theborders of the partitions are defined by the weightingvectors for which the relative order between twopoints changes. To define the borders of the partitionsWA and WB , we need to examine the locus of weightsw′ for which fw′(A)=fw′(B). From this equation, wederive that w′=[1−c

2 , 1−c2 , c] where c ∈ [0, 1]. The vec-

tors w′ form a line that divides the solution space intotwo partitions.

Furthermore, we seek only the weighting vectorsfor which fw′(A)=fw′(B)<fw′(C), since otherwise Cis the top-1 point. Thus, if we take also into con-sideration that fw′(A) < fw′(C), then an additionalconstraint is formed, namely c > 1

3 . Therefore, theborder between the partitions WA and WB is theline segment defined by the points [1/3, 1/3, 1/3] and[1/2, 1/2, 0]. By repeating the same procedure for theother pairs of points, the result is the partitioningdepicted in Fig. 5(a). Notice that there exists a singleweighting vector w=[1/3, 1/3, 1/3] for which all threedata points have the same score for the dataset S1.

Fig. 5(b) depicts the partitions of the solutionspace for another dataset S2 containing the pointsA=[1/2, 0, 1/2], B=[1/2, 1/2, 0] and C=[0, 1/2, 1/2]. Fordataset S2, in order to detect the border between WA

and WB , only the constraint changes to c < 13 , there-

fore the border between the partitions WA and WB

is defined as the line segment defined by the points[1/3, 1/3, 1/3] and [1, 0, 0]. This discussion shows thatobtaining the partition boundaries in higher dimen-sions is a complicated process that goes far beyond

Algorithm 2 RTA: RTOPk Threshold Algorithm.

1: Input: S, W , q, k2: Output: bRTOPk(q)3: W ′ ← ∅, buffer ← ∅4: τ ←∞5: for (each wi ∈W ) do6: if (fwi

(q) ≤ τ ) then7: buffer ← TOPk(wi)8: if (fwi

(q) ≤ τwi(buffer)) then

9: W ′ ←W ′ ∪ {wi}10: end if11: end if12: τ ← τwi+1

(buffer)13: end for14: return W ′

the task of identifying the weighting vectors for whichthe relative order changes.

Algorithm 1 can be extended for higher dimensions,similarly to the approach in [2] for traditional top-kquery processing. The main difference is that in higherdimensions, in each repetition (line 4), each pair ofpoints define a (d-2)-dimensional hyperplane in thesolution space. The remaining challenge is to definethe boundaries of the partitions. The details of sucha generalization are very interesting and we plan tostudy them further in our future work.

5 B ICHROMATIC RTOPk QUERIES

Definition 3: (Bichromatic Reverse top-k) Given apoint q and a positive number k, as well as twodatasets S and W , where S represents data points andW is a dataset containing different weighting vectors,a weighting vector wi ∈ W belongs to the bichromaticreverse top-k result set (bRTOPk(q)) of q, if and onlyif ∃p ∈ TOPk(wi) such that fwi

(q) ≤ fwi(p).

For a bichromatic reverse top-k query, two datasetsS and W are given, where S contains the datapoints and W the different weighting vectors thatrepresent user preferences. Then, the aim is to findall weighting vectors wi ∈ W such that the querypoint q ∈ TOPk(wi). A brute force (naive) approachis to process a top-k query for each wi ∈ W andtest whether q belongs to TOPk(wi). Obviously, thebrute force approach is prohibitively expensive anddoes not scale with the number of weighting vectorswi in the dataset W which may be high (compara-ble to the size |S| of the dataset S). In the sequel,we present a threshold-based algorithm, called RTA(Reverse top-k Threshold Algorithm), which discardsweighting vectors that cannot contribute to the resultset bRTOPk(q), without evaluating the correspondingtop-k queries.

5.1 Threshold-based Algorithm (RTA)

RTA aims to reduce the number of top-k query eval-uations, based on the observation that top-k queries

7

defined by similar weighting vectors5 return similarresult sets [1]. Hence, RTA exploits already computedtop-k result sets to avoid evaluating weighting vectorsthat cannot be in the reverse top-k result set. There-fore, in each repetition a threshold is set based onthe previously computed top-k result set P . Given aset of points P , we denote as τwi

(P ) ≡ max{fwi(P )}

the maximum of all scoring values fwi(pj), pj ∈ P ,

which means that ∀pj ∈ P : τwi(P ) ≥ fwi

(pj), and∃pj ∈ P : τwi

(P ) = fwi(pj). The maximum value

τwi(P ) corresponds to the worst scoring value for

any point in the set P based on wi and is used asa threshold during the reverse top-k evaluation.

Algorithm 2 formally describes the RTA algorithmfor processing a bichromatic RTOPk query. Initially,RTA computes the top-k result TOPk(wi) for thefirst weighting vector (line 7). Notice that in the firstiteration we cannot avoid evaluating a top-k query,as the threshold τ cannot be set yet. The k datapoints that belong to the result set TOPk(wi) arekept in a main-memory buffer. The score fwi

(q) ofquery point q based on vector wi is computed andcompared against τwi

(buffer) (line 8) and if it is notgreater than τwi

(buffer), then wi is added to the resultset (line 9). Before the next iteration, we take the nextweighting vector (wi+1) and we set the threshold τequal to τwi+1

(buffer) (line 12). Then, the conditionof line 6 is tested, and if the score fwi

(q) is higherthan the threshold τ , then wi can be safely discarded.If wi cannot be discarded, we pose again a top-kquery on dataset S and we update the buffer withthe new result set TOPk(wi). In each iteration, thek points of the previously processed top-k query arekept in the buffer. The algorithm terminates when allweighting vectors have been evaluated or discarded.Notice that the size of the buffer is always bound by k,and queries with small k values are commonly usedin practice. Furthermore, we assume that the buffercontains k points, which always holds if k < |S|.

Theorem 1: (Correctness of the algorithm) RTA alwaysreturns the correct and the complete result set.

Proof: Equivalently, the theorem states that RTAreports a weighting vector w as result, if and only ifit belongs to the result set bRTOPk(q). We prove –by contradiction – that w is never falsely reported asresult and that w is never falsely discarded.

(1) Let w be a weighting vector that is falselyadded to the bRTOPk(q) set, i.e., w /∈ bRTOPk(q)and fw(q) ≤ τw(buffer). Based on line 7 fw(q) ≤τw(TOPk(w)). Thus, ∃p ∈ TOPk(w) such that fw(q) ≤τw(TOPk(w)) = fw(p). Then, by definition w ∈bRTOPk(q), which is a contradiction.

(2) Let w ∈ bRTOPk(q) be a weighting vector thatis falsely discarded. Then, based on the definition ofthe reverse top-k query, ∃p ∈ TOPk(w) such that

5. We address the issue of accessing similar weighting vectors inSection 5.2.

fw(q) ≤ fw(p). Since RTA discarded w, there exists aset of k points pi (1 ≤ i ≤ k) in the buffer that have abetter scoring value than q based on the threshold,i.e., ∀pi: fw(pi) < fw(q) ≤ fw(p). This means thatp /∈ TOPk(w), which leads to a contradiction.

In the worst case, RTA needs to process |W | top-k queries, hence the algorithm degenerates to thebrute force algorithm. However, in the average case,RTA returns the correct result by evaluating muchfewer than |W | top-k queries, which is verified alsoin the experimental evaluation. On the other hand,RTA needs to evaluate at least |bRTOPk(q)| top-kqueries, since no weighting vector wi can be addedwith certainty to the result set without evaluating therespective top-k query.

5.2 Sorted Access to Weighting Vectors

In each repetition, RTA sets a threshold exploitingpreviously computed top-k result sets, in order todiscard weighting vectors that cannot be in the queryresult set. The effectiveness of the threshold dependson the k data objects in the buffer. Top-k queriesdefined by similar weighting vectors return similarresult sets [1]. Thus, if the buffered result set wasobtained by a similar weighting vector w′ with thecurrently processed w, then the probability that thethreshold can discard w is high. As a result, the orderin which the weighting vectors are examined influ-ences the performance of RTA, and it is beneficial toaccess similar weighting vectors in consecutive steps.Consequently, the weighting vectors W are sortedbased on their pairwise similarity.

Given a similarity function sim(wi, wj) between wi

and wj , and an ordering of the weighting vectorse = w1, ..., w|W |, the overall similarity is defined as

sim(e) =∑|W |−1

i=1 sim(wi, wi+1). The goal is to find theoptimal ordering e in terms of similarity, defined ase = argmax∀e(sim(e)), that maximizes the similarityof all consecutive pairs of weighting vectors. In thefollowing, we define the Vector Ordering Problem(VOP) formally.

Definition 4: (Vector Ordering Problem) Given a realnumber c and a set of vectors W with nonnegativecost function sim(wi, wj) associated with each pair ofvectors wi and wj , the problem is whether there existsan ordering of the weighting vectors e = w1, ..., w|W |,

such that∑|W |−1

i=1 sim(wi, wi+1) ≥ c.

Lemma 4: The VOP problem is NP-complete.

Proof: We first show that VOP belongs to NP.Given an instance of VOP and a candidate solution,the verification algorithm checks that the orderingcontains each vector exactly once, sums up the costvalues, and checks whether the sum is at least c. Thisprocess can be done in polynomial time. To provethat VOP is NP-complete, we show that the Traveling

8

Salesman Problem6 (TSP) is polynomial-time reducibleto the sorting problem (TSP ≤P sorting problem). Let〈G(V,E), d, c〉 be an instance of TSP. We construct aninstance of VOP as follows. We form the set of vectorsW by adding a vector wi for each vi ∈ V and definethe cost function sim as sim(wi, wj) = sim(wj , wi) =d(vi, vj). Then, the instance of VOP is 〈W, sim, c〉,which can be created easily in polynomial time. Wenow show that there exists a Hamiltonian cycle withat least cost c for TSP, if and only if there exists anordering with at least cost c for VOP. Suppose thatgraph G is a Hamiltonian cycle represented by thesequence v1, v2, . . . , v|V |, v1 with at least cost c, thenthe vector ordering w1, w2, . . . , w|V | has at least costc, since sim(wi, wj) = d(vi, vj). Conversely, supposethat a vector ordering w1, w2, . . . , w|W | has at leastcost c. Then, the cycle represented by the sequencev1, v2, . . . , v|V |, v1 is a Hamiltonian cycle and has atleast cost c. Thus, we conclude that VOP is NP-complete.

The problem of finding the optimal ordering e interms of similarity is the maximization problem ofVOP. Since VOP is NP-complete, the optimizationproblem is NP-hard. Any algorithm proposed forsolving the TSP problem can be used for finding anapproximate solution of our optimization problem,if we consider a fully connected graph where eachweighting vector corresponds to a vertex and theweights of the edges correspond to the similarity ofthe weighting vectors. More accurately, the algorithmmust solve the non-metric TSP problem, since theweights on graph edges do not necessarily satisfythe triangle inequality. We employ a greedy algo-rithm that is known as nearest neighbor algorithm forTSP [8] to obtain an ordering of the set W with lowcomputational overhead. We select as first weightingvector w1 the most similar vector to the diagonalvector of the space. Then, each time, the most similarweighting vector wi+1 to the previous vector wi isselected.

We employ the cosine similarity as the similarityfunction sim(wi, wj) between two vectors. Notice thatthis sorting of the weighting vectors takes place ina preprocessing phase, since it is independent of thequery point. Thus, W is stored sorted and it is givenas input to RTA.

5.3 RTA Example

Consider a dataset S consisting of the points pi,a dataset W = {w1, w2, w3} with w1 = [0.4, 0.6],w2 = [0.6, 0.4], and w3 = [0.8, 0.2], as well as the querypoint q, depicted in Fig. 6. Let us assume that k=2 andthe first examined weighting vector is w1. Then, RTAevaluates a top-2 query (TOP2(w1)) and retrieves the

6. Given a complete graph G = (V, E), a cost function d(vi, vj),and a nonnegative integer c, check whether G has a Hamiltoniancycle with cost at least c.

1

1

2 3 4 5 6 7 8 9 10

2345678910

x

y

p1

p9

p2

p4

p7

p8

p10

p3

p6

p5

q

Hw1(p1)

query point

lw1(p1)

(a) Query evaluation of w1.

1

1

2 3 4 5 6 7 8 9 10

2345678910

x

y

p1

p9

p2

p4

p7

p8

p10

p3

p6

p5

q

lw3(p1)

lw2(p1)

(b) Processing w2 and w3.

Fig. 6. Example of bichromatic algorithm (RTA).

data points p1 and p2 that are placed in the buffer{p2, p1}. As depicted in Fig. 6(a), points p1 and p2 areenclosed in the query space Hw1

(p1) (depicted as graytriangle). Since q is not enclosed in Hw1

(p1), at leasttwo data points have a better score than q and w1 doesnot belong to the bRTOP2(q). This is detected by RTAin line 6, where the scoring value fwi

(q) is comparedto the threshold.

In the next step (Fig. 6(b)), w2 is examined andthe threshold is set based on the query line lw2

(p1).Notice that the threshold is set equal to the maximumscoring value of points p1 and p2 in the buffer. Since qhas a higher scoring value fw2

(q) than the threshold,the weighting vector w2 is discarded without furtherprocessing. As depicted in Fig. 6(b), Hw2

(p1) containsat least 2 data points (in this example: {p1,p2,p3}), andthis verifies that w2 can be safely discarded.

When the next vector w3 is considered, the thresh-old is set based on point p1, which has the highestscore for w3 among the data points in the buffer.Then, q is enclosed in Hw3

(p1), therefore the resultset TOP2(w3) has to be retrieved, and the buffer nowcontains {p3, p2}. The score value of q is better thanthe score value of p2, which is the top-2 data point forthis query, so w3 is added to the reverse top-2 resultset of q. Then, RTA terminates and returns w3 as theresult of bRTOP2(q).

5.4 Incremental Threshold Refinement

In principle, RTA is independent of the algorithmused for the underlying top-k evaluation. Neverthe-less, if the top-k algorithm is incremental (as in thecase of the branch-and-bound algorithm that usesan R-tree), then RTA can be adapted, so that thethreshold is refined after each retrieved data object.Instead of retrieving the entire top-k result set andupdating the buffer afterwards (line 7), RTA mayretrieve incrementally the k data objects. Each timea data object is retrieved, it is added to the bufferby keeping the k objects with the lowest scores. Thethreshold is updated and RTA tests if the weightingvector wi can be discarded, before retrieving the nextresult. Therefore, fewer than k retrieved data objectsmay suffice to discard wi.

9

1

1

2 3 4 5 6 7 8 9 10

2345678910

x

y

p1

p2

p4

p7

p8

p10

p3

CUi

p5

CLi

Ci

(a) Grid partitioning.

1

1

2 3 4 5 6 7 8 9 10

2345678910

x

y

CiL

q

wz

CiU

(b) Cell example.

Fig. 7. Example of grid-based algorithm.

The incremental refinement of the threshold mayrequire fewer than k retrieved data objects per top-k evaluation to discard a weighting vector. On theother hand, when this occurs, fewer than k points inthe buffer are updated, and the threshold for the nextweighting vector is less accurate. This may cause atop-k evaluation for the next weighting vector, thatcould be avoided if all the k elements were retrieved.We study this effect in our experimental evaluation.

6 MATERIALIZED RTOPK VIEWS

In this section, we present an indexing structure(RTOP -Grid) based on space partitioning, which ma-terializes reverse top-k views for efficient processingof bichromatic RTOPk queries. First, we define the in-dexing structure and present the properties of RTOP-Grid that improve the performance of RTOPk queries.Afterwards, we present the RTOPk algorithm thatuses the RTOP-Grid and the construction algorithmof RTOP-Grid that takes into account the gain incomputational cost during query processing. Finally,we generalize our approach for arbitrary k values anddiscuss updates.

6.1 Definitions and Properties

Let us assume a grid-based space partitioning of thedata space. The grid consists of disjoint data spacepartitions, also called cells (Fig. 7(a)). Each cell Ci

is defined by its lower left corner CLi and upper right

corner CUi . Given a cell Ci and a value k, a reverse

top-k query for each corner CLi and CU

i is evalu-ated and the result set is stored. More particularly,each grid corner is considered as a query point andthe query is evaluated (using Algorithm 2) againstthe dataset S, ignoring the remaining grid corners.The resulting weighting vectors wz are maintainedin a list associated with the corresponding corner,for example for the lower left corner CL

i we defineas LL

i = {wz ∈ bRTOPk(CLi )}. Analogously, LU

i isdefined. Henceforth, we refer to the lists of weightingvectors of a cell as materialized views.

During query processing we exploit the material-ized views of the cells, in order to restrict the number

Algorithm 3 GRTA: Grid-based RTOPk Algorithm.

1: Input: S, q, k2: Output: bRTOPk(q)3: W ′ ← ∅, W ′′ ← ∅, Wcand ← ∅4: Find cell Ci that encloses q5: for (∀wz ∈ LL

i ) do6: if (wz ∈ LU

i ) then7: W ′ ←W ′ ∪ {wz}8: else9: Wcand ←Wcand ∪ {wz}

10: end if11: end for12: W ′′ ← RTA(S,Wcand,q,k)13: return {W ′ ∪W ′′}

of candidate weighting vectors that need to be exam-ined by RTA algorithm. Given a query point q, the cellCi which encloses query point q is determined. Basedon the following theorem the materialized views canbe used for restricting the computational cost of theRTOPk query.

Theorem 2: Given a query point q and a cell Ci thatencloses q, it holds that:

(1) If a weighting vector w ∈ W does not exist inthe materialized view w /∈ LL

i , then w cannot be inthe reverse top-k result set of q: w /∈ bRTOPk(q).

(2) If a weighting vector w ∈ W belongs to thematerialized view w ∈ LU

i , then w is in the reversetop-k result set of q: w ∈ bRTOPk(q).

Proof: It holds that CLi [i] ≤ q[i] ≤ CU

i [i] for 1 ≤ i ≤d. Thus, for any w ∈ W it holds that fw(CL

i ) ≤ fw(q) ≤fw(CU

i ) due to the monotonicity of fw. Therefore, ifw /∈ LL

i then w /∈ bRTOPk(q), whereas if w ∈ LUi then

w ∈ bRTOPk(q).As an example, in Fig. 7(b), for any weighting

vector wz , the query space Hwz(CU

i ) contains thequery space Hwz

(q), which in turn contains the queryspace Hwz

(CLi ). If wz /∈ LL

i , then the query spaceHwz

(CLi ) contains more than k data points, which

means that Hwz(q) contains also more than k data

points (q /∈ TOPk(wz)). On the other hand, if wz ∈ LUi

then fewer than k data points exist in the query spaceHwz

(CUi ). Therefore, since q is enclosed in Ci, then it

is also in the top-k result, independently of q’s exactposition in the cell. Notice that a weighting vector wz

that belongs to LUi , also belongs to LL

i .Only for weighting vectors wz that are in LL

i butnot in LU

i we need to examine if q belongs to theTOPk(wz) result set. Essentially, this restricts the in-put of Algorithm 2 to weighting vectors only from theset LL

i − LUi , rather than W .

6.2 Grid-based RTOP k Algorithm (GRTA)

Algorithm 3 formally describes the evaluation ofan RTOPk query using the grid-based materializedviews. Initially, the cell Ci that encloses q is deter-mined (line 4). Then, each weighting vector wz ∈ LL

i

is further examined (line 5). If wz belongs also to LUi

10

(line 6), then based on Theorem 2 we are certain thatwz belongs to the bRTOPk(q) result set and wz isadded to list W ′ (line 7). If wz does not belong toLU

i , then wz is added (line 9) to the set of candidateweighting vectors Wcand that need to be evaluated.Finally, we invoke Algorithm 2 on the set of candidateweighting vectors Wcand (line 12) and some of themare returned as results denoted as W ′′. The weightingvectors that belong to the union of W ′ and W ′′

constitute the results of the GRTA algorithm (line 13).An important improvement of the grid-based ma-

terialization compared to the RTA algorithm is thatsome weighting vectors are added to the result setwithout evaluating the top-k query. Furthermore, thenumber of weighting vectors that need to be ex-amined in order to retrieve the RTOPk result set isrestricted, since Algorithm 2 takes as input a limitedset of weighting vectors Wcand, instead of the entireset W . In particular, the upper bound of top-k eval-uations for different weighting vectors is |LL

i | − |LUi |.

Of course, RTA reduces even more this number, bydiscarding weighting vectors based on already com-puted results. The exact savings in terms of discardedweighting vectors also depend on the constructionalgorithm and the quality of the resulting grid, as willbe shown presently.

6.3 RTOP-Grid Construction

In this section, we discuss the construction algorithmof RTOP-Grid. In our approach, the grid-based spacepartitioning occurs recursively, starting by a single cellthat covers the entire universe. We take into consider-ation three different subproblems. First, we developa cost-based heuristic for deciding which cell Ci tosplit. Secondly, we accomplish efficient computationof the views LL

i and LUi , by using a results sharing

approach. Finally, we propose different strategies forestablishing the stopping condition of the cell divisionprocess.

Given a cell Ci and a query point q enclosed in Ci,the performance of RTOPk query depends mainly onthe number of evaluated top-k queries, which in turndepends on the number of weighting vectors in theviews LL

i and LUi . Therefore, it is very important that

the splitting strategy of the construction algorithmsplits first the most costly cells, i.e., the cells that maylead to many top-k evaluations. We define the costfor a cell Ci as the probability that a query point isenclosed in a cell multiplied by the number of top-kquery evaluations necessary for processing the queryin Ci. Assume that f(q[1], q[2], ..., q[d]) ≡ f(q) denotesthe density function describing the distribution of thed variables corresponding to the dimensions of thequery points. Then, the expected cost of a cell Ci canbe estimated as:

COSTCi= (|LL

i | − |LUi |)

∫

Ci

f(q) (1)

Algorithm 4 Construction of RTOP-Grid.

1: Input: S, W , k , Limit2: Output: RTOP-Grid3: Create cell C0 that covers the universe4: LL

0 ← RTA(S,W ,CL0 ,k)

5: LU0 ← RTA(S,W ,CU

0 ,k)6: RES ← {C0}7: cntCells← 18: while (cntCells < Limit) do9: Find cell Ci with maximum COSTCi

10: Split Ci into C1 and C2 based on dj

11: LL1 ← LL

i

12: LU1 ← GRTA(S,CU

1 ,k)13: LL

2 ← GRTA(S,CL2 ,k)

14: LU2 ← LU

i

15: RES ← RES − {Ci}16: RES ← RES ∪ {C1, C2}17: cntCells← cntCells + 118: end while19: return RES

In the case of uniform query distribution, the integralof Equation 1 can be replaced by the fraction of thevolume of the space D covered by the cell (normalized

volume V (Ci)VD

).Given a RTOP-Grid index, we define the average

number of top-k query evaluations that are necessaryfor processing a reverse top-k query as a qualitymeasure of RTOP-Grid, which can be expressed as thesum of the costs of all cells:

COSTRTOP−Grid =∑

∀i

COSTCi(2)

The cost function implies that the cost of a par-ticular cell adds up to the total cost of the grid,only if a query point is actually enclosed in the cell.Equation 2 is the average cost of processing a reversetop-k query, in terms of top-k evaluations for a givenRTOP-Grid, because it contains the probability that aquery is enclosed in a cell. Furthermore, the estimatedcost is an upper bound of the actual cost, since RTAneeds even fewer top-k evaluations than |LL

i | − |LUi |.

The splitting employed in the RTOP-Grid constructionalgorithm aims at minimizing the aforementioned costfunction and picks in each iteration the cell with themaximum COSTCi

value.Algorithm 4 describes the construction of RTOP-

Grid. Assuming initially a single cell C0 covering theentire universe (line 3), the algorithm starts by com-puting the materialized views of the lower and uppercorner of the universe (lines 4,5). In order to processthe RTOPk query for each cell’s corners efficiently,the RTA algorithm is employed. In each iteration, thealgorithm picks a cell Ci to be split, which is thecell Ci with the maximum COSTCi

, according to oursplitting strategy (line 9). Then, two new cells C1 andC2 are created (line 10) by selecting a dimension in around robin fashion, which is used to divide the cellin two parts. Consequently, the materialized views of

11

the new cells C1 and C2 are computed. Our algorithmemploys result sharing in two ways. First, it is obviousthat LL

1 and LU2 equals to LL

i and LUi respectively

(lines 11,14), and these materialized views do not haveto be recomputed. Secondly, whenever a reverse top-k query for each cell’s corners needs to be computed,GRTA is employed (lines 12,13) on the currently con-structed RTOP-Grid. Therefore, the algorithm takesinto account the views of the existing cells to restrictthe weighting vectors that need to be examined. Then,cell Ci is removed from the RTOP-Grid, whereas cellsC1 and C2 that cover the removed cell are added(lines 15,16). The algorithm continues to iterate, untilthe stopping condition that ceases splitting of cells issatisfied (line 8).

As regards the stopping condition, two differentstrategies are used, each controlling the cost of adifferent parameter, namely storage requirements andquery processing performance. Hence, two differentstrategies are employed:

• Space-bounded: In order to restrict the constructionand storage cost, the algorithm stops when aspecific number of grid cells (given as input) arecreated. Algorithm 4 describes this strategy (line8).

• Guaranteed cost: This strategy focuses on queryprocessing cost, rather than construction cost, andaims at setting a bound on the average numberof required top-k evaluations. Cells are split aslong as the quality of the RTOP-Grid, has notreached the bound (given as input). The qualityis measured by means of Equation 2. Therefore,the condition of Algorithm 4 (line 8) is modifiedas follows: COSTRTOP−Grid>Limit.

In our experimental evaluation, we also examine astraightforward approach, namely UNIFORM, wherethe algorithm decides to split the cell that has thelargest volume, without using the cost function. Thestopping condition follows the space-bounded strat-egy, i.e., splitting stops when a specified number ofcells are created.

6.4 Supporting Arbitrary k Values

In this section, we generalize our approach to supportreverse top-k queries for arbitrary values of k, usinga common RTOP-Grid. Given an upper limit Kmax,the RTOP-Grid is constructed for Kmax and additionalinformation is stored that enables processing queriesfor any k value (k ≤ Kmax). For each weighting vectorwz , the rank of the cell corner, i.e., the minimumk for which the corner is in the top-k result set ofwz , is additionally maintained. Thus, the material-ized view can be described as LL

i = {(wz, kLz )} and

LUi = {(wz, k

Uz )}.

Algorithm 3 can be adjusted to process reversetop-k queries over a grid constructed for arbitraryk ≤ Kmax. First, the cell Ci that encloses q is

determined. Then, the weighting vectors that arecontained in LL

i are examined, while weightingvectors that are not in LL

i cannot contribute to thereverse top-k result set of q. For any wz ∈ LL

i , thefollowing cases are distinguished (the following codereplaces lines 6-10 of Algorithm 3):

IF (kLz ≤ k) THEN

IF (wz ∈ LUi and kU

z ≤ k)

THEN

W ′ ←W ′ ∪ {wz}

ELSE

Wcand ←Wcand ∪ {wz}

6.5 Updates

Updates that occur either in W or S affect the ma-terialized RTOPk views, therefore they should besupported efficiently. In case of insertion of a newweighting vector wins, we need to progressively ex-amine the corners of the grid, starting from the originof the data space. If a corner CL

i (CUi ) does not qualify

as top-k object for wins, then we can safely discard allcorners dominated by CL

i (CUi ). Deletion of an existing

weighting vector wdel is simple, as it requires removalof wdel from the lists of any corner of the grid.

Insertion of a data point pins is more costly, sinceonly grid corners that dominate pins are discarded.For the remaining corners, we cannot avoid com-puting the reverse top-k query. However, GRTA canbe used and only weighting vectors that belong tothe materialized views of the cell corner have to beevaluated, since no weighting vectors can be added,but only some of them may be removed from thematerialized view. Similarly a data point pdel thatis removed from the dataset probably influences allnon-dominating cell corners, therefore we need torecompute the materialized views for them, since newweighting vectors may have to be added.

7 EXPERIMENTAL EVALUATION

In this section, we present an extensive experimentalevaluation of reverse top-k queries. All algorithms areimplemented in Java and the experiments run on a3GHz Dual Core AMD processor equipped with 2GBRAM. The block size is 8KB.

As far as the dataset S is concerned, both realand synthetic data collections, namely uniform (UN),correlated (CO) and anticorrelated (AC), are used. Forthe uniform dataset, all attribute values are gener-ated independently using a uniform distribution. Thecorrelated and anticorrelated datasets are generatedas described in [9]. We also use two real datasets:NBA (17265 tuples, d=5) and HOUSE (127930 tuples,d=6) [3]. For the dataset W , two different data dis-tributions are examined, namely uniform (UN) andclustered (CL). For the clustered dataset W , first CW

12

10

100

1000

10000

100000

2 3 4 5

Tim

e (m

sec)

Dimensionality (d)

UNACCO

(a) Average time.

1

10

100

1000

10000

100000

1e+006

1e+007

2 3 4 5

I/Os

Dimensionality (d)

UNACCO

(b) I/Os.

1

10

100

1000

10000

100000

1e+006

2 3 4 5

#Top

-k E

valu

atio

ns

Dimensionality (d)

UNACCO

(c) Number of top-k evaluations.

Fig. 8. Performance of RTA for varying d [naive (outer bar) vs. RTA (inner bar)].

10

100

1000

10000

100000

2 3 4 5

Tim

e (m

sec)

Dimensionality (d)

UNACCO

(a) Average time.

1

10

100

1000

10000

100000

1e+006

1e+007

2 3 4 5

I/Os

Dimensionality (d)

UNACCO

(b) I/Os.

1

10

100

1000

10000

100000

1e+006

2 3 4 5

#Top

-k E

valu

atio

ns

Dimensionality (d)

UNACCO

(c) Number of top-k evaluations.

Fig. 9. Performance of RTA for varying d for k-skyband queries [naive (outer bar) vs. RTA (inner bar)].

cluster centroids that belong to the (d-1)-dimensionalhyperplane defined by

∑

wi = 1 are selected ran-domly. Then, each coordinate is generated on the(d-1)-dimensional hyperplane by following a normaldistribution on each axis with variance σ2

W , and amean equal to the corresponding coordinate of thecentroid.

We evaluate the performance of RTA against analternative technique (referred as naive) that evaluatesa top-k query for each weight in the dataset W .In particular, both for RTA and naive, the datasetS is indexed by an R-tree and top-k processing isperformed using a state-of-the-art branch-and-boundalgorithm. Our metrics include: a) the time (wall-clock time), b) the I/Os, and c) the number of top-kevaluations required by each algorithm. We presentaverage values over the 1000 queries in all cases.Notice that we do not measure the I/Os that occurby reading W , since this cost is the same for everymethod.

7.1 Performance Evaluation of RTA

In Fig. 8, we study the behavior of RTA for increasingdimensionality d, for various distributions (UN, AC,CO) of dataset S and uniform weights W . We use|S|=10K, |W |=10K, top-k=10 and 1000 random queriesthat follow the data distribution. Notice that the y-axisis in logarithmic scale. In the bar charts, each of thethree bars (for a specific dimensionality) representsa dataset: UN, AC, and CO respectively. The totallength of the bar represents the performance of naive,while the inner bar depicts the performance of RTA.Regarding time, RTA is 2 orders of magnitude better

than naive, in all examined data distributions. Interms of I/Os, again RTA outperforms naive by 1to 3 orders of magnitude, while larger savings areobtained for datasets UN and CO. The reason behindRTA’s superiority is clearly demonstrated in Fig. 8(c),where the number of top-k evaluations necessary forcomputing an RTOPk query is shown. The thresholdemployed by RTA reduces significantly the numberof top-k evaluations, saving around 1.5 to 3 ordersof magnitude compared to naive. Notice that naiverequires |W | (=10K) top-k evaluations in all cases.

An interesting observation is that only a smallpercentage (around 2%) of the queries actually returnnon-empty result sets. Since the queries are generatedfollowing the data distribution, many queries are notin the top-k result for any weighting vector. Reversetop-k queries with empty result sets are also very in-formative for a product manufacturer, since they indi-cate that the particular product is not popular for anycustomer, compared to their competitors’ products.On the other hand, RTA processes RTOPk queriesthat have a small or empty result set efficiently byoften requiring only one top-k evaluation, because thethreshold employed eliminates candidate weightingvectors that do not belong to the result set. In contrast,naive does not have this ability and always com-putes |W | top-k queries. In order to generate a morechallenging query workload for RTA, we increase theprobability that a query point belongs to a top-kresult, by selecting random query points from the k-skyband7 of the dataset. Obviously, these query points

7. A k-skyband query returns the set of points which are domi-nated by at most k-1 other points.

13

are more likely to produce non-empty reverse top-kresults. This query workload corresponds to queriesabout products that seem popular to customers, andmanufacturers are expected to pose such queries withhigh probability.

Fig. 9 depicts the results obtained by using k-skyband queries for the same experimental setupdepicted in Fig. 8. Although we witness a smalldeterioration in the results of RTA, our algorithm con-sistently outperforms naive by 1 to 2 orders of mag-nitude. Some interesting observations can be madeby studying Fig. 9(c). First, we notice that the cor-related dataset requires more top-k evaluations. Thereason is that the k-skyband of a correlated datasetcontains few points that are close to the origin of thedata space, and therefore such points are in the top-k for many weighting vectors. Second, we observea decreasing tendency as dimensionality increases,which seems counterintuitive at first. However, this isbecause again the cardinality of bRTOPk(q) decreasesas the dimensionality increases. For the rest of ourexperiments, we use k-skyband queries and we do notshow the results of naive, as it performs consistentlyworse than RTA by few orders of magnitude.

Thereafter, we perform a scalability study of RTA inFig. 10. We use as metric the number of top-k evalua-tions, as it is the dominant factor for the performanceof RTA. First, we increase the cardinality of W usingdifferent data distributions of S (Fig. 10(a)). We fix theremaining parameters to |S|=10K, d=5 and top-k=10.We observe that RTA is highly efficient, especiallyfor the costly CO dataset. For instance, for |W |=5K,RTA needs on average 544 top-k evaluations, whilethe average mandatory cost is 459 (this is the numberof queries that cannot be avoided, also equal to theaverage size of the result set). Thus, RTA needs only544 (10.88%) out of 5000 query evaluations (100%),which is just marginally more than the mandatory 459(9.18%), and therefore RTA saves 89.12% of the cost.

In Fig. 10(b), we set |W |=10K and gradually increasethe cardinality of S to 100K. For the CO dataset, weobserve that fewer top-k evaluations are necessarywith increasing |S|. The main reason is that the dataspace has more data points, thus becomes denser,and k-skyband queries lead to result sets with fewerweighting vectors, hence smaller processing cost. InFig. 10(c), we use |S|=10K and |W |=10K, and studyhow the value of k affects the performance of RTA.It is clear that RTA is highly efficient for UN andAC datasets, and its performance is affected onlyfor CO. Higher values of k increase the probabilitythat a query point belongs to top-k for some weight-ing vector, and therefore the average cardinality ofbRTOPk(q) increases, leading to more top-k evalua-tions.

We also study the performance of RTA for a clus-tered dataset W , using CW =5 clusters of weightingvectors. A clustered dataset W simulates the case

where user preferences are not independent, but thereexist some groups of common user preferences. Inthis experiment, we use the default setup and varythe dimensionality. Thus, Fig. 11(a) is analogous andalso comparable to Fig. 9(c) which was for a uniformdataset W . The results show that, in the case ofclustered dataset W , RTA performs better than foruniform W for all data distributions, neverthelessthe general trends remain the same as dimensionalityincreases. In Fig. 11(b), we assess RTA using the NBAdataset. The performance of RTA is in accordance withthe case of synthetic data. We try both a uniform andclustered dataset W and the results show again thatfewer top-k evaluations are required for the clustereddataset W . In Fig. 11(c), a similar experiment is con-ducted using the HOUSE dataset.

7.2 Performance Evaluation of RTOP-Grid

In the sequel, we evaluate the performance of RTOP-Grid in Fig. 12. Unless mentioned explicitly, we use|S|=10K, |W |=10K, d=5 and top-k=10. First, we pro-vide a comparison of the RTOP-Grid space-boundedstrategy to the UNIFORM approach and to RTA(Fig. 12(a)), for increasing number of cells. RTOP-Grid performs consistently better than UNIFORM,demonstrating the advantages of using the cost-basedsplitting strategy, instead of splitting the cell withthe maximum volume. RTOP-Grid also provides animprovement to RTA, in terms of the required numberof top-k evaluations as expected, and in this setupit achieves a reduction of top-k evaluations between18.5% (100 cells) and 26.3% (1000 cells).

In Fig. 12(b), we test the RTOP-Grid guaranteedcost strategy versus RTA, with increasing cost bound,for top-k={10, 20}. The chart shows that RTOP-Gridreduces the number of top-k evaluations comparedto RTA by 30%, when the cost bound is set to 100.As expected, when the bound imposed on cost issmaller, RTOP-Grid improves RTA more. Notice thatin most cases the actual number of top-k evaluationsis smaller than the bound set on average cost. Thisis because the average cost is estimated based on thenumber of weighting vectors in the views, and it doesnot take into account the additional savings in top-kquery evaluations caused by the threshold mechanismof RTA, employed also by RTOP-Grid. In Fig. 12(c),we show the number of cells created by RTOP-Gridfor the same experiment. Clearly, the number of cellsincreases rapidly when the cost bound is set too low.However, similar improvements can be obtained byrelaxing the cost bound, i.e., notice that setting thebound to 200 achieves similar performance to thebound of 100, using much fewer cells. Furthermore,we study the scalability of RTOP-Grid for varying val-ues of |W |, |S| and top-k. Fig. 13(a) shows the resultsobtained by increasing |W |. RTOP-Grid consistentlyoutperforms UNIFORM and improves RTA. Then, in

14

0

200

400

600

800

1000

1200

5000 10000 15000

#Top

-k E

valu

atio

ns

Cardinality |W|

RTA-UNRTA-ACRTA-CO

(a) Scalability with |W |.

0 100 200 300 400 500 600 700 800 900

1000

10000 50000 100000

#Top

-k E

valu

atio

ns

Cardinality |S|

RTA-UNRTA-ACRTA-CO

(b) Scalability with |S|.

0

500

1000

1500

2000

10 20 30 40 50

#Top

-k E

valu

atio

ns

top-k

RTA-UNRTA-ACRTA-CO

(c) Scalability with top-k.

Fig. 10. Scalability study of RTA.

0

500

1000

1500

2000

2500

3000

2 3 4 5

#Top

-k E

valu

atio

ns

Dimensionality (d)

RTA-UNRTA-ACRTA-CO

(a) Clustered dataset W .

0

100

200

300

400

500

600

10 20 30 40 50

#Top

-k E

valu

atio

ns

top-k

RTA/UNRTA/CL

(b) Real dataset (NBA).

0

100

200

300

400

500

600

700

800

10 20 30 40 50

#Top

-k E

valu

atio

ns

top-k

RTA/UNRTA/CL

(c) Real dataset (HOUSE).

Fig. 11. Performance of RTA for clustered weights W and for real data (NBA and HOUSE).

0

50

100

150

200

100 500 1000

#Top

-k E

valu

atio

ns

Number of Cells

RTOP-GridUNIFORM

RTA

(a) Space-bounded strategy.

0

50

100

150

200

250

300

100 200 300 400 500

# T

op-k

Eva

luat

ions

Cost bound

RTOP-Grid, top-10RTA, top-10

RTOP-Grid, top-20RTA, top-20

(b) Guaranteed cost strategy.

0

2000

4000

6000

8000

10000

100 200 300 400 500

Num

ber

of C

onst

ruct

ed C

ells

Cost bound

top-10top-20

(c) Number of constructed cells.

Fig. 12. Performance evaluation of the strategies of RTOP-Grid.

Fig. 13(b), we set |W |=10K and increase |S|. Onceagain, the gain of RTOP-Grid over RTA is sustainedin all setups. Finally, in Fig. 13(c), the chart showshow the cost is affected by increasing k. RTOP-Gridperforms better than RTA and UNIFORM for all kvalues and the benefit increases with k.

7.3 Monochromatic vs. Bichromatic Algorithm

In Fig. 14, we set d=2 and study the comparative per-formance of RTA against the monochromatic RTOPkalgorithm. To this end, we apply the monochromaticalgorithm to identify the partitions of W that belongto the solution set, and then retrieve the subset ofweighting vectors W that belong to these partitions.The data distribution for both S and W is uniform,denoted as UN/UN. The default values used are|S|=10K, |W |=10K, and top-k=10.

In Fig. 14(a), we measure the time required byeach algorithm employing a logarithmic scale. Weobserve that RTA scales better with |S|, compared tothe monochromatic algorithm. In Fig. 14(b), we vary

the cardinality of W , from 5K to 15K vectors. It turnsout that the monochromatic reverse top-k algorithmscales better with |W |, because it is immune to theactual cardinality of W , as it only needs to identifythe partitions of the space that provide solutions tothe query. The number of weighting vectors doesnot affect significantly the time required to identifythe partitions. However, RTA needs to examine (andpotentially process) more top-k queries as the cardi-nality of W increases, therefore its total time increases.Similarly, in Fig. 14(c), RTA requires more time tocompute the result for increasing values of top-k.Again, the monochromatic reverse top-k algorithm ispractically unaffected by the increased values of k.

All in all, RTA is more sensitive to higher valuesof |W | and top-k, thus the monochromatic RTOPk al-gorithm scales better. In contrast, the monochromaticalgorithm is sensitive to the cardinality of S, thereforeRTA performs better for increased values of |S|.

15

50

100

150

200

5000 10000 15000

#Top

-k E

valu

atio

ns

Cardinality |W|

RTOP-GridUNIFORM

RTA

(a) Scalability with |W |.

20 40 60 80

100 120 140 160 180 200

10000 50000 100000

#Top

-k E

valu

atio

ns

Cardinality |S|

RTOP-GridUNIFORM

RTA

(b) Scalability with |S|.

0

100

200

300

400

500

600

700

10 20 30 40 50

#Top

-k E

valu

atio

ns

top-k

RTOP-GridUNIFORM

RTA

(c) Scalability with top-k.

Fig. 13. Scalability study of RTOP-Grid for the space-bounded strategy.

1

10

100

1000

10000

100000

10000 50000 100000

Tim

e (m

sec)

Cardinality |S|

MONO-UN/UNRTA-UN/UN

(a) Scalability with |S|.

0

200

400

600

800

1000

1200

1400

5000 10000 15000

Tim

e (m

sec)

Cardinality |W|

MONO-UN/UNRTA-UN/UN

(b) Scalability with |W |.

0

500

1000

1500

2000

2500

3000

10 20 30 40 50

Tim

e (m

sec)

top-k

MONO-UN/UNRTA-UN/UN

(c) Scalability with top-k.

Fig. 14. Performance of monochromatic algorithm vs. RTA.

2

4

6

8

10

12

2 3 4 5

eval

uate

d k

Dimensionality (d)

RTAINC

(a) Evaluated value of k.

1

20000

40000

60000

80000

2 3 4 5

#Top

-k E

valu

atio

ns

Dimensionality (d)

RTAINC

(b) Number of top-k evaluations.

Fig. 15. Incremental threshold refinement vs. RTA.

1

10

100

1000

10000

100000

2 3 4 5

#Top

-k E

valu

atio

ns

Dimensionality (d)

RTA-NoSort/UNRTA-Simple/UN

RTA/UN

Fig. 16. Effect of sorting W .

7.4 RTA with Incremental Threshold Refinement

In the next experiment (Fig. 15), we study the vari-ant of RTA algorithm that incrementally refines thethreshold during each top-k evaluation, as discussedin Section 5.4. We denote this variant of RTA as INC.We use the default setup of uniform data distributionfor S and W , |S|=10K, |W |=10K, top-k=10 and wevary the dimensionality from 2 to 5. In Fig. 15(a),the average value of k used for the top-k queries isshown. RTA always issues top-k queries with k=10.In contrast, INC results in retrieving in each top-kevaluation significantly fewer objects than k. On theother hand, this leads to an increased number of top-k query evaluations performed by INC (Fig. 15(b)).By retrieving fewer than k data objects, the bufferis partially updated, leading to an inaccurate thresh-old, which in turn triggers more top-k evaluations.Concluding, INC requires a higher number of top-kquery evaluations, however retrieving fewer than kdata objects on average.

7.5 Effect of Sorted Weighting Vectors

In Fig. 16, we examine the improvement of the per-formance of RTA caused by the sorting of W basedon pairwise similarity. We compare RTA against aversion that does not employ sorting (RTA-NoSort)and accesses the vectors in a random order. In ad-dition, we test the performance of sorting based onsimilarity to a predetermined vector (RTA-Simple),namely the diagonal vector of the space. We evaluateall approaches with weighting vectors that followa uniform data distribution. The results show thatdepending on the dimensionality RTA requires upto one order of magnitude fewer top-k evaluationsthan RTA-NoSort. Furthermore, the performance ofRTA using pairwise similarity is clearly much betterthan RTA-Simple, while the latter is only slightlybetter than RTA-NoSort. This experiment verifies thatour proposed sorting based on pairwise similarityis appropriate for the RTA algorithm. Nevertheless,all variants perform much better than naive, whichevaluates |W |=10K top-k queries.

16

8 RELATED WORK

As reverse top-k queries are inherently related totop-k query processing, we summarize some repre-sentative work here. One family of algorithms arethose based on preprocessing techniques. Onion [7]precomputes and stores the convex hulls of datapoints in layers. Then, the evaluation of a linear top-k query is accomplished by processing the layersinwards, starting from the outmost hull. Prefer [1]uses materialized views of top-k result sets, accord-ing to arbitrary scoring functions. Onion and Pre-fer are mostly appropriate for static data, due tothe high cost of preprocessing. Efficient maintenanceof materialized views for top-k queries is discussedin [10]. The robust index [2] is a sequential indexingapproach that improves the performance of Onion [7]and Prefer [1]. The main idea is that a tuple shouldbe placed at the deepest layer possible, to reducethe probability of accessing it at query processingtime, without compromising the correctness of theresult. Later, in [11], the dominant graph is proposedas a structure that captures dominance relationshipsbetween points. Another family of algorithms focuseson computing the top-k queries over multiple sources,where each source provides a ranking of a subset ofattributes only. Fagin et al. [12] introduce TA and NRAalgorithms. Variations of them have been proposedleading to various threshold-based algorithms [13],[14], [15], [16].

Reverse nearest neighbor (RNN) queries were orig-inally proposed in [4]. An RNN query finds theset of points that have the query point as theirnearest neighbor. Recently, reverse furthest neighborqueries [17] are introduced, that are similar to RNNqueries. The reverse skyline query [5], [6] identifiescustomers that would be interested in a productbased on the dominance of the competitors products.DADA [18] aims to help manufactures position theirproducts in the market, based on three types of dom-inance relationship analysis queries. Creating com-petitive products has been recently studied in [19].Nevertheless in these approaches, user preferencesare expressed as data points that represent preferableproducts, whereas reverse top-k queries examine userpreferences in terms of weighting vectors. Miah etal. [20] study a different problem, again from theperspective of manufacturers. The authors proposean algorithm that selects the subset of attributes thatincreases the visibility of a new product. Finding themost influential products with reverse top-k querieshas been studied in [21].

9 CONCLUSIONS

In this paper, we introduce the reverse top-k querywhich retrieves all weighting vectors for which thequery point belongs to the top-k result set. The pro-posed query type is important for market analysis

and for estimating the impact of a product based onthe user preferences and the competitors products. Westudy two versions of reverse top-k queries, namelymonochromatic and bichromatic. For the monochro-matic reverse top-k query only a dataset of productsis given, while for the bichromatic reverse top-k aset of weighting vectors is also available. The exper-imental evaluation demonstrates the efficiency of theproposed algorithms.

REFERENCES

[1] V. Hristidis, N. Koudas, and Y. Papakonstantinou, “Prefer: Asystem for the efficient execution of multi-parametric rankedqueries,” in SIGMOD, 2001, pp. 259–270.

[2] D. Xin, C. Chen, and J. Han, “Towards robust indexing forranked queries,” in VLDB, 2006, pp. 235–246.

[3] A. Vlachou, C. Doulkeridis, Y. Kotidis, and K. Nørvag, “Re-verse top-k queries,” in ICDE, 2010, pp. 365–376.

[4] F. Korn and S. Muthukrishnan, “Influence sets based onreverse nearest neighbor queries,” in SIGMOD, 2000, pp. 201–212.

[5] E. Dellis and B. Seeger, “Efficient computation of reverseskyline queries,” in VLDB, 2007, pp. 291–302.

[6] X. Lian and L. Chen, “Monochromatic and bichromatic reverseskyline search over uncertain databases,” in SIGMOD, 2008,pp. 213–226.

[7] Y.-C. Chang, L. D. Bergman, V. Castelli, C.-S. Li, M.-L. Lo,and J. R. Smith, “The onion technique: Indexing for linearoptimization queries,” in SIGMOD, 2000, pp. 391–402.

[8] D. J. Rosenkrantz, R. E. Stearns, and P. M. Lewis II, “An anal-ysis of several heuristics for the traveling salesman problem,”SIAM Journal on Computing, vol. 6, no. 3, pp. 563–581, 1977.

[9] S. Borzsonyi, D. Kossmann, and K. Stocker, “The skylineoperator.” in ICDE, 2001, pp. 421–430.

[10] K. Yi, H. Yu, J. Yang, G. Xia, and Y. Chen, “Efficient mainte-nance of materialized top-k views,” in ICDE, 2003, pp. 189–200.

[11] L. Zou and L. Chen, “Dominant graph: An efficient indexingstructure to answer top-k queries,” in ICDE, 2008, pp. 536–545.

[12] R. Fagin, A. Lotem, and M. Naor, “Optimal aggregation algo-rithms for middleware.” in PODS, 2001, pp. 102–113.

[13] R. Akbarinia, E. Pacitti, and P. Valduriez, “Best position algo-rithms for top-k queries,” in VLDB, 2007, pp. 495–506.

[14] S. Chaudhuri and L. Gravano, “Evaluating top-k selectionqueries.” in VLDB, 1999, pp. 397–410.

[15] U. Guntzer, W.-T. Balke, and W. Kießling, “Optimizing multi-feature queries for image databases.” in VLDB, 2000, pp. 419–428.

[16] A. Marian, N. Bruno, and L. Gravano, “Evaluating top-kqueries over web-accessible databases.” ACM Transactions onDatabase Systems, vol. 29, no. 2, pp. 319–362, 2004.

[17] B. Yao, F. Li, and P. Kumar, “Reverse furthest neighbors inspatial databases,” in ICDE, 2009.

[18] C. Li, B. C. Ooi, A. K. H. Tung, and S. Wang, “Dada: a datacube for dominant relationship analysis,” in SIGMOD, 2006,pp. 659–670.

[19] Q. Wan, R. C.-W. Wong, I. F. Ilyas, M. T. Ozsu, and Y. Peng,“Creating competitive products,” PVLDB, vol. 2, no. 1, pp.898–909, 2009.

[20] M. Miah, G. Das, V. Hristidis, and H. Mannila, “Standing outin a crowd: Selecting attributes for maximum visibility,” inICDE, 2008, pp. 356–365.

[21] A. Vlachou, C. Doulkeridis, K. Nørvag, and Y. Kotidis, “Iden-tifying the Most Influential Data Objects with Reverse top-kqueries,” in PVLDB, vol. 3, no. 1, pp. 364–372, 2010.