Computational geometry

We give a deterministic algorithm for triangulating a simple polygon in linear time. The basic strategy is to build a coarse approximation of a triangulation in a bottom-up phase and then use the information computed along the way to refine the triangulation in a top-down phase. The main tools used are the polygon-cutting theorem, which provides us with a balancing scheme, and the planar separator theorem, whose role is essential in the discovery of new diagonals. Only elementary data structures are required by the algorithm. In particular, no dynamic search trees, of our algorithm.

Triangulating a simple polygon in linear time

Computational geometry.

Origami describes rules for creating folded structures from patterns on a flat sheet, but does not prescribe how patterns can be designed to fit target shapes. Here, starting from the simplest periodic origami pattern that yields one-degree-of-freedom collapsible structures-we show that scale-independent elementary geometric constructions and constrained optimization algorithms can be used to determine spatially modulated patterns that yield approximations to given surfaces of constant or varying curvature. Paper models confirm the feasibility of our calculations. We also assess the difficulty of realizing these geometric structures by quantifying the energetic barrier that separates the metastable flat and folded states. Moreover, we characterize the trade-off between the accuracy to which the pattern conforms to the target surface, and the effort associated with creating finer folds. Our approach enables the tailoring of origami patterns to drape complex surfaces independent of absolute scale, as well as the quantification of the energetic and material cost of doing so.

Programming curvature using origami tessellations

Voting based extreme learning machine

A new form of optimality for comparison based static dictionaries is introduced. This type of optimality, key-independent optimality, is motivated by applications that assign key values randomly. It is shown that any data structure that is key-independently optimal is expected to execute any access sequence where the key values are assigned arbitrarily to unordered data as fast as any offline binary search tree algorithm, within a multiplicative constant. Asymptotically tight upper and lower bounds are presented for key-independent optimality. Splay trees are shown to be key-independently optimal.

Key Independent Optimality

In a packing problem, the goal is to put some small objects disjointly into a large container, while optimizing some objective function. The packing problem is very general, and a rich variety of objects and containers are possible. One major split in the taxonomy of packing concerns whether the objects to be packed are allowed to be different or are all identical. In the case of identical packing, probably the simplest non-trivial variant is the following problem, which we call the 2 × 2 packing problem: How many axis-aligned 2× 2 squares can be packed inside a polygon P with n edges drawn on a unit grid, where the squares must be packed such that each occupies exactly four grid locations (i.e. rotation or fractional placement is forbidden)? Whether the problem when P is restricted to be simple (the 2× 2 simple packing problem) is polynomial or NP -complete appears on the open problem project [1] as problem 56. There they cite [3] as proving the 2× 2 packing problem NP complete (where P must be allowed to have holes). This is not true, as in [3] they do prove NP -completeness, but only when all possible locations where the squares could be packed are explicitly provided in the input. Since the size of a normal representation of a grid polygon using binary integers can differ exponentially from the number of possible packing locations inside the polygon (e.g. a k×k square requires Θ(log k) bits to represent but has Θ(k) packing locations), it does not follow from their result that the 2 × 2 packing problem is in NP if the input is simply a polygon. The result of [3] does prove NP -hardness for 2 × 2 packing problem. This paper is devoted to proving the 2 × 2 packing problem is in NP , and thus, combined with the work of [3] proves NP -completeness for the first time. Whether the 2× 2 simple packing problem is polynomial or NP -complete remains an important open question, and remains open quite surprisingly even if P is restricted to be orthogonally convex. A simple greedy algorithm works for Manhattan Skyline polygons [2], the most complex class of polygons for which a polynomial algorithm is known.

Packing 2 × 2 unit squares into grid polygons is NP-complete

Consider laying out a fixed-topology binary tree of N nodes into external memory with block size B so as to minimize the worst-case number of block memory transfers required to traverse a path from the root to a node of depth D. We prove that the optimal number of memory transfers is $$\begin{aligned} \begin{cases} \varTheta( {D \over\lg(1{+}B)} ) & \mathrm{when}~D = O(\lg N), \\ \varTheta( {\lg N \over\lg(1{+}{B \lg N \over D} )} ) & \mathrm{when}~D = \varOmega(\lg N)~\mathrm{and}~D = O(B \lg N), \\ \varTheta( {D \over B} ) & \mathrm{when}~D = \varOmega(B \lg N). \end{cases} \end{aligned}$$

/pdf/worst-case-optimal-tree-layout-in-external-memory-zh56i2daiz.pdf

Worst-Case Optimal Tree Layout in External Memory

We consider the design of adaptive data structures for searching elements of a tree-structured space. We use a natural generalization of the rotation-based online binary search tree model in which the underlying search space is the set of vertices of a tree. This model is based on a simple structure for decomposing graphs, previously known under several names including elimination trees, vertex rankings, and tubings. The model is equivalent to the classical binary search tree model exactly when the underlying tree is a path. We describe an online O(log log n)-competitive search tree data structure in this model, matching the best known competitive ratio of binary search trees. Our method is inspired by Tango trees, an online binary search tree algorithm, but critically needs several new notions including one which we call Steiner-closed search trees, which may be of independent interest. Moreover our technique is based on a novel use of two levels of decomposition, first from search space to a set of Steiner-closed trees, and secondly from these trees into paths.

Competitive online search trees on trees

A static binary search tree where every search starts from where the previous one ends (lazy finger) is considered. Such a search method is more powerful than that of the classic optimal static trees, where every search starts from the root (root finger), and less powerful than when rotations are allowed--where finding the best rotation based tree is the topic of the dynamic optimality conjecture of Sleator and Tarjan. The runtime of the classic root-finger tree can be expressed in terms of the entropy of the distribution of the searches, but we show that this is not the case for the optimal lazy finger tree. A non-entropy based asymptotically-tight expression for the runtime of the optimal lazy finger trees is derived, and a dynamic programming-based method is presented to compute the optimal tree.

John Iacono

Papers

Key Independent Optimality

Packing 2 × 2 unit squares into grid polygons is NP-complete

Worst-Case Optimal Tree Layout in External Memory

Competitive online search trees on trees

The Power and Limitations of Static Binary Search Trees with Lazy Finger