Convex Hull of Points Lying on Lines in o(n log n) Time after Preprocessing

Motivated by the desire to cope with data imprecision, we study methods for taking advantage of preliminary information about point sets in order to speed up the computation of certain structures associated with them. In particular, we study the following problem: given a set L of n lines in the plane, we wish to preprocess L such that later, upon receiving a set P of n points, each of which lies on a distinct line of L, we can construct the convex hull of P efficiently. We show that in quadratic time and space it is possible to construct a data structure on L that enables us to compute the convex hull of any such point set P in O(n alpha(n) log* n) expected time. If we further assume that the points are "oblivious" with respect to the data structure, the running time improves to O(n alpha(n)). The analysis applies almost verbatim when L is a set of line-segments, and yields similar asymptotic bounds. We present several extensions, including a trade-off between space and query time and an output-sensitive algorithm. We also study the "dual problem" where we show how to efficiently compute the (<= k)-level of n lines in the plane, each of which lies on a distinct point (given in advance). We complement our results by Omega(n log n) lower bounds under the algebraic computation tree model for several related problems, including sorting a set of points (according to, say, their x-order), each of which lies on a given line known in advance. Therefore, the convex hull problem under our setting is easier than sorting, contrary to the "standard" convex hull and sorting problems, in which the two problems require Theta(n log n) steps in the worst case (under the algebraic computation tree model).Comment: 26 pages, 5 figures, 1 appendix; a preliminary version appeared at SoCG 201

Threadable Curves

We define a plane curve to be threadable if it can rigidly pass through a point-hole in a line L without otherwise touching L. Threadable curves are in a sense generalizations of monotone curves. We have two main results. The first is a linear-time algorithm for deciding whether a polygonal curve is threadable---O(n) for a curve of n vertices---and if threadable, finding a sequence of rigid motions to thread it through a hole. We also sketch an argument that shows that the threadability of algebraic curves can be decided in time polynomial in the degree of the curve. The second main result is an O(n polylog n)-time algorithm for deciding whether a 3D polygonal curve can thread through hole in a plane in R^3, and if so, providing a description of the rigid motions that achieve the threading.Comment: 16 pages, 12 figures, 12 references. v2: Revised with brief addendum after Mikkel Abrahamsen pointed us to a relevant reference on "sweepable polygons." v3: Major revisio

Experimental and computational analyses reveal that environmental restrictions shape HIV-1 spread in 3D cultures

Here, using an integrative experimental and computational approach, Imle et al. show how cell motility and density affect HIV cell-associated transmission in a three-dimensional tissue-like culture system of CD4+ T cells and collagen, and how different collagen matrices restrict infection by cell-free virions

On the design of an implementation of kinetic minimum spanning trees

En aquest projecte dissenyem una possible implementació dels arbres cinètics d'expansió mínims proposats teòricament per Agarwal et al. a 'Parametric and kinetic minimum spanning trees'. El problema que es vol resoldre amb aquesta proposta és el de mantenir un arbre d'expansió mínim d'un graf amb pesos que canvia al llarg del temps. Els possibles canvis del graf són causats per canvis als pesos de les arestes -els quals són funció d'un paràmetre t que representa el temps- a més de permetre addicions i supressions d'arestes i actualitzacions de la funció de càlcul del pes de les arestes.In this project, we design a possible implementation of kinetic minimum spanning trees proposed theoretically by Agarwal et al. in 'Parametric and kinetic minimum spanning trees'. The problem we try to solve with this proposal is to maintain a minimum spanning tree of an edge-weighted graph that changes through time. The possible changes in the graph come from changes in the edge weights -which are functions of a parameter t which represents time- in addition to permitting additions and deletions of vertices and edges and updates to the edge weight calculation function

Agglomerative Clustering of Growing Squares

We study an agglomerative clustering problem motivated by interactive glyphs in geo-visualization. Consider a set of disjoint square glyphs on an interactive map. When the user zooms out, the glyphs grow in size relative to the map, possibly with different speeds. When two glyphs intersect, we wish to replace them by a new glyph that captures the information of the intersecting glyphs. We present a fully dynamic kinetic data structure that maintains a set of $n$ disjoint growing squares. Our data structure uses $O(n (\log n \log\log n)^2)$ space, supports queries in worst case $O(\log^3 n)$ time, and updates in $O(\log^7 n)$ amortized time. This leads to an $O(n\alpha(n)\log^7 n)$ time algorithm to solve the agglomerative clustering problem. This is a significant improvement over the current best $O(n^2)$ time algorithms.Comment: 14 pages, 7 figure

Parametric and kinetic minimum spanning trees

We consider the parametric minimum spanning tree problem, in which we are given a graph with edge weights that are linear functions of a parameter, and wish to computethe sequence of minimum spanning trees generated as, varies. We also consider the kinetic minimum spanning tree problem, in which, represents time and the graph is subject in addition to changes such as edge insertions, deletions, and modifications of the weight functions as time progresses. We solve both problems in time O(n.pow2(2/3).log(4/3).n) per combinatorial change in the tree (or randomized O(n.pow2(2/3).log(n)) per change). Our time bounds reduce to O(n.pow2(1/2).log(3/2).n) per change (O(n.pow2(1/2).log(n)) randomized) for planar graphs or other minor-closed families of graphs, and O(n.pow2(1/4).log(3/2).n) per change (O(n.pow2(1/4).log(n) randomized) for planar graphs with weight changes but no insertions or deletions