Minimum projective linearizations of trees in linear time
Lluís Alemany-Puig, Juan Luis Esteban, Ramon Ferrer-i-Cancho
MMinimum projective linearizations of trees in linear time
Llu´ıs Alemany-Puig a, ∗ , Juan Luis Esteban b , Ramon Ferrer-i-Cancho a a Complexity and Quantitative Linguistics Lab, LARCA Research Group, Computer Science Department, UniversitatPolit`ecnica de Catalunya, Jordi Girona 1-3, 08034, Barcelona, Spain b Computer Science Department, Universitat Polit`ecnica de Catalunya, Jordi Girona 1-3, 08034, Barcelona, Spain
Abstract
The minimum linear arrangement problem (MLA) consists of finding a mapping π from vertices of agraph to integers that minimizes (cid:80) uv ∈ E | π ( u ) − π ( v ) | . For trees, various algorithms are available tosolve the problem in polynomial time; the best known runs in subquadratic time in n = | V | . Thereexist variants of the MLA in which the arrangements are constrained to certain classes of projectivity.Iordanskii, and later Hochberg and Stallmann (HS), put forward O ( n )-time algorithms that solve theproblem when arrangements are constrained to be planar. We also consider linear arrangements ofrooted trees that are constrained to be projective. Gildea and Temperley (GT) sketched an algorithmfor the projectivity constraint which, as they claimed, runs in O ( n ) but did not provide any justificationof its cost. In contrast, Park and Levy claimed that GT’s algorithm runs in O ( n log d max ) where d max isthe maximum degree but did not provide sufficient detail. Here we correct an error in HS’s algorithmfor the planar case, show its relationship with the projective case, and derive an algorithm for theprojective case that runs undoubtlessly in O ( n )-time. Keywords:
Linear arrangements, Minimum Linear Arrangement Problem, Projectivity, Planarity,One-page embeddings
1. Introduction
A linear arrangement π of a graph G = ( V, E ) is an ordering of its vertices (it can also be seenas a permutation). In such arrangement, the distance d ( u, v ) between two vertices u, v can be definedas d ( u, v ) = | π ( u ) − π ( v ) | where π is mapping from n vertices to integers in [1 , n ]. The minimumlinear arrangement problem (MLA) consists of finding a π that minimizes the cost D = (cid:80) uv ∈ E d ( u, v )[4, 2]. In arbitrary graphs, the problem is NP-hard [4]. For trees, various algorithms are available tosolve the problem in polynomial time [6, 14, 2]. Goldberg and Klipker devised an O (cid:0) n (cid:1) algorithm[6]. Later, Shiloach contributed with an O (cid:0) n . (cid:1) algorithm [14]. Finally, Chung contributed twoalgorithms running in O (cid:0) n (cid:1) -time and O (cid:0) n λ (cid:1) -time, respectively, where λ is any real number satisfying λ > log 3 / log 2 [2]. The latter algorithm is the best algorithm known. For planar linear arrangements,i.e., arrangements where edges do not cross, linear-time algorithms have been proposed [10, 9]. Tothe best of our knowledge, the first algorithm was put forward by Iordanskii [10]. Sixteen years later,Hochberg and Stallmann (HS) put forward another linear-time algorithm [9].Later, Gildea and Temperley (GT) [5] sketched an algorithm to solve the problem in projectivearrangements of rooted trees. A projective linear arrangement is a planar arrangement where noedge covers the root [12, 13]. Fig. 1(a) shows a projective arrangement while Fig. 1(b) shows anarrangement that is projective if we take vertex 2 as the root but not if we take vertex 1 as the root. ∗ Corresponding author
Email addresses: [email protected] (Llu´ıs Alemany-Puig), [email protected] (Juan Luis Esteban), [email protected] (Ramon Ferrer-i-Cancho)
Preprint submitted to Elsevier February 18, 2021 a r X i v : . [ c s . D S ] F e b Figure 1: Two different linear arrangements of the same free tree T . a) A minimum projective arrangement of T rootedat 1 with cost D = 7; the circled dot denotes the root. b) A minimum planar arrangement of T with cost D = 6 underthe planarity constraint; the squared dot denotes its (only) centroidal vertex. The tree shown in Fig. 1 is the smallest tree for which there is a vertex that, when chosen as the root,makes the minimum cost of the projective case be greater than that of the planar case (there are noother 6-vertex trees where that happens). While GT alleged that their sketch runs in O ( n ) [5, p. 2],Park and Levy (PL) argued that it runs in time O ( n log d max ), where d max is the maximum degree.However, PL did not give enough detail to support their conclusion [1]. Here we show that this is anoverestimation of the actual complexity: the problem can be actually solved in linear time.The remainder of the article is organized as follows. Section 2 introduces the notation and reviewsHS’s algorithm. Section 3 corrects a subalgorithm of HS’s [9]. Section 4 presents a detailed linear-timealgorithm for the projective case that stems from HS’s algorithm for the planar case but using anapproach based on intervals. Our algorithm for the projective case can be used to solve the planarcase: we clarify that HS’s algorithm already contained a subalgorithm for solving the projective casealthough the authors did not identify it as such in their article [9]. Indeed, their algorithm consistsof two main steps: finding a central vertex (as in Iordanskii’s algorithm [10]) and then solving theprojective case for the input tree rooted at the center. Therefore, Section 4 unifies, in a sense, HS’salgorithm and GT’s sketch. Put differently, solving the minimization of D on a tree under planarityis equivalent to solving the projective case for a tree rooted at a specific vertex. For instance, theminimum D under planarity for the tree in Fig. 1 is obtained when calculating the minimum D underprojectivity when the tree is rooted at the vertex marked with a square in Fig. 1(b). Section 5 drawssome general conclusions and indicates some future paths for research.
2. Notation and review
Throughout this paper we use T = ( V, E ) to denote a free tree, and T r = ( V, E ; r ) to denote atree T rooted at a vertex r where n = | V | . Free trees have undirected edges, and rooted trees havedirected edges; we consider the edges of a rooted tree to be oriented away from the root. In rootedtrees, we refer to the parent of a vertex u as p ( u ); in a directed edge ( u, v ), p ( v ) = u . We use T ru todenote a subtree of T r rooted at u ∈ V (if u = r then T ru = T r ), and Γ u to denote the set of neighborsof vertex u in T . We call T rv an immediate subtree of T ru rooted at v if ( u, v ) ∈ E ( T r ). Extending thenotation in [9], we use T ru, , · · · , T ru,k to denote the k immediate subtrees of a subtree T ru of T r sorteddecreasingly by size. We also use n ≥ · · · ≥ n k ≥ n denotes the size of T ru, ; we omit the vertex when referring to immediate subtrees of T r . Henceforth assume, without lossof generality, that k is even. Recall that π ( u ) is the position of u ∈ V in the linear arrangement.Now we summarize the core ideas and tools derived by HS [9]. Firstly (Lemmas 6, 11), the optimalprojective arrangement of T r is obtained by arranging the immediate subtrees of T r inwards, decreas-ingly by size and on alternating sides, namely T r , T r , · · · , r, · · · , T r , T r or T r , T r , · · · , r, · · · , T r , T r .Immediate subtrees of T r can be arranged in any of the two orders, whereas immediate subtrees of T ru , u (cid:54) = r have to be placed according to the side in which u is placed with respect to p ( u ): if u is placedto p ( u )’s left then the optimal order is T ru, , T ru, , · · · , u, · · · , T ru, , T ru, (Fig. 2(a)), and if u is placed to2 ru, u T ru,k u u a) v c) p ( u ) p ( u )b) T ru, p ( u ) T ru,k T ru, T ru,i T ru,i +2 T ru,k − T ru,k T ru, Figure 2: a,b) Optimal arrangements of T rv according to the relative position of v with respect to v ’s parent. c) Depictionof ( p ( u ) , u ) , ( u, v ) ∈ E in an optimal projective arrangement, divided into the anchor (the part of the edge ( u, v ) to theleft of the vertical line), and the coanchor (the part of the edge ( u, v ) to the right). The length of the anchor of edge( p ( u ) , u ) is the sum n j for even j ∈ [2 , k ]. u v w vu w Figure 3: Left: a free tree with s ( u, v ) = 7, s ( v, u ) = 3 and s ( v, w ) = s ( w, v ) = 5. Right: the free tree rooted at v ; | V ( T vu ) | = s ( v, u ). Borrowed from [9, Fig. 7]. p ( u )’s right the optimal order is T ru, , T ru, , · · · , u, · · · , T ru, , T ru, (Fig. 2(b)). Notice that the root is notcovered in any of these planar arrangements, as required by the projectivity constraint [12, 13].Secondly [9, Theorem 12], an optimal planar arrangement of a free tree T is obtained when T is rooted at one of its centroidal vertices . Therefore, an optimal planar arrangement of a free tree T is an optimal projective arrangement of T c , where c denotes one (of the possible two) centroidalvertices of T . For the calculation of a centroidal vertex, HS defined s ( u, v ), which we call directional size of subtrees. The directional size s ( u, v ) in a free tree T , for { u, v } ∈ E ( T ), is the size of T uv (Fig.3). Notice that s ( v, u ) + s ( u, v ) = n . They also outlined a way of calculating all of the s ( u, v ) in O ( n )-time [9, Section 6], but did not provide any pseudocode; here we provide it in Algorithm 2.1.Using the s ( u, v ) for all edges in T , we can construct a sorted adjacency list of the tree which wedenote as L (Algorithm 2.2), and with it we calculate one of the centroidal vertices. Pseudocode forthe calculation of the centroid is given in Algorithm 2.3. All three algorithms have O ( n )-time and O ( n )-space complexity.In order to complete the other algorithms, we need to consider also the rooting of the list L withrespect to a vertex w . We denote the resulting list as L w . This operation is denoted as RootList ( L, w )in the pseudocode. This operation consists of the action of removing edges of the form ( u, p ( u )) from L , starting at the given vertex w , which acts as a root. In other words, vertex w induces an orientationof the edges oriented towards the leaves, and we have to remove the edges oriented in the oppositedirection. This can be done in linear time. We do not give the pseudocode for this operation since itis fairly simple.
3. Minimum planar linear arrangements
In [9], HS present an easy-to-understand algorithm to calculate a minimal planar linear arrange-ment for any free tree in linear time. The idea behind the algorithm is presented in section 2. Theimplementation has two procedures, embed and embed branch , that perform a series of actions in thefollowing order: In this paper we follow the same terminology and notation as in [7, Pages 35-36]. Therefore, we consider the center to be the set of central vertices, the vertices whose eccentricity is equal to the radius, and the centroid to be the set of centroidal vertices, the set of vertices whose weight, i.e., the size of the largest subtree, is minimum. lgorithm 2.1: Calculation of directional sizes. Cost O ( n )-time, O ( n )-space. Function
ComputeS ( T ) isInput: T free tree. Output: S = { ( u, v, s ( u, v )) , ( v, u, s ( v, u )) | { u, v } ∈ E } . S ← ∅ u ∗ ← choose an arbitrary vertex for v ∈ Γ u ∗ do ( , S (cid:48) ) ← ComputeSu ( T, ( u ∗ , v )) S ← S ∪ S (cid:48) return S Function
ComputeSu ( T, ( u, v )) isInput: T free tree, ( u, v ) the directing edge. Output: s = s ( u, v ), S = { ( u, v, s ( u, v )) , ( v, u, s ( v, u )) | { u, v } ∈ E ( T u ∗ v ) } . s ← for w ∈ Γ v do if w (cid:54) = u then ( s (cid:48) , S (cid:48) ) ← ComputeSu ( T, ( v, w )) s ← s + s (cid:48) S ← S ∪ S (cid:48) // s = s ( u, v ) , n − s = s ( v, u ) S ← S ∪ { ( u, v, s ) , ( v, u, n − s ) } // Append at end in O (1) return ( r, S ) Algorithm 2.2:
Calculation of the sorted adjacency list. Cost O ( n )-time, O ( n )-space. Function
SortedAdjacencyList ( T ) isInput: T free tree. Output: L , the decreasingly-sorted adjacency list of T . S ← ComputeS ( T ) // Algorithm 2.1 Sort the triples ( u, v, s ) in S decreasingly by s using counting sort [3] L ← {∅} n for ( u, v, s ) ∈ S do L [ u ] ← L [ u ] ∪ ( v, s ) // Append at end in O (1) return L Algorithm 2.3:
Calculation of a centroidal vertex. Cost O ( n )-time, O ( n )-space. Function
FindCentroidalVertex ( T ) isInput: T free tree. Output:
A centroidal vertex of T . L ← SortedAdjacencyList ( T ) // Algorithm 2.2 u ← choose an arbitrary vertex while true do ( v, s ) ← largest entry in L [ u ] // O (1) -time since L [ u ] is sorted if s > n/ then u ← v else return u Procedure embed gets one centroidal vertex, c , uses it as a root and orders its immediate subtreesby size. • Procedure embed puts immediate subtrees with an even index in one side of the arrangement andimmediate subtrees with odd index in the other side (the bigger the subtree, the farther awayfrom the centroid), calling procedure embed branch for every subtree. • Procedure embed branch calculates recursively a displacement of all nodes with respect to theplacement of the centroid (of the whole tree) in the linear arrangement. • Procedure embed calculates the centroid’s position (the sum of sizes of trees on the left of thecentroid) and applies the displacement to the rest of the nodes.
Algorithm 3.1:
Step (5) from procedure embed . π ( c ) ← lef tSum + 1 relP os [ c ] ← for each vertex v do π ( v ) ← π ( c ) + relP os [ v ]From Algorithm 3.1, we can see that vector relPos must contain the displacement of all nodes fromthe position of the centroid in the linear arrangement. Note that this is only the last lines of embed .The problem lays in procedure embed branch , which does not calculate correctly the displacementvector relPos . In Algorithm 3.2, we give a correct version of procedure embed branch , where changeswith respect to HS’s version are marked in red. Lines 3 to 6 are needed to calculate the correctdisplacement. For a vertex u (cid:54) = c , variable under anchor is the number of nodes of T cu between u and c . Adding under anchor to parameter base (line 8), we obtain the correct displacement. There is alsoa slight modification in the recursive calls.We should note that embed needs to calculate a sorted adjacency list L to calculate a centroidalvertex c for T c (algorithm 2.3). However, in order to calculate the arrangement, we need L to berooted at c , then we use L c (see section 2).In section 4, we give an even simpler algorithm that can be seen as a different interpretation of HS’salgorithm as it uses the same idea for ordering the subtrees but instead of calculating displacementsfor nodes it only uses the interval of positions where a subtree must be arranged.Prior to HS’s work, Iordanskii [10] presented an algorithm to solve task of minimizing D under theplanarity constraint. He devised a different approach to solve the same problem: given a free tree,the algorithm roots the tree at its centroid, and then separates the tree into chains of vertices, whichhave to be arranged in such a way that a planar arrangement is produced. The proper selection of thechains, coupled with the proper labeling of their vertices, produce a minimal planar arrangement. Anoutline of the algorithm that is applied on T c is as follows [11]:1. Select an arbitrary vertex v in the current decomposition subtree (initial tree).2. Go from vertex v along the branches with the greatest number of vertices to some hangingvertex v i .3. Starting from vertex v i , construct a chain along the branches with the largest number of verticesto some other hanging vertex v j .4. Assign the highest and lowest numbers to the vertices v i and v j from the range allocated for thecurrent decomposition subtree (1 and n for the initial tree).5 lgorithm 3.2: embed branch corrected Function embed branch ( L c , v, base, dir, relP os ) isInput: (Rooted) sorted adjacency list L c for T c as described in section 2; v the root of thesubtree to be arranged; base the displacement for the starting position of thesubtree arrangement; dir whether or not v is to the left or to the right of its parent. Output: relP os contains the displacement from the centroid of all nodes of the subtree. C v ← L c [ v ] // the children of v decreasingly sorted by size bef ore ← af ter ← under anchor ← for i = 1 to | C v | step do v i , n i ← C v [ i ] // the i -th child of v , and its size | V ( T cv i ) | under anchor ← under anchor + dir ∗ n i base ← base + under anchor for i = | C v | downto do v i , n i ← C v [ i ] if i is even then embed branch ( L c , v i , base − dir ∗ ( bef ore + 1) , − dir, relP os ) bef ore ← bef ore + n i else embed branch ( L c , v i , base + dir ∗ ( af ter + 1) , dir, relP os ) af ter ← af ter + n i relP os [ v ] ← base
5. Enumerate monotonically the chain connecting the vertices v i and v j , leaving the correspondingranges of numbers for each selected decomposition subtree.6. The procedure recursively repeats until all vertices are numbered.The algorithm requires O ( n ) comparison operations and O ( n log n ) additional memory.Iordanskii’s approach differs markedly from HS’s algorithm, e.g., using chains instead of anchors,and here we have focused on deriving an algorithm for the projective case that stems from HS’salgorithm for the planar case.
4. Minimum projective linear arrangements
In this section, we provide complete pseudocode (Algorithm 4.1) for the calculation of an optimalarrangement for rooted trees . The pseudocode given can be regarded as a formal interpretation of GT’ssketch [5]. Nevertheless, our pseudocode’s correctness stems largely from the theorems and lemmasgiven by HS [9], summarized in Section 2. The algorithm we present here has O ( n )-time and O ( n )-space complexity, hence our upper bound for the projective case is tighter than that given by PL[1]. In Algorithm 4.1 we give two procedures, where the recursive one can be seen as a combinationof HS’s methods embed branch and embed excluding the calculation of one of the centroidal vertices[9]. Furthermore, using this algorithm to solve the planar is straightforward. Given a free tree T , wesimply have to find a centroidal vertex c of T , Algorithm 2.3, where to root the tree and then supply T c as input of Algorithm 4.1. This is due to the fact that an optimal planar arrangement for T isan optimal projective arrangement for T c [9]. However, notice that an optimal planar arrangementfor T need not be an optimal projective arrangement for T r for r (cid:54) = c . Figure 1(a) shows an optimal6rojective arrangement of the rooted tree T , which is not an optimal planar arrangement of T ; Figure1(b) shows an arrangement which is both optimal planar for T , and optimal projective for T . Algorithm 4.1:
Linear-time calculation of optimal projective arrangement. Function
ArrangeOptimalProjective ( T r ) isInput: T r rooted tree at r . Output:
An optimal projective arrangement π . L ← SortedAdjacencyList ( T ) // T ’s sorted adjacency list (Algorithm 2.2) L r ← RootList ( L, r ) // list L rooted at r (see section 2) π ← { } n // empty arrangement Arrange Rec ( L r , r, right , , n, π ) // The starting side ‘right’ is arbitrary. return π Function
Arrange Rec ( L r , u, τ, a, b, π ) isInput: (Rooted) sorted adjacency list L r as described in section 2; u the root of thesubtree to be arranged; τ position of u with respect to its parent p ( u ); [ a, b ]interval of positions of the arrangement where to embed T ru ; π thepartially-constructed arrangement. Output: π updated with the optimal projective arrangement for T ru in [ a, b ]. C u ← L r [ u ] // the children of u decreasingly sorted by size if τ is right then side ← right else side ← left for i from to | C u | do v, n v ← C u [ i ] // the i -th child of u , and its size n v = | V ( T rv ) | if side is left then τ next ← left; a next ← a ; b next ← a + n v − else τ next ← right; a next ← b − n v + 1; b next ← b Arrange Rec ( L r , v, τ next , a next , b next , π ) if side is left then a ← a + n v else b ← b − n v side ← opposite side π ( u ) ← a Our algorithm calculates the arrangement of the input tree T r using intervals of integers [ a, b ],where 1 ≤ a ≤ b ≤ n , that indicate the first and the last position of the vertices of a subtree inthe linear arrangement; an approach based on intervals (but using chains) was considered earlier byIordanskii [11]. For the case of T r , the interval is obviously [1 , n ], as seen in the first call to the recursiveprocedure (line 5); said procedure is defined in line 7. The loop starting at line 11 is responsible forarranging all immediate subtrees of T ru following the ordering described by HS (Section 2). Now, let T ru ( u (cid:54) = r ) be a subtree of T r to be embedded in the interval [ a, b ], where u , a and b are parametersof the recursive procedure. If one of the immediate subtrees of T ru , say T rv with n v = | V ( T rv ) | , is tobe arranged in the available interval farthest to the left of its parent u , its interval is [ a, a + n v − u , its interval is[ b − n v + 1 , b ] (line 14). Notice that the side (with respect to u ) to which subtree T rv has to be arrangedis decided by changing the value of the variable side , whose initial value is given in either line 9 orline 10 depending on the side to which u has been placed with respect to its parent (said side is givenas the parameter τ to the recursive procedure). After T rv is arranged, we need to update the left andright limits of the arrangement of T ru : if the subtree T rv is arranged to the left of u , the left limit is tobe increased by n v (line 16), and when it is arranged to the right of u , the right limit is to be decreasedby n v (line 17). When all immediate subtrees of T ru have been arranged (line 19), only node u needs7o be arranged, thus the remaining interval [ a, b ] has one element, and then a = b and π ( u ) = a .The algorithm’s time and space complexities are O ( n ). First, the sorted adjacency list L of T r can be computed in O ( n ) (line 2); obtaining the list L r (line 3) as explained at the end of section 2 isalso O ( n ). The running time of the recursive function is clearly O ( n ): the ‘for’ loop (line 11) containsconstant-time operations, a single recursive call and, since each loop consists of d u = | Γ u | iterations(for a vertex u ), the total running time is O (cid:0)(cid:80) u ∈ V d u (cid:1) = O ( n ) because every vertex is visited onlyonce. The spatial complexity is O ( n ): sorting and building the adjacency list L r requires O ( n )-spaceand the recursive function requires extra O ( n )-space (for the whole stack of the recursion) in the worstcase (for path graphs).
5. Conclusions and future work
To the best of our knowledge, our work is the first to highlight a relationship between the minimumlinear arrangement problem under planarity and the same problem under projectivity. We have shownthat HS’s algorithm for planarity [9] contains a subalgorithm to solve the projective problem. Wesuspect that Iordanskii’s algorihtm for planarity [10] may also contain a subalgorithm for the projectivecase. We have corrected a few aspects of HS’s algorithm and we provided a detailed algorithm for theprojective case that stems from their work on the planar case and runs undoubtlessly in O ( n ). GT[5] just sketched an algorithm and claimed it to run in linear time. PL [1] added some details but notsufficiently, concluding that it runs in O ( n log d max ) time, which, as we have seen, overestimates theactual complexity.It could be the case that a unified approach for planarity and projectivity could also be adoptedfor the maximum linear arrangement problem [8]. To the best of our knowledge, a polynomial timealgorithm for the unrestricted case is not forthcoming. An intriguing question is if the maximum lineararrangement problem on trees can be solved in linear time for the projective and planar case as in thecorresponding minimization problem. Acknowledgements
We are grateful to M. Iordanskii for helpful discussions. LAP is supported by Secretaria d’Universitatsi Recerca de la Generalitat de Catalunya and the Social European Fund. RFC and LAP are supportedby the grant TIN2017-89244-R from MINECO (Ministerio de Econom´ıa, Industria y Competitividad).RFC is also supported by the recognition 2017SGR-856 (MACDA) from AGAUR (Generalitat deCatalunya). JLE is funded by the grant PID2019-109137GB-C22 from MINECO.
References [1] Y. Albert Park and R. Levy. Minimal-length linearizations for mildly context-sensitive dependencytrees. In
Proceedings of the 10th Annual Meeting of the North American Chapter of the Associationfor Computational Linguistics: Human Language Technologies (NAACL-HLT) conference , pages335–343, Stroudsburg, PA, USA, 2009. Association for Computational Linguistics.[2] F. R. K. Chung. On optimal linear arrangements of trees.
Comp. & Maths. with Appls. , 10(1):43–60, 1984.[3] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein.
Introduction toAlgorithms . The MIT Press, Cambridge, MA, USA, 2nd edition, 2001.[4] M. R. Garey and D. S. Johnson. Some simplified np-complete graph problems.
TheoreticalComputer Science , pages 237–267, 1976. 85] Daniel Gildea and David Temperley. Optimizing grammars for minimum dependency length. In
Proceedings of the 45th Annual Meeting of the Association of Computational Linguistics , pages184–191, Prague, Czech Republic, June 2007. Association for Computational Linguistics.[6] M. K. Goldberg and I. A. Klipker. Minimal placing of trees on a line. Technical report, Physico-Technical Institute of Low Temperatures. Academy of Sciences of Ukranian SSR, USSR, 1976. inRussian.[7] F. Harary.
Graph Theory . Addison-Wesley, Reading, MA, 1969.[8] R. Hassin and S. Rubinstein. Approximation algorithms for maximum linear arrangement.
Infor-mation Processing Letters , 80(4):171 – 177, 2001.[9] R. A. Hochberg and M. F. Stallmann. Optimal one-page tree embeddings in linear time.
Infor-mation Processing Letters , 87:59–66, 2003.[10] M. A. Iordanskii. Minimal numberings of the vertices of trees — Approximate approach. InLothar Budach, Rais Gatiˇc Bukharajev, and Oleg Borisoviˇc Lupanov, editors,
Fundamentals ofComputation Theory , pages 214–217, Berlin, Heidelberg, 1987. Springer Berlin Heidelberg.[11] M.A. Iordanskii.
Introduction to graph theory . Minin Pedagogical State University, Nizhny Nov-gorod, 2014. in Russian.[12] Marco Kuhlmann and Joakim Nivre. Mildly non-projective dependency structures. In
Proceedingsof the COLING/ACL 2006 Main Conference Poster Sessions , pages 507–514, 2006.[13] Igor Mel’ˇcuk.
Dependency Syntax: Theory and Practice . State University of New York Press,Albany, NY, USA, 1988.[14] Y. Shiloach. A minimum linear arrangement algorithm for undirected trees.