The Experts below are selected from a list of 35448 Experts worldwide ranked by ideXlab platform

Alireza Zarei - One of the best experts on this subject based on the ideXlab platform.

  • kinetic euclidean minimum spanning tree in the plane
    Journal of Discrete Algorithms, 2012
    Co-Authors: Zahed Rahmati, Alireza Zarei
    Abstract:

    This paper presents a kinetic data structure (KDS) for maintenance of the Euclidean minimum spanning tree (EMST) on a set of moving points in 2-dimensional space. For a set of n points moving in the plane we build a KDS of size O(n) in O(nlogn) Preprocessing Time by which the EMST is maintained efficiently during the motion. This is done by applying the required changes to the combinatorial structure of the EMST which is changed in discrete Timestamps. We assume that the motion of the points, i.e. x and y coordinates of the points, are defined by algebraic functions of constant maximum degree. In terms of the KDS performance parameters, our KDS is responsive, local, and compact. The presented KDS is based on monitoring changes of the Delaunay triangulation of the points and edge-length changes of the edges of the current Delaunay triangulation.

  • kinetic euclidean minimum spanning tree in the plane
    International Workshop on Combinatorial Algorithms, 2011
    Co-Authors: Zahed Rahmati, Alireza Zarei
    Abstract:

    This paper presents the first kinetic data structure (KDS) for maintenance of the Euclidean minimum spanning tree (EMST) on a set of n moving points in 2-dimensional space. We build a KDS of size O(n) in O(nlogn) Preprocessing Time by which their EMST is maintained efficiently during the motion. In terms of the KDS performance parameters, our KDS is responsive, local, and compact.

Boris Aronov - One of the best experts on this subject based on the ideXlab platform.

  • Data Structures for Halfplane Proximity Queries and Incremental Voronoi Diagrams
    Algorithmica, 2018
    Co-Authors: Boris Aronov, Prosenjit Bose, Erik D Demaine, Joachim Gudmundsson, John Iacono, Stefan Langerman, Michiel Smid
    Abstract:

    We consider Preprocessing a set S of n points in convex position in the plane into a data structure supporting queries of the following form: given a point q and a directed line  $$\ell $$ ℓ in the plane, report the point of S that is farthest from (or, alternatively, nearest to) the point  q among all points to the left of line  $$\ell $$ ℓ . We present two data structures for this problem. The first data structure uses $$O(n^{1+\varepsilon })$$ O ( n 1 + ε ) space and Preprocessing Time, and answers queries in $$O(2^{1/\varepsilon }\log n)$$ O ( 2 1 / ε log n ) Time, for any $$0< \varepsilon < 1$$ 0 < ε < 1 . The second data structure uses $$O(n \log ^3 n)$$ O ( n log 3 n ) space and polynomial Preprocessing Time, and answers queries in $$O(\log n)$$ O ( log n ) Time. These are the first solutions to the problem with $$O(\log n)$$ O ( log n ) query Time and $$o(n^2)$$ o ( n 2 ) space. The second data structure uses a new representation of nearest- and farthest-point Voronoi diagrams of points in convex position. This representation supports the insertion of new points in clockwise order using only $$O(\log n)$$ O ( log n ) amortized pointer changes, in addition to $$O(\log n)$$ O ( log n ) -Time point-location queries, even though every such update may make $$\Theta (n)$$ Θ ( n ) combinatorial changes to the Voronoi diagram. This data structure is the first demonstration that deterministically and incrementally constructed Voronoi diagrams can be maintained in o ( n ) amortized pointer changes per operation while keeping $$O(\log n)$$ O ( log n ) -Time point-location queries.

  • ray shooting and intersection searching amidst fat convex polyhedra in 3 space
    Computational Geometry: Theory and Applications, 2008
    Co-Authors: Boris Aronov, Mark De Berg, Chris Gray
    Abstract:

    We present a data structure for ray-shooting queries in a set of convex fat polyhedra of total complexity n in R^3. The data structure uses O(n^2^+^@e) storage and Preprocessing Time, and queries can be answered in O(log^2n) Time. A trade-off between storage and query Time is also possible: for any m with n

  • ray shooting and intersection searching amidst fat convex polyhedra in 3 space
    Symposium on Computational Geometry, 2006
    Co-Authors: Boris Aronov, Mark De Berg, Chris Gray
    Abstract:

    We present a data structure for ray-shooting queries in a set of convex fat polyhedra of total complexity n in R3. The data structure uses O(n2+e) storage and Preprocessing Time, and queries can be answered in O(log2 n) Time. A trade-off between storage and query Time is also possible: for any m with n 2, we can construct a structure that uses O(m1+e) storage and Preprocessing Time such that queries take O((n/√m)log2 n) Time.We also describe a data structure for simplex intersection queries in a set of n convex fat constant-complexity polyhedra in R3. For any m with n 3, we can construct a structure that uses O(m1+e) storage and Preprocessing Time such that all polyhedra intersecting a query simplex can be reported in O((n/m1/3)log n+k) Time, where k is the number of answers.

  • data structures for halfplane proximity queries and incremental voronoi diagrams
    Lecture Notes in Computer Science, 2006
    Co-Authors: Boris Aronov, Prosenjit Bose, Erik D Demaine, Joachim Gudmundsson, John Iacono, Stefan Langerman, Michiel Smid
    Abstract:

    We consider Preprocessing a set S of n points in the plane that are in convex position into a data structure supporting queries of the following form: given a point q and a directed line in the plane, report the point of S that is farthest from (or, alternatively, nearest to) the point q subject to being to the left of line . We present two data structures for this problem. The first data structure uses O(n 1+e ) space and Preprocessing Time, and answers queries in O(2 1/e logn) Time. The second data structure uses O(n log 3 n) space and polynomial Preprocessing Time, and answers queries in O(log n) Time. These are the first solutions to the problem with O(logn) query Time and o(n 2 ) space. In the process of developing the second data structure, we develop a new representation of nearest-point and farthest-point Voronoi diagrams of points in convex position. This representation supports insertion of new points in counterclockwise order using only O(log n.) amortized pointer changes, subject to supporting O (log n)-Time point-location queries, even though every such update may make ⊖(n) combinatorial changes to the Voronoi diagram. This data structure is the first demonstration that deterministically and incrementally constructed Voronoi diagrams can be maintained in o(n) pointer changes per operation while keeping O(log n)-Time point-location queries.

Zahed Rahmati - One of the best experts on this subject based on the ideXlab platform.

  • kinetic euclidean minimum spanning tree in the plane
    Journal of Discrete Algorithms, 2012
    Co-Authors: Zahed Rahmati, Alireza Zarei
    Abstract:

    This paper presents a kinetic data structure (KDS) for maintenance of the Euclidean minimum spanning tree (EMST) on a set of moving points in 2-dimensional space. For a set of n points moving in the plane we build a KDS of size O(n) in O(nlogn) Preprocessing Time by which the EMST is maintained efficiently during the motion. This is done by applying the required changes to the combinatorial structure of the EMST which is changed in discrete Timestamps. We assume that the motion of the points, i.e. x and y coordinates of the points, are defined by algebraic functions of constant maximum degree. In terms of the KDS performance parameters, our KDS is responsive, local, and compact. The presented KDS is based on monitoring changes of the Delaunay triangulation of the points and edge-length changes of the edges of the current Delaunay triangulation.

  • kinetic and stationary point set embeddability for plane graphs
    Graph Drawing, 2012
    Co-Authors: Zahed Rahmati, Sue Whitesides, Valerie King
    Abstract:

    We investigate a kinetic version of point-set embeddability. Given a plane graph G(V,E) where |V|=n, and a set P of n moving points where the trajectory of each point is an algebraic function of constant maximum degree s, we maintain a point-set embedding of G on P with at most three bends per edge during the motion. This requires reassigning the mapping of vertices to points from Time to Time. Our kinetic algorithm uses linear size, O(nlogn) Preprocessing Time, and processes O(n2β2s+2(n)logn) events, each in O(log2n) Time. Here, βs(n)=λs(n)/ n is an extremely slow-growing function and λs(n) is the maximum length of Davenport-Schinzel sequences of order s on n symbols.

  • kinetic euclidean minimum spanning tree in the plane
    International Workshop on Combinatorial Algorithms, 2011
    Co-Authors: Zahed Rahmati, Alireza Zarei
    Abstract:

    This paper presents the first kinetic data structure (KDS) for maintenance of the Euclidean minimum spanning tree (EMST) on a set of n moving points in 2-dimensional space. We build a KDS of size O(n) in O(nlogn) Preprocessing Time by which their EMST is maintained efficiently during the motion. In terms of the KDS performance parameters, our KDS is responsive, local, and compact.

Chris Gray - One of the best experts on this subject based on the ideXlab platform.

Micha Sharir - One of the best experts on this subject based on the ideXlab platform.

  • submatrix maximum queries in monge matrices and partial monge matrices and their applications
    Symposium on Discrete Algorithms, 2017
    Co-Authors: Haim Kaplan, Shay Mozes, Yahav Nussbaum, Micha Sharir
    Abstract:

    We describe a data structure for submatrix maximum queries in Monge matrices or partial Monge matrices, where a query seeks the maximum element in a contiguous submatrix of the given matrix. The structure, for an n × n Monge matrix, takes O(nlog n) space and O(nlogn) Preprocessing Time, and answers queries in O(log2n) Time. For partial Monge matrices, the space grows by α(n), the Preprocessing grows by α(n)logn (α(n) is the inverse Ackermann function), and the query remains O(log2n). Our design exploits an interpretation of the column maxima in a Monge (partial Monge, respectively) matrix as an upper envelope of pseudo-lines (pseudo-segments, respectively).We give two applications: (1) For a planar set of n points in an axis-parallel rectangle B, we build a data structure, in O(nα(n)log4n) Time and O(nα(n)log3n) space, that returns, for a query point p, the largest-area empty axis-parallel rectangle contained in B and containing p, in O(log4n) Time. This improves substantially the nearly quadratic storage and Preprocessing obtained by Augustine et al. [2010]. (2) Given an n-node arbitrarily weighted planar digraph, with possibly negative edge weights, we build, in O(nlog2n/log logn) Time, a linear-size data structure that supports edge-weight updates and graph-distance queries between arbitrary pairs of nodes in O(n2/3log5/3n) Time per operation. This improves a previous algorithm of Fakcharoenphol and Rao [2006]. Our data structure has already been applied in a recent maximum flow algorithm for planar graphs in Borradaile et al. [2011].

  • submatrix maximum queries in monge matrices and monge partial matrices and their applications
    Symposium on Discrete Algorithms, 2012
    Co-Authors: Haim Kaplan, Shay Mozes, Yahav Nussbaum, Micha Sharir
    Abstract:

    We describe a data structure for submatrix maximum queries in Monge matrices or Monge partial matrices, where a query specifies a contiguous submatrix of the given matrix, and its output is the maximum element of that submatrix. Our data structure for an n x n Monge matrix takes O(n log n) space, O(n log2n) Preprocessing Time, and can answer queries in O(log2n) Time. For a Monge partial matrix the space bound and the Preprocessing Time both grow by the small factor α(n), where α(n) is the inverse Ackermann function. Our design exploits an interpretation of the column maxima in a Monge matrix (resp., Monge partial matrix) as an upper envelope of pseudo-lines (resp., pseudo-segments).We give two applications for this data structure: (1) For a set of n points in a rectangle B in the plane, we build a data structure that, given a query point p, returns the largest-area empty axis-parallel rectangle contained in B and containing p, in O(log4n) Time. The Preprocessing Time is O(nα(n) log4n), and the space required is O(nα(n) log3n). This improves substantially a previous data structure of Augustine et al. [arXiv: 1004.0558] that requires quadratic space. (2) Given an n-node arbitrarily weighted planar digraph, with possibly negative edge weights, we build, in O(n log2n/log log n) Time, a linear-size data structure that supports edge-weight updates and distance queries between arbitrary pairs of nodes (where the distance is minimum weight of a path in the graph between the pair of nodes), in O(n2/3 log5/3n) Time for each update and query. This improves the O(n4/5 log13/5n)-Time bound of Fakcharoenphol and Rao [JCSS 72, 2006]. Our data structure has already been applied in a recent maximum flow algorithm for planar graphs of Borradaile et al. [FOCS 2011], and we believe it will find additional applications.

  • range minima queries with respect to a random permutation and approximate range counting
    Discrete and Computational Geometry, 2011
    Co-Authors: Haim Kaplan, Edgar A Ramos, Micha Sharir
    Abstract:

    In approximate halfspace range counting, one is given a set P of n points in ℝd , and an e>0, and the goal is to preprocess P into a data structure which can answer efficiently queries of the form: Given a halfspace h, compute an estimate N such that (1−e)|P∩h|≤N≤(1+e)|P∩h|. Several recent papers have addressed this problem, including a study by Kaplan and Sharir (Proc. 17th Annu. ACM-SIAM Sympos. Discrete Algo., pp. 484–493, 2006), which is based, as is the present paper, on Cohen’s technique for approximate range counting (Cohen in J. Comput. Syst. Sci. 55:441–453, 1997). In this approach, one chooses a small number of random permutations of P, and then constructs, for each permutation π, a data structure that answers efficiently minimum range queries: Given a query halfspace h, find the minimum-rank element (according to π) in P∩h. By repeating this process for all chosen permutations, the approximate count can be obtained, with high probability, using a certain averaging process over the minimum-rank outputs. In the previous study, the authors have constructed such a data structure in ℝ3, using a combinatorial result about the overlay of minimization diagrams in a randomized incremental construction of lower envelopes. In the present work, we propose an alternative approach to the range-minimum problem, based on cuttings, which achieves better performance. Specifically, it uses, for each permutation, O(n ⌊d/2⌋(log log n)c /log ⌊d/2⌋ n) expected storage and Preprocessing Time, for some constant c, and answers a range-minimum query in O(log n) expected Time. We also present a different approach, based on “antennas,” which is simple to implement, although the bounds on its expected storage, Preprocessing, and query costs are worse by polylogarithmic factors.