In this paper, we present algorithms and data structures for the top-k nearest neighbor searching where the input points are exact and the query point is uncertain under the L1 distance metric in the plane. The uncertain query point is represented by a discrete probability density function, and the goal is to return the top-k expected nearest neighbors, which have the smallest expected distances to the query point. Given a set of n exact points in the plane, we build an O(n log n log log n)-size data structure in O(n log n log log n) time, such that for any uncertain query point with m possible locations and any integer k with 1 k n, the top-k expected nearest neighbors can be found in O(mlogm + (k+m)log^2 n) time. Even for the special case where k = 1, our result is better than the previously best method (in PODS 2012), which requires O(n log^2 n) preprocessing time, O(n log^2 n) space, and O(m^2 log^3 n) query time. In addition, for the one-dimensional version of this problem, our approach can build an O(n)-size data structure in O(n log n) time that can support O(min mk,mlog m + k + log n) time queries and the query time can be reduced to O(k+m+log n) time if the locations of Q are given sorted. In fact, the problem is equivalent to the aggregate or group nearest neighbor searching with the weighted SUM as the aggregate distance function operator.
When the input points are exact and the query point is uncertain, the ENN is the same as the weighted version of the (ANN), which is a generalization of the ANN. Only heuristics are known for answering ANN queries @cite_22 @cite_28 @cite_2 @cite_11 @cite_6 @cite_23 @cite_7 . The best known heuristic method for exact (weighted) ANN queries is based on R-tree @cite_6 , and Li al @cite_28 gave a data structure with 3-approximation query performance for the ANN. Agarwal @cite_17 gave a data structure with a polynomial-time approximation scheme for the ENN queries under the Euclidean distance metric, which also works for the ANN queries.
@cite_22 @cite_7 @cite_28 @cite_17 @cite_6 @cite_23 @cite_2 @cite_11
2136046112 2624483937 2885633361 2079168081
Given two spatial datasets P (e.g., facilities) and Q (queries), an aggregate nearest neighbor (ANN) query retrieves the point(s) of P with the smallest aggregate distance(s) to points in Q. Assuming, for example, n users at locations q 1 ,…q n , an ANN query outputs the facility p ∈ P that minimizes the sum of distances vpq i v for 1 ≤ i ≤ n that the users have to travel in order to meet there. Similarly, another ANN query may report the point p ∈ P that minimizes the maximum distance that any user has to travel, or the minimum distance from some user to his her closest facility. If Q fits in memory and P is indexed by an R-tree, we develop algorithms for aggregate nearest neighbors that capture several versions of the problem, including weighted queries and incremental reporting of results. Then, we analyze their performance and propose cost models for query optimization. Finally, we extend our techniques for disk-resident queries and approximate ANN retrieval. The efficiency of the algorithms and the accuracy of the cost models are evaluated through extensive experiments with real and synthetic datasets. We present a fully dynamic randomized data structure that can answer queries about the convex hull of a set of n points in three dimensions, where insertions take O(log3n) expected amortized time, deletions take O(log6n) expected amortized time, and extreme-point queries take O(log2n) worst-case time. This is the first method that guarantees polylogarithmic update and query cost for arbitrary sequences of insertions and deletions, and improves the previous O(ne)-time method by Agarwal and Matousek a decade ago. As a consequence, we obtain similar results for nearest neighbor queries in two dimensions and improved results for numerous fundamental geometric problems (such as levels in three dimensions and dynamic Euclidean minimum spanning trees in the plane). Aggregating different image features for image retrieval has recently shown its effectiveness. While highly effective, though, the question of how to uplift the impact of the best features for a specific query image persists as an open computer vision problem. In this paper, we propose a computationally efficient approach to fuse several hand-crafted and deep features, based on the probabilistic distribution of a given membership score of a constrained cluster in an unsupervised manner. First, we introduce an incremental nearest neighbor (NN) selection method, whereby we dynamically select k-NN to the query. We then build several graphs from the obtained NN sets and employ constrained dominant sets (CDS) on each graph G to assign edge weights which consider the intrinsic manifold structure of the graph, and detect false matches to the query. Finally, we elaborate the computation of feature positive-impact weight (PIW) based on the dispersive degree of the characteristics vector. To this end, we exploit the entropy of a cluster membership-score distribution. In addition, the final NN set bypasses a heuristic voting scheme. Experiments on several retrieval benchmark datasets show that our method can improve the state-of-the-art result. Let G = G(A∪B,A×B), with |A| = |B| = n, be a weighted bipartite graph, and let d(·,·) be the cost function on the edges. Let w(M) denote the weight of a matching in G, and M* a minimum-cost perfect matching in G. We call a perfect matching M c-approximate, for c ≥ 1, if w(M) ≤ c · w(M*). We present three approximation algorithms for computing minimum-cost perfect matchings in G. First, we consider the case when d(·,·) is a metric. For any Δ > 0, we present an algorithm that, in O(n2+Δ log n log2(1 Δ)) time, computes a O(1 Δα)-approximate matching of G, where α = log3 2 ≈ 0.631. Next, we assume the existence of a dynamic data structure for answering approximate nearest neighbor (ANN) queries under d(··). Given two parameters e, d e) is the query and update time of an (e 2)-ANN data structure. Finally, we present an algorithm that works even if d(·,·) is not a metric but admits an ANN data structure for d(·,·). In particular, we present an algorithm that computes, in O(e---1n3 2τ (n, e) log4(n e) log Δ) time, a (1 + e)-approximate matching of A and B; here Δ is the ratio of the largest to the smallest-cost edge in G, and τ (n, e) is the query and update time of an (e c)-ANN data structure for some constant c > 1. We show that our results lead to faster matching algorithms for many geometric settings.