Finding and listing induced paths and cycles

Transcription

1 1 Finding and listing induced paths and cycles 2 3 Chính T. Hoàng Marcin Kamiński Joe Sawada R. Sritharan November 30, Abstract Many recognition problems for special classes of graphs and cycles can be reduced to finding and listing induced paths and cycles in a graph. We design algorithms to list all P 3 s in O(m p 3 (G)) time, and for k 4 all P k s in O(n k 1 + p k (G) + k c k (G)) time, where p k (G), respectively, c k (G), are the number of P k s, respectively, C k s, of a graph G. We also provide an algorithm to find a P k, k 5, in time O(m (k 1)/2 ) if k is odd, and O(nm (k/2) 1 ) if k is even. As applications of our findings, we give algorithms to recognize quasi-triangulated graphs and brittle graphs. Our algorithms time bounds are incomparable with previously known algorithms Introduction Many recognition problems for special classes of graphs can be reduced to finding and listing induced paths and cycles in a graph. For example, if we can efficiently list all P 3 s and their complements of a graph, then we can recognize quasi-triangulated graphs efficiently (definitions are given in Section 2). Also, recognizing brittle graphs is reduced to listing the P 4 s of a graph. In this paper, we provide polynomial time algorithms for finding and listing induced paths of given length. The problems of finding a triangle and listing all triangles of a graph are well known. Our results show an intimate connection between listing triangles and listing P 3 s. Our main results are an O(m p 3 (G)) algorithm to list all P 3 s of a graph G, a proof that listing the P 3 s is as difficult as listing triangles, an algorithm to find a P k, k 5, in time O(k!! m (k 1)/2 ) if k is odd, and O(k!! nm (k/2) 1 ) if k is even, and an algorithm to list all P k s in O(n k 1 + p k (G) + k c k (G)) time, where p k (G), respectively, c k (G), are the number of P k s, respectively, C k s, of a graph G. We will also provide an O(n k 1 + p k (G) + c k (G)) algorithm to list all C k s of a graph G. As applications of our findings, we give algorithms to recognize quasi-triangulated graphs and brittle graphs. Our algorithms time bounds are incomparable with previously known algorithms. Physics and Computer Science, Wilfrid Laurier University, Canada. Research supported by NSERC. choang@wlu.ca Algorithms Research Group, Département d Informatique, Université Libre de Bruxelles O8.114, CP 212, Bvd. du Triomphe, 1050 Bruxelles Marcin.Kaminski@ulb.ac.be School of Computer Science, University of Guelph, Canada. Research supported by NSERC. jsawada@uoguelph.ca Computer Science Department, The University of Dayton, Dayton, OH 45469, srithara@notes.udayton.edu, Acknowledges support from The National Security Agency, USA 1

2 e Figure 1: A non-brittle graph with no C k, k Definitions and background Let G = (V, E) be a graph. Then co-g denotes the complement of G. Let x be a vertex of G. N(x) denotes the set of vertices adjacent to x in G. For a set S of vertices not containing x, we say x is non-adjacent to S if x is not adjacent to any vertex of S. Let P k denote the induced path on k vertices, and v 1 v 2 v k the P k with vertices v 1, v 2,..., v k and edges v i v i+1 for i = 1, 2..., k 1. p k (G) denotes the number of P k s of G, and co-p k (G) denotes the number of co-p k s of G. C k, k 3, denotes the chordless cycle with k vertices and c k (G) denotes the number of C k s of G. K t denotes the complete graph on t vertices. The graph co-c 4 is usually denoted by 2K 2 and we call co-p 5 a house. The C 3 is referred to as a triangle. The paw is the graph with vertices a, b, c, d and edges ab, bc, ac, ad. The diamond is the K 4 minus an edge. Let (G), respectively, (G), co-c 4 (G), paw(g), (G), k 4 (G), denote the number of triangles, respectively, C 4, co-c 4, paws, diamonds, K 4, of G. As usual, n denotes the number of vertices and m denotes the number of edges of the input graph. A vertex x is simplicial if its neighbors form a clique. A graph G is quasi-triangulated if each of its induced subgraphs H contains a simplicial vertex in H or in co-h. A graph is chordal if it does not contain an induced C k for k 4. Chordal graphs are well studied (for more information, see [9].) It is well known that a chordal graph contains a simplicial vertex. Thus, all chordal graphs are quasi-triangulated. The C 4 is quasi-triangulated but not chordal. For a P k v 1 v 2 v k, k 4, the edges v 1 v 2, v k 1 v k are the wings of the P k ; the vertices v 1, v k are the endpoints of the P k. For a P 4 abcd, the edge bc is the rib of the P 4 ; b, c are the midpoints of the P 4. A vertex of a graph G is soft if it is not a midpoint of any P 4, or alternatively, if it is not the endpoint of any P 4. A graph is brittle if each of its induced subgraphs contains a soft vertex. Since a simplicial vertex is soft, quasi-triangulated graphs are brittle. Observe that any graph with a C k where k > 4 is not brittle. The graph G in Figure 1 (with one edge labeled e) is a non-brittle graph containing no C k, k > 4; G e is brittle and not quasi-triagulated. Quasi-triangulated graphs and brittle graphs are subclasses of perfectly orderable graphs [3] and are well studied (see [10]). Let O(n α ) be the current best complexity of the algorithm to multiply two n n matrices. It is currently known α < [4]. It is well known that finding a triangle in a graph is reduced to matrix multiplication. Thus, a triangle can be found in O(n α ) time. It follows from [1] that a triangle can be detected in time O(m 1.4 ) and all triangles can be listed in O(m 1.5 ) time. An acyclic orientation of a graph is transitive if every P 3 abc has either a b, c b, or b a, b c. It is known that testing for transitive orientations is equivalent to testing for triangles with an O(n 2 ) reduction. We will remark on this problem later. 2

3 Listing induced paths In this section we discuss the problem of efficiently listing all induced P k s in G. Naïvely, all P k s of a graph G can be listed in O(k 2 n k ) time by considering the O(n k ) sequences of k distinct vertices and testing whether or not each sequence forms a P k in O(k 2 ) time. Taking k to be a constant, this is the best bound we can hope for when p k (G) = Θ(n k ). For example, if the vertices of G are partitioned into k equal sized sets V 1, V 2,..., V k where each V i, V i+1 form a complete bipartite graph for i = 1, 2,..., k 1, then p k (G) = Θ(n k ). However, for many graphs we may expect a much smaller number for p k (G). In particular, for sparse graphs we can obtain a much better bound focusing on the number of edges m: Theorem 1 For k 1, a graph G has { O(nm p k (G) = (k 1)/2 ) if k is odd O(m k/2 ) if k is even Moreover, for k 1, all P k s of a graph G can be listed in time O(k!! nm (k 1)/2 ) if k is odd, or O(k!! m k/2 ) if k is even Proof. By induction on k. Clearly p 1 (G) = O(n) and p 2 (G) = O(m). Since each P k 2 of the form p 1 p 2 p k 2 can be extended to a P k in at most m ways, this proves the first part of the proof. Specifically, we consider each edge xy and test whether or not either p 1 p 2 p k 2 xy or p 1 p 2 p k 2 yx is a P k. This test will take O(k) time for each edge, hence proving that we can list all P k s in the given time bound. Ideally we would like to list all P k s in time O(p k (G) + m); that is it should cost only constant time per P k. This seems a very challenging task, even for k = 3. Thus, perhaps it is more reasonable to look for an algorithm with running time O(p k (G) + n t ), where t k 1. To begin, we consider a simple recursive algorithm to list all P k s for a graph G. Assume that G is represented by the adjacency lists adj[v] for each vertex v G. If we consider each vertex as the starting point of a P k, then we can generate all P k s with the algorithm ListPath shown below: function ListPath( int t ) int u for each u adj[p t 1 ] do vis[u]++ for each u adj[p t 1 ] do if vis[u] = 1 then p t := u if t < k then ListPath(t+1) else if p 1 < p t then Process(p 1 p 2 p t ) for each u adj[p t 1 ] do vis[u] end At each recursive call, we attempt to extend the induced path p 1 p 2 p t 1. To make the algorithm more efficient, for each vertex u, we maintain the value vis[u] which is the number of vertices in p 1 p 2 p t 1 that are adjacent 3

4 to u. This allows us to test whether or not a neighbour u of p t 1 can extend the induced path in constant time by checking if vis[u] = 1. To initialize the algorithm we set vis[v] := 0 for each vertex v G. Then, for vertex v G we set p 1 := v, set vis[v] := 1, make the call ListPath(2), and finally reset vis[v] := 0. To make sure we do not list the same path twice, we only visit an induced path p 1 p 2 p t if p 1 < p t (given an initial ordering on the vertices). The function Process(P k ) is an application specific function to process the path. A naïve analysis of the algorithm ListPath yields a worst case running time of O(n t ). However, for sparse graphs this bound is not tight. A more detailed analysis for small values of k will be done in the following subsections that measure the running time for a graph G with respect to the number of occurrences of certain induced subgraphs Listing P 3 s When k = 3, the algorithm ListPath is equivalent to considering each edge uv and then checking all neighbours w of u and v to see if we obtain a P 3 of the form uvw or vuw. If a neighbour w does not form a P 3 then it must be adjacent to both u and v and hence forms a triangle. Thus, an upper bound on the running time can be expressed as O(m + (G) + p 3 (G)). Each P 3 will be found twice and the algorithm can be optimized so that each triangle will be found exactly 3 times (by visiting the ordered adjacency lists for u and v at the same time). Since (G) = O(m 1.5 ), the above discussion proves the following Theorem 2 There is an O(m + (G) + p 3 (G)) = O(m p 3 (G)) algorithm to list all P 3 s of a graph G. Observe that this bound is incomparable with the O(nm) approach from Theorem 1. Thus, the algorithm ListPath will be an improvement of this simpler approach in sparse graphs where p 3 (G) = O(m 1.5 ). Note that some sparse graphs do admit Θ(m 2 ) P 3 s as observed in the n-star, i.e., a graph on n vertices and n 1 edges with a vertex of degree n 1 (every other vertex has degree one). Thus, we consider one more approach that does not visit any triangles. The following algorithm can be used to list all P 3 s, all co-p 3 s, or all P 3 s and co-p 3 s of a graph: for each isolated vertex x V do for each yz E do Process({x, y, z}) V := V {x} for each x V do for each y V N(x) {x} do for each z N(y) do if xz E and y < z then Process(yzx) if xz / E and y < z then Process({x, y, z}) In the above algorithm, we first visit all co-p 3 s that include an isolated vertex in G, removing the isolated vertices from the graph. Every vertex in the remaining graph will be adjacent to at least one other vertex. Thus, in the second part of the algorithm, the innermost for loop always iterates at least once and for each iteration either finds a P 3 (if xz E) or a co-p 3 (if xz / E). To remove duplicates, we only process those where y < z for an initial vertex ordering. 4

5 Theorem 3 There is a O(m + p 3 (G)+ co-p 3 (G)) algorithm to list: all P 3 s of a graph G, all co-p 3 s of a graph G, all P 3 s and co-p 3 s of a graph G For certain special classes of graphs, we can list P 3 s more efficiently. For example, the following result applies to diamond and house-free graphs. 114 Theorem 4 There is an O(m 2 3 n + p 3 (G))-time algorithm to list all P 3 s of a (diamond, house)-free graph G Proof. From [6] all maximal cliques of a (diamond, house)-free graph G can be listed in O(m 2 3 n) time. For a vertex v, N(v) is the union of disjoint cliques C 1,..., C k and C i {v} is a maximal clique of G. Observe that xvy is a P 3 of G if and only if x C i, y C j where i j. The result then follows Lower bound The following result shows, with a O(n 2 ) reduction, listing P 3 s is as hard as listing triangles, a well known problem. Theorem 5 If there is a f(n, m)-time algorithm to list all P 3 s of a graph, then there is a O(n 2 + f(n, m))-time algorithm to list all triangles of a graph. Proof. Given G = (V, E), construct the bipartite graph H = (X, Y, E ) as follows: X = {w 1 w V }, Y = {w 2 w V } (that is, for each vertex w V, put its copy w 1 in X, and w 2 in Y ), and E = {w 1 z 2 wz E} {w 2 z 1 wz E}. It is clear that abc is a triangle in G if and only if a 1 b 2 c 1 is a P 3 of H such that a is adjacent to c in G. As H can be constructed from G in linear time, listing all the P 3 s of H in f(n, m) time enables us to list all the triangles of G in O(n 2 + f(n, m)) time Listing P 4 s In addition to analyzing the algorithm for ListPath when k = 4, we will also consider three other approaches for listing all P 4 s of a graph G. These three approaches can be summarized as follows: 1. Consider pairs of edges as potential wings of a P 4 and test if exactly one endpoint of each edge is adjacent. 2. Consider all edges as a potential ribs of a P 4 and visit the neighbourhoods of each endpoint. 3. Consider each vertex as an endpoint of a P 4, and perform a BFS (Breadth-First Search) 4 levels deep. By keeping track of cross edges use the BFS tree to find all P 4 s. For the algorithm ListPath for k = 4, we consider the possible subgraphs at each level of computation. After three vertices have been added, we have exactly the analysis for generating P 3 s: O(m + (G) + p 3 (G)). When 5

6 adding a fourth vertex there are four possible induced subgraphs: a P 4 s, C 4, paw, or diamond. Thus, an upper bound on the running time can be expressed as: O(m + (G) + p 3 (G) + (G) + paw(g) + (G) + p 4 (G)) For the first alternate approach, we consider all pairs of edges uv and wx. If the two edges share a common endpoint, then we have either a P 3 or a triangle. If all four vertices are distinct, then we will obtain one of the following induced subgraphs on the four vertices: a 2K 2, P 4 s, C 4, paw, diamond, K 4. A simple analysis yields Θ(m 2 ), but using occurrences of these subgraphs we get: O( (G) + p 3 (G) + co-c 4 (G) + (G) + paw(g) + (G) + k 4 (G) + p 4 (G)) Note this alternate approach gives a bound worse than that of the ListPath algorithm. For the second alternate approach, we consider each edge uv as potential rib of a P 4, and then consider elements of the cross product of the adjacency lists of u and v as the potential endpoints of a P 4. For a P 4 to be possible, the size of each adjacency list must be greater than 1 to account for their shared edge. If this condition is satisfied, then the possible subgraphs are: P 4, C 4, paw, diamond, or K 4. However, we can make a small improvement by first scanning the two adjacency lists concurrently (assuming the lists are ordered) and removing common vertices. Each vertex removed will correspond to a triangle. If each adjacency list still has more than one vertex, then we charge the non removed vertices to the cross product operation which will yield either a P 4 or a C 4. If after removing all shared vertices one of the adjacency lists has size 1, then we need to account for the vertices visited that are not shared. Since each such vertex forms a P 3, we can use the number of P 3 s as an upper bound. Once this step is completed, we must make one more pass through the adjacency lists to insert back the removed vertices. This algorithm will take: O(m + (G) + p 3 (G) + (G) + p 4 (G)) = O(m p 3 (G) + (G) + p 4 (G)) = O(nm + (G) + p 4 (G)). 155 Thus, for C 4 -free graphs, we have the following result. 156 Theorem 6 There is an O(nm + p 4 (G)) algorithm to list all P 4 s of a C 4 -free graph G The final approach uses some pre-processing that will be beneficial in a paw-free graph. We consider each vertex u as the potential endpoint of a P 4. Then we perform a BFS starting from u up to 4 levels that constructs a parent list for each vertex v visited containing all neighbors of v in the previous level. Clearly by following any path from a vertex in the 4th level back to u we obtain a P 4, and all such paths can be easily found recursively using the parent pointer. In addition to such P 4 s, a P 4 may also exist with two vertices in the third level. Thus when we perform our BFS, we must also keep track of all edges whose endpoints are both in the third level. For each such edge xw we scan the parent lists of each vertex. If they share a parent then we have a paw, but for each parent of one vertex that is not in the parent list of the other, we find a P 4. To handle equivalent P 4 s, we only list those where the first vertex is greater than the last vertex for some given vertex ordering. This algorithm will take: O(nm + paw(g) + p 4 (G)). Thus, we have the following result. 168 Theorem 7 There is an O(nm + p 4 (G)) algorithm to list all P 4 s of a paw-free graph G. 6

7 If a graph is either paw-free or C 4 -free then we have algorithms that run in time O(nm + p 4 (G)). An open question is whether or not there exists an algorithm that runs in time O(n 3 +p 4 (G)) to list all P 4 s for an arbitrary graph G Listing P k s In this subsection, we consider two general approaches to list all P k s of a graph G. First, recall that the algorithm ListPath for k = 3 runs in time O(m p 3 (G)). Extending this algorithm to k = 4, observe that in the worst case we perform O(n) extra work for each P 3. Thus, we can generate all P 4 s in O(m n p 3 (G)). The following generalizes this observation for larger k. 177 Theorem 8 There is an O(m n k 3 p 3 (G)) algorithm to list all P k s of a graph G Our second approach extends the rib approach we used to list all P 4 s; however instead of a rib we start by considering a P k 2. If L is a list of all P k 2 s in G, the following approach will list all P k s: for each P := p 1 p 2 p k 2 L do A := set of vertices adjacent to p 1 and non-adjacent to P {p 1 } B := set of vertices adjacent to p k 2 and non-adjacent to P {p k 2 } for each (a, b) A B do if ab / E then Process( ap b ) To analyze this algorithm, observe that A and B can be computed in O(kn) time and the nested for loop either generates a P k or a C k (when ab E). Also note that each C k will be generated k times. Thus, using the upper bound of O(n k 2 ) for the number p k 2 (G), we obtain an overall running time bound of O(kn k 1 + p k (G) + k c k (G)) for this algorithm. The factor k in front of the term n k 1 is somewhat undesirable; however, this factor can be eliminated by modifying the algorithm to start with P k 4 s as follows: for each P := p 1 p 2 p k 4 L do A := set of vertices adjacent to p 1 and non-adjacent to P {p 1 } B := set of vertices adjacent to p k 4 and non-adjacent to P {p k 4 } C := set of vertices non-adjacent to P for each (a, b) A B do if ab / E then A := subset of C adjacent to a but not b B := subset of C adjacent to b but not a for each (u, v) A B do if uv / E then Process( uap bv ) 185 Theorem 9 There is a O(n k 1 + p k (G) + k c k (G)) algorithm to list all P k s of a graph G. 7

8 186 Corollary 1 There is a O(n k 1 + p k (G)) algorithm to list all P k s of a C k -free graph G Listing C k Observe, that many of the algorithms for listing P k s can easily be modified to list all C k s. In particular, to apply the algorithm immediately preceding Theorem 9, observe that we will find all C k s if uv E in the final statement of the algorithm. However, one extra challenge for cycles is to easily identify duplicates. This can be done by ensuring that we only list cycles of the form C = c 1 c 2 c k where c 1 is the smallest vertex in C and c 2 < c k. There are three steps to doing this efficiently. First, when we list the P k 4, we must keep track of the smallest vertex in the induced path as the path gets generated. This can easily be done in constant time. Second, we do not consider a P k 4 unless the smallest vertex is p 1. Finally, when we consider (u, v) in the final for loop, we will find a representative C k of the form P bvua if and only if p 1 is smaller than each of b, v, u, a and p 2 < a. Observe that each C k will be tested at most a constant number of times. Thus, the algorithm for listing C k s yields an improved bound compared to the one we give to list P k s. 198 Theorem 10 There is a O(n k 1 + p k (G) + c k (G)) algorithm to list all C k s of a graph G For the special case of k = 4, observe that the algorithm used to prove Theorem 6 can also be adapted to obtain the following result (which is an improvement for sparse graphs). 201 Theorem 11 There is an O(nm + p 4 (G) + c 4 (G)) algorithm to list all C 4 s of a graph G For sparse graphs, we can also make simple modifications to the proof of Theorem 1 to obtain similar results for cycles. Using the techniques just described, we can easily obtain only the representative cycles with constant time testing. Theorem 12 All C k s of a graph G can be listed in time O(k!! nm (k 1)/2 ) if k is odd, or O(k!! m k/2 ) if k is even Finding induced paths One can find a P 3 in linear time since a graph contains a P 3 if and only if it has a component that is not a clique. It is also known that finding a P 4 (if one exists) in a graph can be done in linear time [5]. In this section, we give an algorithm for finding a P k, k 5, that is better than the naïve O(n k ) algorithm. We first consider an auxiliary problem. Problem P1. Let a be a vertex of G and let B be a subset of V {a}. Is there a P 4 of the form abcd where b, c, d B? This problem can be answered in O(nm) time using the following approach: for each b N(a) and each cd E with b, c, d B, test if abcd is a P 4. However, it is possible to achieve a more efficient algorithm for Problem P1 by computing certain components. In particular, if B is the subset of vertices in B that are not adjacent to a, then compute the components C 1, C 2,..., C t for the subgraph of G induced by B. The desired P 4 exists if and only if there is a vertex b N(a) B that is adjacent to some but not all vertices of some C i. The following provides a detailed explanation of how we efficiently test each b: 8

9 B := B N(a) C 1, C 2,..., C t := components of the subgraph of G induced by B initialize counters c 1, c 2,..., c t to 0 L := an empty list for each b N(a) B do for each c N(b) B do j := index of component containing c c j ++ if c j = 1 then add j to L for each j L do if c j < C j then return yes c j := 0 remove j from L return no The components can be computed in O(m) time and it is easy to maintain which component each vertex belongs to. The first nested for loop visits a unique edge bc, and the second nested for loop is executed at most the same number of times as the first for loop. Thus, the overall running time is O(m). Observe that if we did not maintain the list L, the second nested for loop could be altered to test if 0 < c j < C j for each 1 j t. However, in the worst case there may be O(n) components and hence the running time would be O(n 2 ). When the algorithm return yes, we can produce a P 4 as follows. Retrieve the current vertex b and component C j. Let X, respectively, Y, be the set of vertices of C j adjacent, respectively, non-adjacent, to b. Find an edge xy with x X, y Y. Since C j is connected, such edge exists. Then, abxy is the desired P 4. The above discussion establishes the following theorem. 229 Theorem 13 Problem P1 can be solved in O(m) time. 230 Theorem 14 There is an O(m 2 ) algorithm to find a P 5 in a graph G if one exists Proof. For each edge uv, we test if uv extends into a P 5 of the form uvwxy or vuwxy for some vertices w, x, y. This is done by solving Problem P1 with a = v and B = V N(u) (respectively, a = u and B = V N(v)) Theorem 15 For k 5, a P k, if one exists, can be found in a graph G in time (i) O(k!! m (k 1)/2 ) if k is odd, (ii) O(k!! nm (k/2) 1 ) if k is even Proof. We have seen the theorem holds for k = 5. Suppose k > 5. We list all P k 3 s. For each of these paths, we test if it can be extended into a P k. Consider a path v 1 v 2 v k 3. We test in time O(m) that this path can be extended into a P k v 1 v 2 v k 3 bcd by solving Problem P1 with a = v k 3 and B = V (N(v 1 ) N(v 2 )... N(v k 4 )). Using the bound to list all P k 3 s given in Theorem 1, the result follows. 9

10 A note on finding C 4 and C 5 The purpose of this section is to show that finding C 4 and C 5 are related to finding certain P 4 s in a graph. It is known a C k, k 4, can be found in O(n k 3+α ) time [13]. In particular, a C 4, respectively, C 5, can be found in O(n ), respectively, O(n ), time. Intuitively, finding a C k (respectively, P k ) should be at least as hard as finding a C k 1 (respectively, P k 1 ), for k 4. But this seems to be a challenging problem. We do not even have a solution in the case k = 4. We will show that finding a C 5 is at least as hard as finding a triangle. First, consider the following Problem P2. Let the vertices of a graph G be partitioned into two sets A, B. Is there a P 4 of the form abcd where a, d A, and b, c B? We can find a C 5 as follows: For each vertex x, define A = N(x), B = V A {x}. Then x belongs to a C 5 if and only if Problem P2 has a positive answer on the sets A, B. So, if we can solve Problem P2 in O(n 3 ) time, then we can find a C 5 in O(n 4 ) time. Theorem 16 Problem P2 is at least as hard as finding a C Proof. Let G be an instance of the problem of finding a C 4. We will construct an instance H of Problem P2. Let B be a copy of G and A be a copy of the complement of G. For a vertex x A and a vertex y B, add the edge xy if x = y (x and y are the same vertex in G), or xy is an edge in G. Suppose G contains a C 4 abcd. Then H contains a P 4 abcd with a, d A, b, c B (actually, H contains four such P 4 s). Now, suppose H contains a P 4 abcd with a, d A, b, c B. a and b cannot be the same vertex in G, for otherwise a is adjacent to c in H, a contradiction. Similarly, c and d are different vertices in G. Thus, G contains the C 4 abcd. The above shows it will be difficult to solve Problem P2 in O(n 3 ) time since finding a C 4 in O(n 3 ) time is a well known open problem. Can we prove finding a C 5 is at least as hard as finding a C 4? Consider the following problem: Problem P3. Given a graph G, a vertex x. Is there a C 5 of G containing x? Note that Problems P2 and P3 are equivalent in linear time. Theorem 17 Problem P3 is at least as hard as finding a triangle Proof. Given G with vertex set V = {1, 2,..., n}, construct H as follows. Make four copies H 1, H 2, H 3, H 4 of V. For vertices i H t, j H t+1, if ij is an edge of G, then add the edge between the copy of i H t and j H t+1 for t = 1, 2, 3. For vertices i H 1, j H 4, i j, add the edge between the copy of i H 1 and j H 4. Observe that H is bipartite. Add a vertex x adjacent to all vertices in H 1 H 4. Suppose there is a C 5 = xpqrs containing x in H. It is easy to see that each of {p, q, r, s} is in a distinct H i. Without loss of generality, we may assume p H 1, s H 4. p and s must be copy of the same vertex of G. Therefore, p, q, r form a triangle in G. Suppose G contains a triangle pqr. Then H contains the C 5 xpqrp. Note that in the above proof, any C 5 of H must contain x. So, testing for a C 5 is at least as hard as testing for a triangle. Now, one may want to prove the converse of Theorem 16. But this would mean that finding a C 4 is at least as hard as finding a triangle which is a long standing open problem. 10

11 A modification of the construction in [13] shows that deciding whether there is a C 5 containing a given edge can be solved in O(n α ) time. Therefore Problem P3 can be solved in time O(n α+1 ) by, for each edge incident to x, testing if there is a C 5 containing it Applications The ability to recognize whether or not a graph G belongs to a class C has been widely studied for many graph classes. Many classes of graphs, including chordal graphs, strongly chordal graphs, quasi-triangulated graphs and brittle graphs have particular special vertices that can be used to solve the recognition problem. For such a class C and its corresponding special vertex definition, the following generic approach can be used to determine if G belongs to C: L:= list of special vertices while L not empty do remove a vertex v from L remove v from G update L if G is empty then return G C return G / C The overall running time of this approach is dependent on the time to initialize and update L. For quasitriangulated graphs and brittle graphs, we will use listings of appropriate P k s that will optimize these steps Recognizing quasi-triangulated graphs For quasi-triangulated graphs, the special vertices are those that are either simplicial (not a middle vertex of any P 3 ) or co-simplicial (not an isolated vertex in any co-p 3 ). Using the generic recognition algorithm, we can optimize the initialization and maintenance of these special vertices as follows: List and store all P 3 s and co-p 3 s in a table T, for each vertex v let Q[v] be a list of pointers to all items in T containing v, for each vertex v let mid[v] hold the number of P 3 with v as a midpoint for each vertex v let iso[v] hold the number of co-p 3 with v as the isolated vertex store all special vertices v (those with mid[v] = 0 or iso[v] = 0) in a list L. While constructing the table T it is easy to update the values for Q, mid, and iso in constant time per table element. Observe that this pre-computation runs in time proportional to the time it takes to list the P 3 s and co-p 3 s. To maintain these data structures as a special vertex s is removed from L and G, remove all the elements from T pointed to by Q[s]. When removing a P 3 avb the value mid[v] is decremented; when removing a co-p 3 with v as the isolated vertex the value iso[v] is decremented. If either mid[v] = 0 or iso[v] = 0 after an update, insert v into L. Observe that each item in T is removed at most once, and thus quasi-triangulated graphs can be recognized in the time it takes to list all P 3 s and co-p 3 s. Thus, Theorem 3 leads to the following result. 11

12 303 Theorem 18 There is a O(m + p 3 (G)+ co-p 3 (G)) algorithm to recognize quasi-triangulated graphs The above result give time bound for recognition of quasi-triangulated graphs that is incomparable to the bounds of O(n 2.77 ) given in [14] Recognizing brittle graphs The following simple approach, which is folklore ([12], page 31), can be used to recognize brittle graphs: If there exists a soft vertex, remove it. Repeat this process until there is no soft vertex or the graph is empty. If the graph is empty, the graph is brittle; otherwise it is not brittle. The key to this algorithm is to detect soft vertices. The following method uses significant pre-computation: List and store all P 4 s in a table, for each vertex v let Q[v] be a list of pointers to all the P 4 s containing v, for each vertex v let mid[v] hold the number of P 4 s with v as a midpoint, for each vertex v let end[v] hold the number of P 4 s with v as an endpoint, store all soft vertices v (those with mid[v] = 0 or end[v] = 0) in a list L. While computing the P 4 s, it is easy to update the values for Q, mid and end in constant time per P 4. Observe that this pre-computation runs in time proportional to the time it takes to list the P 4 s. To maintain these data structures as a soft vertex s is removed from L and the graph, remove all the P 4 s pointed to by Q[s] from the table. When removing a P 4, the values mid[u], end[u] are updated for each u (not equal to s) in the P 4. If u becomes soft, it is inserted into L. Observe that each P 4 is removed at most once, and thus brittle graphs can be recognized in the time it takes to list all P 4 s. The results from Section 3 lead to the following three theorems: 322 Theorem 19 A brittle graph G can be recognized in O(m n p 3 (G)) time. 323 Theorem 20 A brittle graph G can be recognized in O(nm + p 4 (G) + paw(g)) time. 324 Theorem 21 A brittle graph G can be recognized in O(nm + p 4 (G) + (G)) time The above results give time bounds for recognition of brittle graphs that is incomparable to the bounds of O(n ) or O(n 3 log n log n) given in [7], and the bound O(m 2 ) given in [12] Testing for transitive orientations Recall an acyclic orientation of a graph is transitive if every P 3 abc has either a b, c b, or b a, b c. We will describe a connection between transitivity testing and finding a triangle. Consider the following problems: Problem A: Given directed acyclic graph G, is G transitively oriented? Problem B: Given graph G, does G contain a triangle? 12

13 Spinrad [15] has shown that each of the above problems can be reduced to the other in O(n 2 ) time. The derived (directed) graph in the reduction has O(n) vertices, but it can have Ω(n 2 ) (directed) edges. Thus, the current best algorithm to solve Problem A is via the use of boolean matrix multiplication (set the diagonal entries of the adjacency matrix A of the directed acyclic graph to 1, and then check whether A equals A 2 ) and it runs in O(n α ) time. By listing all P 3 s and checking that each one is properly oriented, we can solve Problem A in time O(m + (G) + p 3 (G)) = O(m p 3 (G)), thus obtaining an incomparable time complexity. Our algorithm is faster on graphs with few triangles and P 3 s such as long induced paths References [1] N. Alon, R Yuster, U. Zwick, Finding and counting given length cycles, Algorithmica 17 (1997) [2] A. Brandstädt, V.B. Le, J.P. Spinrad, Graph Classes: A Survey, SIAM Monographs on Discrete Math. Appl., Vol. 3, SIAM, Philadelphia (1999). [3] V. Chvátal, Perfectly orderable graphs, in: C. Berge, V. Chvátal, Topics in Perfect Graphs, Annals of Discrete Mathematics, 21 (1984), Amsterdam: North-Holland, pp [4] D. Coppersmith, S. Winograd, Matrix multiplication via arithmetic progressions, Journal of Symbolic Computation 9:3 (1990) [5] D. G. Corneil, Y. Perl, L. K. Stewart, A linear recognition algorithm for cographs, SIAM Journal on Computing 14 (1985) [6] E. M. Eschen, C. T. Hoàng, J. P. Spinrad, R. Sritharan, On graphs without a C 4 or a diamond, to appear in Discrete Applied Mathamatics. [7] E. M. Eschen, J. L. Johnson, J. P. Spinrad, R. Sritharan, Recognition of some classes of perfectly orderable graphs, Discrete Applied Mathamatics 128 (2003) [8] I. Gorgos, C. Hoàng, V. Voloshin, A note on quasi-triangulated graphs, SIAM J. Discrete Math. 20:3 (2006) [9] M.C. Golumbic. Algorithmic Graph Theory and Perfect Graphs. Academic Press, [10] C. T. Hoàng. Perfectly orderable graphs: a survey. In: Perfect Graphs. J. L. Ramirez-Alfonsin and B. A. Reed (Editors), pp Wiley, [11] R. M. McConnell, J. Spinrad, Linear-time transitive orientation, 8th ACM-SIAM Symposium on Discrete Algorithms (1997) [12] A. A. Schäffer, Recognizing brittle graphs: remarks on a paper of Hoàng and Khouzam, Discrete Applied Mathematics 31 (1991) [13] J. P. Spinrad, Finding large holes, Information Processing Letters 39 (1991) [14] J. P. Spinrad, Recognizing quasi-triangulated graphs, Discrete Applied Mathematics 139 (2004) [15] J. P. Spinrad, Personal communication. 13