3 research outputs found

    Algorithms for Incremental Planar Graph Drawing and Two-page Book Embeddings

    Get PDF
    Subject of this work are two problems related to ordering the vertices of planar graphs. The first one is concerned with the properties of vertex-orderings that serve as a basis for incremental drawing algorithms. Such a drawing algorithm usually extends a drawing by adding the vertices step-by-step as provided by the ordering. In the field of graph drawing several orderings are in use for this purpose. Some of them, however, lack certain properties that are desirable or required for classic incremental drawing methods. We narrow down these properties, and introduce the bitonic st-ordering, an ordering which combines the features only available when using canonical orderings with the flexibility of st-orderings. The additional property of being bitonic enables an st-ordering to be used in algorithms that usually require a canonical ordering. With this in mind, we describe a linear-time algorithm that computes such an ordering for every biconnected planar graph. Unlike canonical orderings, st-orderings extend to directed graphs, in particular planar st-graphs. Being able to compute bitonic st-orderings for planar st-graphs is of particular interest for upward planar drawing algorithms, since traditional incremental algorithms for undirected planar graphs might be adapted to directed graphs. Based on this observation, we give a full characterization of the class of planar st-graphs that admit such an ordering. This includes a linear-time algorithm for recognition and ordering. Furthermore, we show that by splitting specific edges of an instance that is not part of this class, one is able to transform it into one for which then such an ordering exists. To do so, we describe a linear-time algorithm for finding the smallest set of edges to split. We show that for a planar st-graph G=(V,E), |V|−3 edge splits are sufficient and every edge is split at most once. This immediately translates to the number of bends required for upward planar poly-line drawings. More specifically, we show that every planar st-graph admits an upward planar poly-line drawing in quadratic area with at most |V|−3 bends in total and at most one bend per edge. Moreover, the drawing can be obtained in linear time. The second part is concerned with embedding planar graphs with maximum degree three and four into books. Besides providing a simplified incremental linear-time algorithm for embedding triconnected 3-planar graphs into a book of two pages, we describe a linear-time algorithm to compute a subhamiltonian cycle in a triconnected 4-planar graph

    Extending the hardness of RNA secondary structure comparison

    Get PDF
    Abstract. In molecular biology, RNA structure comparison is of great interest to help solving problems as different as phylogeny reconstruction, prediction of molecule folding and identification of a function common to a set of molecules. Lin et al. [6] proposed to define a similarity criterion between RNA structures using a concept of edit distance; they named the corresponding problem Edit. Recently, Blin et al. [3] showed that another problem, the Longest Arc-Preserving Common Subsequence problem (or Lapcs), is in fact a subproblem of Edit. This relationship between those two problems induces the hardness of what was the last open case for the Edit problem, Edit(Nested,Nested), which corresponds to computing the edit distance between two secondary structures without pseudoknots. Nevertheless, Lapcs is a very restricted subproblem of Edit: in particular, it corresponds to a given system of editing costs, whose biological relevance can be discussed; hence, giving a more precise categorization of the computational complexity of the Edit problem remains of interest. In this paper, we answer this question by showing that Edit(Nested,Nested) is NP-complete for a large class of instances, not overlapping with the ones used in the proof for Lapcs, and which represent more biologically relevant cost systems
    corecore