A Geometric Form for the Extended Patience Sorting Algorithm

Patience Sorting is a combinatorial algorithm that can be viewed as an iterated, non-recursive form of the Schensted Insertion Algorithm. In recent work the authors extended Patience Sorting to a full bijection between the symmetric group and certain pairs of combinatorial objects (called pile configurations) that are most naturally defined in terms of generalized permutation pattern and barred pattern avoidance. This Extended Patience Sorting Algorithm is very similar to the Robinson-Schensted-Knuth (or RSK) Correspondence, which is itself built from repeated application of the Schensted Insertion Algorithm. In this work we introduce a geometric form for the Extended Patience Sorting Algorithm that is in some sense a natural dual algorithm to G. Viennot's celebrated Geometric RSK Algorithm. Unlike Geometric RSK, though, the lattice paths coming from Patience Sorting are allowed to intersect. We thus also give a characterization for the intersections of these lattice paths in terms of the pile configurations associated with a given permutation under the Extended Patience Sorting Algorithm.Comment: 14 pages, LaTeX, uses pstricks; v2: major revision after section 3; to be published in Adv. Appl. Mat

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

Dependency Mapping Software for Jira, Project Management Tool

Efficiently managing a software development project is extremely important in industry and is often overlooked by the software developers on a project. Pieces of development work are identified by developers and are then handed off to project managers, who are left to organize this information. Project managers must organize this to set expectations for the client, and ensure the project stays on track and on budget. The main block in this process are dependency chains between tasks. Dependency chains can cause a project to take much longer than anticipated or result in the under utilization of developers on a project. While project managers do have access to project management tools, few have capabilities to effectively visualize dependencies. The goal of this research was to interact with a project management tool\u27s API, pull down dependency information for a project, and build out possible timelines for a set of tasks. We visualize this problem with a directed graph, where each node is a task and edges in the graph indicate dependencies. The relationships between this problem and more well-known problems in graph theory are used to inform the development of the algorithms. Two algorithms are explored to handle the problem and are then run under different conditions. Analysis of the results provide insight to what structures of dependency chains can be handled by the algorithms. The resulting software could be used to save companies both time and money when planning software development projects

Multi-Step Processing of Spatial Joins

Spatial joins are one of the most important operations for combining spatial objects of several relations. In this paper, spatial join processing is studied in detail for extended spatial objects in twodimensional data space. We present an approach for spatial join processing that is based on three steps. First, a spatial join is performed on the minimum bounding rectangles of the objects returning a set of candidates. Various approaches for accelerating this step of join processing have been examined at the last year’s conference [BKS 93a]. In this paper, we focus on the problem how to compute the answers from the set of candidates which is handled by the following two steps. First of all, sophisticated approximations are used to identify answers as well as to filter out false hits from the set of candidates. For this purpose, we investigate various types of conservative and progressive approximations. In the last step, the exact geometry of the remaining candidates has to be tested against the join predicate. The time required for computing spatial join predicates can essentially be reduced when objects are adequately organized in main memory. In our approach, objects are first decomposed into simple components which are exclusively organized by a main-memory resident spatial data structure. Overall, we present a complete approach of spatial join processing on complex spatial objects. The performance of the individual steps of our approach is evaluated with data sets from real cartographic applications. The results show that our approach reduces the total execution time of the spatial join by factors

An Integral geometry based method for fast form-factor computation

Monte Carlo techniques have been widely used in rendering algorithms for local integration. For example, to compute the contribution of a patch to the luminance of another. In the present paper we propose an algorithm based on Integral geometry where Monte Carlo is applied globally. We give some results of the implementation to validate the proposition and we study the error of the technique, as well as its complexity.Postprint (published version

Coloring geometric hyper-graph defined by an arrangement of half-planes

We prove that any finite set of half-planes can be colored by two colors so that every point of the plane, which belongs to at least three half-planes in the set, is covered by half-planes of both colors. This settles a problem of Keszegh