Computational Geometry-Theory and Applications最新文献

We consider an optimization problem of inscribing a unit rectangle in a convex polygon. An axis-aligned unit rectangle is an axis-aligned rectangle whose horizontal sides are of length 1. A unit rectangle of orientation θ is a copy of an axis-aligned unit rectangle rotated by θ in counterclockwise direction. The goal is to find a largest unit rectangle inscribed in a convex polygon over all orientations in $[0,\pi )$. This optimization problem belongs to shape analysis, classification, and simplification, and they have applications in various cost-optimization problems.

A packing of disks in the plane is a set of disks with disjoint interiors. This paper is a survey of some open questions about such packings. It is organized into five themes: compacity, conjugacy, density, uniformity and computability.

We study the uniform 2-dimensional vector multiple knapsack (2VMK) problem, a natural variant of multiple knapsack arising in real-world applications such as virtual machine placement. The input for 2VMK is a set of items, each associated with a 2-dimensional weight vector and a positive profit, along with m 2-dimensional bins of uniform (unit) capacity in each dimension. The goal is to find an assignment of a subset of the items to the bins, such that the total weight of items assigned to a single bin is at most one in each dimension, and the total profit is maximized.

Our main result is a $(1-\frac{\ln 2}{2}-\epsilon )$-approximation algorithm for 2VMK, for every fixed $\epsilon >0$, thus improving the best known ratio of $(1-\frac{1}{e}-\epsilon )$ which follows as a special case from a result of Fleischer et al. (2011) [6].

Our algorithm relies on an adaptation of the Round&Approx framework of Bansal et al. (2010) [15], originally designed for set covering problems, to maximization problems. The algorithm uses randomized rounding of a configuration-LP solution to assign items to $\approx m\cdot \ln 2\approx 0.693\cdot m$ of the bins, followed by a reduction to the (1-dimensional) Multiple Knapsack problem for assigning items to the remaining bins.

Given a set P of n points and a set S of m disks in the plane, the disk coverage problem asks for a smallest subset of disks that together cover all points of P. The problem is NP-hard. In this paper, we consider a line-separable unit-disk version of the problem where all disks have the same radius and their centers are separated from the points of P by a line ℓ. We present an $O\left(\right(n+m)\log (n+m\left)\right)$ time algorithm for the problem. This improves the previously best result of $O(nm+n\log n)$ time. Our techniques also solve the line-constrained version of the problem, where centers of all disks of S are located on a line ℓ while points of P can be anywhere in the plane. Our algorithm runs in $O\left(\right(n+m)\log (m+n)+m\log m\log n)$ time, which improves the previously best result of $O(nm\log (m+n\left)\right)$ time. In addition, our results lead to an algorithm of $O(n^3\log n)$ time for a half-plane coverage problem (given n half-planes and n points, find a smallest subset of half-planes covering all points); this improves the previously best algorithm of $O(n^4\log n)$ time. Further, if all half-planes are lower ones, our algorithm runs in $O(n\log n)$ time while the previously best algorithm takes $O(n^2\log n)$ time.

A geometric graph is a graph whose vertex set is a set of points in general position in the plane, and its edges are straight line segments joining these points. We show that for every integer $k\ge 2$, there exists a constant $c>0$ such that the following holds. The edges of every dense geometric graph, with sufficiently many vertices, can be colored with k colors, such that the number of pairs of edges of the same color that cross is at most $(1/k-c)$ times the total number of pairs of edges that cross. The case when $k=2$ and G is a complete geometric graph, was proved by Aichholzer et al. (2019) [2].

In this article, we present a construction of a spanner on a set of n points in $R^d$ that we call a heavy path WSPD spanner. The construction is parameterized by a constant $s>2$ called the separation ratio. The size of the graph is $O\left(s^{d}n\right)$ and the spanning ratio is at most $1+2/s+2/(s-1)$. We also show that this graph has a hop spanning ratio of at most $2\lg n+1$.

We present a memoryless local routing algorithm for heavy path WSPD spanners. The routing algorithm requires a vertex v of the graph to store $O(\mathrm{deg}(v)\log n)$ bits of information, where $\mathrm{deg}\left(v\right)$ is the degree of v. The routing ratio is at most $1+4/s+1/(s-1)$ and at least $1+4/s$ in the worst case. The number of edges on the routing path is bounded by $2\lg n+1$.

We then show that the heavy path WSPD spanner can be constructed in metric spaces of bounded doubling dimension. These metric spaces have been studied in computational geometry as a generalization of Euclidean space. We show that, in a metric space with doubling dimension λ, the heavy path WSPD spanner has size $O\left(s^{\lambda }n\right)$ where s is the separation ratio. The spanning ratio and hop spanning ratio are the same as in the Euclidean case.

Finally, we show that the local routing algorithm works in the bounded doubling dimension case. The vertices require the same amount of storage, but the routing ratio becomes at most $1+(2+\frac{\tau }{\tau -1})/s+1/(s-1)$ in the worst case, where $\tau \ge 11$ is a constant related to the doubling dimension.

In this paper, we study the online class cover problem where a (finite or infinite) family $F$ of geometric objects and a set $P_r$ of red points in $R^d$ are given a prior, and blue points from $R^d$ arrives one after another. Upon the arrival of a blue point, the online algorithm must make an irreversible decision to cover it with objects from $F$ that do not cover any points of $P_r$. The objective of the problem is to place a minimum number of objects. When $F$ consists of axis-parallel unit squares in $R^2$, we prove that the competitive ratio of any deterministic online algorithm is $\Omega (\log |P_r\left|\right)$, and also propose an $O(\log |P_r\left|\right)$-competitive deterministic algorithm for the problem.

Quad-surfaces are polyhedral surfaces with quadrilateral faces and the combinatorics of a square grid. Isometric deformation of the quad-surfaces can be thought of as transformations that keep all the involved quadrilaterals rigid. Among quad-surfaces, those capable of non-trivial isometric deformations are identified as flexible, marking flexibility as a core topic in discrete differential geometry. The study of quad-surfaces and their flexibility is not only theoretically intriguing but also finds practical applications in fields like membrane theory, origami, architecture and robotics.

A generic quad-surface is rigid, however, certain subclasses exhibit a 1-parameter family of flexibility. One of such subclasses is the T-hedra which are originally introduced by Graf and Sauer in 1931.

This article provides a synthetic and an analytic description of T-hedra and their smooth counterparts namely, the T-surfaces. In the next step the parametrization of their isometric deformation is obtained and their deformability range is discussed. The given parametrizations and isometric deformations are provided for general T-hedra and T-surfaces. However, specific subclasses are extensively examined and explored, particularly those that encompass notable and well-known structures, including the Miura fold, surfaces of revolution and molding surfaces.

We design the first dynamic distance oracles for interval graphs, which are intersection graphs of a set of intervals on the real line, and for proper interval graphs, which are intersection graphs of a set of intervals in which no interval is properly contained in another.

For proper interval graphs, we design a linear space data structure which supports distance queries (computing the distance between two query vertices) and vertex insertion or deletion in $O(\lg n)$ worst-case time, where n is the number of vertices currently in G. Under incremental (insertion only) or decremental (deletion only) settings in general interval graphs, we design linear space data structures that support distance queries in $O(\lg n)$ worst-case time and vertex insertion or deletion in $O(\lg n)$ amortized time, where n is the maximum number of vertices in the graph. Under fully dynamic settings in general interval graphs, we design a data structure that represents an interval graph G in $O\left(n\right)$ words of space to support distance queries in $O(n\lg n/S(n\left)\right)$ worst-case time and vertex insertion or deletion in $O\left(S\right(n)+\lg n)$ worst-case time, where n is the number of vertices currently in G and $S\left(n\right)$ is an arbitrary function that satisfies $S\left(n\right)=\Omega \left(1\right)$ and $S\left(n\right)=O\left(n\right)$. This implies an $O\left(n\right)$-word solution with $O\left(\sqrt{n\lg n}\right)$-time support for both distance queries and updates. All four data structures can answer shortest path queries by reporting the vertices in the shortest path between two query vertices in $O(\lg n)$ worst-case time per vertex.

We also study the hardness of supporting distance queries under updates over an intersection graph of 3D axis-aligned line segments, which generalizes our problem to 3D. Finally, we solve the problem of computing the diameter of a dynamic connected interval graph.

Finding the smallest d-chain with a specific $(d-1)$-boundary in a simplicial complex is known as the Minimum Bounded Chain problem (MBC_d). MBC_d is NP-hard for all $d\ge 2$. In this paper, we prove that it is also W[1]-hard for all $d\ge 2$, if we parameterize the problem by solution size. We also give an algorithm solving MBC₁ in polynomial time and introduce and implement two fixed parameter tractable (FPT) algorithms solving MBC_d for all d. The first algorithm uses a shortest path approach and is parameterized by solution size and coface degree. The second algorithm is a dynamic programming approach based on treewidth, which has the same runtime as a lower bound we prove under the exponential time hypothesis.