Finding Small Complete Subgraphs Efficiently 111 A preliminary version of this paper appeared in the Proceedings of the 34th International Workshop on Combinatorial Algorithms (IWOCA 2023), LNCS 13889, Springer, Cham, Switzerland, 2023, pp. 185–196.
Abstract
(I) We revisit the algorithmic problem of finding all triangles in a graph with vertices and edges. According to a result of Chiba and Nishizeki (1985), this task can be achieved by a combinatorial algorithm running in time, where is the graph arboricity. We provide a new very simple combinatorial algorithm for finding all triangles in a graph and show that is amenable to the same running time analysis. We derive these worst-case bounds from first principles and with very simple proofs that do not rely on classic results due to Nash-Williams from the 1960s.
(II) We extend our arguments to the problem of finding all small complete subgraphs of a given fixed size. We show that the dependency on and in the running time of the algorithm of Chiba and Nishizeki for listing all copies of , where , is asymptotically tight.
(III) We give improved arboricity-sensitive running times for counting and/or detection of copies of , for small . A key ingredient in our algorithms is, once again, the algorithm of Chiba and Nishizeki. Our new algorithms are faster than all previous algorithms in certain high-range arboricity intervals for every .
Keywords: triangle, subgraph detection/counting, graph arboricity, rectangular matrix multiplication.
1 Introduction
The problem of deciding whether a given graph contains a complete subgraph on vertices is among the most natural and easily stated algorithmic graph problems. If the subgraph size is part of the input, this is the Clique problem which is NP-complete [17]. For every fixed , determining whether a given graph contains a complete subgraph on vertices can be accomplished by a brute-force algorithm running in time.
For , deciding whether a graph contains a triangle and finding one if it does, or counting all triangles in a graph, can be done in time by the algorithm of Itai and Rodeh [16], where is the exponent of matrix multiplication [1, 7], and is the best known bound [10, 36]. The algorithm compares and , where is the graph adjacency matrix; if there is a pair of indexes such that , then there is a triangle based on edge . An equivalent characterization is: contains a triangle iff has a non-zero entry on its main diagonal. See [25, Ch. 10] for a short exposition of this elegant method. Alternatively, this task can be done in time by the algorithm of Alon, Yuster, and Zwick [3], which deals with vertices of high and low degree separately. Itai and Rodeh [16] and also Papadimitriou and Yannakakis [30] as well as Chiba and Nishizeki [6] showed that triangles in planar graphs can be found in time.
For , deciding whether a graph contains a and finding one if it does (or counting all ’s in a graph) can be done in time by the algorithm of Alon, Yuster, and Zwick [3], in time by the algorithm of Eisenbrand and Grandoni [12], and in time by the algorithm of Kloks, Kratsch, and Müller [18].
In contrast to the problem of detecting the existence of subgraphs of a certain kind, the analogous problem of listing all such subgraphs has usually higher complexity, as expected. For example, finding all triangles in a given graph (each triangle appears in the output list) can be accomplished in time and with space by an extended version of the algorithm of Itai and Rodeh [16]. Bar-Yehuda and Even [4] improved the space complexity of the algorithm from to by avoiding the use of the adjacency matrix. Chiba and Nishizeki [6] further refined the time complexity in terms of graph arboricity, which is the minimum number of edge-disjoint forests into which its edges can be partitioned. Their algorithm lists all triangles in a graph in time, where is the arboricity of the graph. They also showed that ; consequently, the running time is .
If is planar, (see [15, p. 124]), so the algorithm runs in (i.e., linear) time on planar graphs. Since there are graphs with , this does not improve the worst-case dependence on (which, in fact, cannot be improved). For every fixed , the same authors gave an algorithm for listing all copies of in time.
We distinguish several variants of the general problem of finding triangles in a given undirected graph : (i) the triangle detection (resp., finding) problem is that of deciding if is triangle-free (resp., finding a triangle in otherwise); (ii) the triangle counting problem is that of determining the total number of triangles in ; (iii) the triangle listing problem is that of listing (reporting) all triangles in , with each triangle appearing in the output list. Obviously, any algorithm for listing all triangles can be easily transformed into one for triangle detection or into one for listing a specified number of triangles, by stopping after the required number of triangles have been output.
Our results.
We obtain the following results for the problem of finding small complete subgraphs of a given size. Each of our algorithms for deciding whether a graph contains a given complete subgraph (item (iii) below) also finds a suitable witness, if it exists.
-
(i)
We provide a new combinatorial algorithm for finding all triangles in a graph running in time, where is the graph arboricity (Algorithm Hybrid in Section 2). We derive these worst-case bounds from first principles and with very simple proofs that do not rely on classic results due to Nash-Williams from the 1960s.
- (ii)
-
(iii)
We give improved arboricity-sensitive running times for counting and/or detection of copies of , for small (Section 4). A key ingredient in our algorithms is the algorithm of Chiba and Nishizeki. Our new algorithms beat all previous algorithms in certain high-range arboricity intervals for every . We also provide up-to-date running times based on rectangular matrix multiplication times.
Preliminaries and notation.
Let be an undirected graph. The neighborhood of a vertex is the set of all adjacent vertices, and its cardinality is called the degree of in . A clique in a graph is a subset of vertices, each pair of which is connected by an edge in . The Clique problem is to find a clique of maximum size in . An independent set of a graph is a subset of vertices such that no two of them are adjacent in .
Unless specified otherwise: (i) all algorithms discussed are assumed to be deterministic; (ii) all graphs mentioned are undirected; (iii) all logarithms are in base .
It should be noted that the asymptotically fastest algorithms for matrix multiplication have mainly a theoretical importance and are otherwise largely impractical [24, Ch. 10.2.4]. As such, any algorithm that employs fast matrix multiplication (FMM) inherits this undesirable feature. Whereas the notion of “combinatorial” algorithm does not have a formal or precise definition, such an algorithm is usually simpler to implement and practically efficient, see [35]. Combinatorial algorithms are sometimes theoretically less efficient than non-combinatorial ones but practically more efficient since they tend to be simpler to implement.
Graph parameters.
For a graph , its arboricity is the minimum number of edge-disjoint forests into which can be decomposed [6]. For instance, it is known and easy to show that . A characterization of arboricity is provided by the following classic result [26, 27, 34]; see also [9, p. 60].
Theorem 1.
(Nash-Williams 1964; Tutte 1961) A multigraph can be partitioned into at most forests if and only if every set induces at most edges.
The degeneracy of an undirected graph is the smallest number for which there exists an acyclic orientation of in which all the out-degrees are at most . The degeneracy of a graph is linearly related to its arboricity, i.e., ; more precisely ; see [3, 13, 23, 39].
It is worth noting that high arboricity is not an indication for the graph having many (or any) triangles. Indeed, the complete bipartite graph , or any of its dense subgraphs has arboricity but no triangles.
1.1 Triangle Finding Algorithms
To place our algorithm in Section 2 in a proper context, we first present a summary of previous work in the area of triangle finding and enumeration.
The algorithms of Itai and Rodeh (1978).
The authors gave three methods for finding triangles. Initially intended for triangle detection, the first algorithm [16] runs in time. It can be extended to list all triangles within the same overall time and works as follows:
The second is a randomized algorithm that checks whether there is an edge contained in a triangle. It runs in worst-case time and expected time. The third algorithm relies on Boolean matrix multiplication and runs in time. (Boolean matrix multiplication can be reduced to standard matrix multiplication; see [24, Ch. 10.2.4] for details.)
The algorithm of Chiba and Nishizeki (1985).
The algorithm uses a vertex-iterator approach for listing all triangles in . It relies on the observation that each triangle containing a vertex corresponds to an edge joining two neighbors of . The graph is represented with doubly-linked adjacency lists and mutual references between the two stubs of an edge ensure that each deletion takes constant time. A more compact version described by Ortmann and Brandes [29] is given below.
The authors [6] showed that their algorithm runs in time. As a corollary, the number of triangles is as well. The upper bound on the number of triangles in a graph is likely older than these references indicate. In any case, other proofs are worth mentioning [11, 19], including algebraic ones [31]. We derive yet another one in Section 2.
Ortmann and Brandes [29] gave a survey of other approaches, including edge-iterators. Algorithms in this category iterate over all edges and intersect the neighborhoods of the endpoints of each edge. A straightforward neighborhood merge requires time per edge , but this is not good enough to list all triangles in time. Two variants developed by Shanks [32] use extra space to represent neighborhoods in hash sets and obtain the intersection in time, which suffices for listing all triangles in time.
The algorithm of Alon, Yuster and Zwick (1997).
The authors showed that deciding whether a graph contains a triangle and finding one if it does (or counting all triangles in a graph) can be done in time [3]. The idea is to find separately triangles for which at least one vertex has low degree (for an appropriately set threshold) and triangles whose all three vertices have high degree. Triangles of the latter type are handled by applying matrix multiplication to a smaller subgraph.
Recent algorithms.
Björklund et al. [5] obtained output-sensitive algorithms for finding (and listing) all triangles in a graph; their algorithms are tailored for dense and sparse graphs. Several approaches [14, 20] provide asymptotic improvements by taking advantage of the bit-level parallelism offered by the word-RAM model. Although they do not appear to be very practical, these methods asymptotically improve on the running time of the earlier algorithms (in particular that in [6]). If the number of triangles is small, Zechner and Lingas [38] showed how to list all triangles in time.
2 A Simple Hybrid Algorithm for Listing All Triangles
In this section we present a new algorithm for listing all triangles. While its general idea is not new, the specific hybrid data structure therein does not appear to have been previously considered. Using both an adjacency list representation and an adjacency matrix representation of the graph yields a very time-efficient neighborhood merge (intersection) procedure. Let and let be the adjacency matrix of . A triangle with is reported when edge is processed, and so each triangle is reported exactly once. For each edge , the algorithm scans the adjacency list of the endpoint of lower degree (among and ) and for each neighbor it checks for the needed entry in the adjacency matrix corresponding to the third triangle edge.
We subsequently show that the algorithm runs in time . Whereas the space used is quadratic, the hybrid algorithm appears to win by running time and simplicity. In particular, no additional data structures nor hashing are used, no sorting (by degree or otherwise) and no doubly linked lists are needed, etc. Similar algorithms that use hashing in order to run in linear space are to times slower than their “unoptimized” counterparts on most graphs with about vertices in the study in [32, 33]. “The two algorithms edge-iterator-hashed and forward-hashed, which use hashed data structures for every node, perform badly” on such graphs, the authors write [33, p. 8].
2.1 The Analysis
Define the following function on the edges of . For , let
(1) |
There are at most triangles based on edge and overall at most triangles in . The runtime of the algorithm is proportional to this quantity; the space used is quadratic. A short and elegant decomposition argument by Chiba and Nishizeki [6, Lemma 2] shows that
(2) |
thus our algorithm runs in time . The same analysis applies to the algorithm of Chiba and Nishizeki [6]. By Theorem 1, the above authors deduced that , which implies that for a connected graph . As such, both algorithms run in time on any graph.
Lemma 1 below shows how to bypass the Nash-Williams arboricity bound (Theorem 1) and deduce the upper bound for listing all triangles in a graph from first principles.
Lemma 1.
Let be a graph on vertices with edges. Then
Proof.
(folklore) There are two types of edges :
-
1.
-
2.
There are at most edges of type 1 and each contributes at most to , so the total contribution from edges of this type is at most .
Each edge of type 2 connects two nodes of degree , and there are at most such nodes. The degree of each of them thus contributes to at most times and the sum of all degrees of such nodes is at most . It follows that the total contribution from edges of type 2 is at most .
Overall, we have . ∎
Remarks.
3 Constructions
Lemma 2.
For every and , there exists a graph of order with edges that contains triangles.
Proof.
Let be the unique integer such that . Note that . Let where , , and . Set induces a complete subgraph and set induces an independent set in . Add edges to arbitrarily so that has edges. Let be the set of triangles in . We have
By Lemma 1, contains triangles, as required. ∎
Lemma 3.
Let be a fixed integer. For every and , there exists a graph of order with that has copies of , where is the number of edges in and is the arboricity of .
Proof.
We may assume that is even and . Suppose that . Let , where , and , . Set consists of complete subgraphs of order whereas is an independent set of size in . All edges in are present in . See Fig. 1.

Let be the set of complete subgraphs of order . We have
Note that the arboricity of is bounded from above by . Indeed, , since and the edges in can be partitioned into stars centered at the vertices in . ∎
4 Finding Small Complete Subgraphs Efficiently
In this section we address the problem of detecting the presence of for a fixed . We combine and refine several approaches existent in the literature of the last years to obtain faster algorithms in general and for a large class of graphs with high arboricity. In particular, we will use the algorithm of Chiba and Nishizeki [6] for listing all copies of in time. Our algorithms are formulated for the purpose of counting but they can be easily adapted for the purpose of detection.
The basic idea is as follows: since listing is generally slower than counting or detection, one can use a hybrid—decomposition based—approach that combines listing in Part A with counting or detection in Part B.
Recall that is the exponent of matrix multiplication [1, 7, 36], namely the infimum of numbers such that two real matrices can be multiplied in time (operations). Similarly, let stand for the infimum of numbers such that an matrix can be multiplied by an matrix in time (operations). For simplicity and as customary (see, e.g., [3, 28]), we write that two matrices can be multiplied in time, since this does not affect our results; and similarly when multiplying rectangular matrices.
The extension method.
The algorithm solves the detection (or counting) problem for a complete subgraph . Let denote the running time of the algorithm for a graph with vertices and edges. Write , for a suitable choice . At the beginning, we run the algorithm of Chiba and Nishizeki to form a list of subgraphs isomorphic to . Then, for each subgraph on the list: (i) we construct the subgraph of induced by vertices in that are adjacent to all vertices in ; and (ii) we count the subgraphs isomorphic to in (or find one such subgraph); this is a (possibly recursive) call of the same procedure on a smaller instance. In other words, we count the number of extensions of the subgraph isomorphic to to a . Another formulation of this method can be found in [21].
There are copies of and they can be found in time. For each fixed copy of , the time spent in is at most , and so the overall time satisfies the recurrence
Each copy of is generated exactly times and so the total count needs to be divided by this number in the end.
The triangle method and its refinement.
The algorithm solves the detection (or counting) problem for a complete subgraph . Nešetřil and Poljak [28] showed an efficient reduction of detecting and counting copies of any complete subgraph to the aforementioned method of Itai and Rodeh [16] for triangle detection and counting. To start with, consider the detection of complete subgraphs of size . For a given graph with vertices, construct an auxiliary graph with vertices, where each vertex of is a complete subgraph of order in . Two vertices in are connected by an edge if and all edges in are present in ; equivalently, is a complete subgraph on vertices. The detection (or counting) of triangles in yields an algorithm for the detection (or counting) of ’s in , running in time. For detecting complete subgraphs of size , where , the algorithm can be adapted so that it runs in time.
The triangle method can be extended to larger subgraphs, i.e., if , for some , and , the algorithm tries to detect a in ; see also [21]. We give a few applications at the end of this section.
Here we focus on . For convenience, define the following integer functions
(3) | ||||
(4) |
With this notation, the algorithm runs in time. Two decades later, Eisenbrand and Grandoni [12] refined the triangle method by using fast algorithms for rectangular matrix multiplication instead of those for square matrix multiplication. It partitions the graph intro three parts roughly of the same size: , , . The refined algorithm runs in time time. If the rectangular matrix multiplication is carried out via the straightforward partition into square blocks and fast square matrix multiplication (see, e.g., [8, Exercise 4.2-6]), one recovers the time complexity of the algorithm of Nešetřil and Poljak; that is, , see [12] for details. Eisenbrand and Grandoni [12] showed that the above inequality is strict for a certain range: if and , or . In summary, their algorithm is faster than that of Nešetřil and Poljak in these cases. We subsequently refer to their method as the refined triangle method. Another extension of the triangle method is considered in [21].
A problem of Kloks, Kratsch, and Müller.
The authors asked [18] whether there is an algorithm for deciding whether a graph contains a , if is a multiple of . Eisenbrand and Grandoni showed that this is true for every multiple of at least . Indeed, by their Theorem 2 [12], this task can be accomplished in time for every , with as in (3). If , where , then
It follows that the running time is . The proof of the theorem is rather involved. Here we provide an alternative simpler argument that also yields an arboricity-sensitive bound, item (i) below.
General case derivations.
We first consider the general cases: (i) , ; (ii) , ; and (iii) , . It will be evident that our algorithms provide improved bounds for every . For a given , we shall consider the interval
-
(i)
, . We use the triangle method with a refined calculation. The vertices of the auxiliary graph are subgraphs isomorphic to . By the result of Chiba and Nishizeki [6], has vertices. The algorithm counts triangles in in time proportional to
For (the entries in Table 1), these runtimes are , , and , respectively.
Since , the above expression is bounded from above as follows:
Next, we show that for a certain high-range of , the new bound beats all previous bounds, namely and , for (or ). Let , where . We first verify that
which holds for . Secondly, we verify that
which holds by the choice of the interval . In particular, for , this occurs for ; for , this occurs for ; for , this occurs for . Moreover, if , as conjectured, these intervals extend to , , and , respectively.
-
(ii)
, . The refined triangle method [12] with , , , leads to rectangular matrix multiplication . Its complexity is at most times that of the square matrix multiplication with dimension , the latter of which is . It follows that
For (the entries in Table 1), these runtimes are , , , and , respectively.
As before, we show that for a certain high-range of , the new bound beats all previous bounds, namely and , for (or ). Let , where . We first verify that
which holds for . Secondly, we verify that
which holds by the choice of the interval . In particular, for , this occurs for ; for , this occurs for ; for , this occurs for . Moreover, if , as conjectured, these intervals extend to , , and , respectively.
-
(iii)
, . The refined triangle method [12] with , , , leads to rectangular matrix multiplication . Its complexity is at most times that of the square matrix multiplication with dimension , the latter of which is . It follows that
For (the entries in Table 1), these runtimes are , , and , respectively.
As before, we show that for a certain high-range of , this bound beats all previous bounds, namely and , for (or ). Let , where . We first verify that
which holds for . Secondly, we verify that
which holds by the choice of the interval . In particular, for , this occurs for ; for , this occurs for ; for , this occurs for . Moreover, if , as conjectured, these intervals extend to , , and , respectively.
The bound for , , is superseded by the bound , using another (so-called “the edge count”) method.
Running time derivations for small .
The previous general case derivations together with the instantiations below yield the running times listed in Table 1.
Previous best | This paper | |
---|---|---|
[6], [16], [3] | ||
[6], [12], [18] | ||
[6], , [12] | ||
[6], [12], [12] | ||
[6], [12], [12] | , | |
[6], [12, 18] | , | |
[6], [12, 18] | ||
[6], [12, 18] | , | |
[6], [12, 18] | , | |
[6], [12, 18] | , | |
[6], [12, 18] | ||
[6], [12, 18] | ||
[6], [12, 18] | ||
[6], [12, 18] | , |
- (i)
-
(ii)
. The refined triangle method [12] with , , , leads to rectangular matrix multiplication or in the worst case. Since , it follows that . (See also [22, Table 3]; this entry has been slightly improved in [36].) In particular, this gives a positive answer to a question of Alon, Yuster, and Zwick [3], who asked for an improvement of their upper bound for detection. In terms of , by [12, Table 1], , but this entry appears unjustified.
-
(iii)
. The refined triangle method [12] with , , , leads to rectangular matrix multiplication or in the worst case. According to [36, Table 1], , hence .
On a side note, the extension method [12] with , yields . Observe however, that , so the above upper bound does not beat that of the algorithm of Chiba and Nishizeki.
-
(iv)
. The general case derivation yields a runtime of .
-
(v)
. The refined triangle method [12] with , , , leads to rectangular matrix multiplication or in the worst case. Since , it follows that .
-
(vi)
. The refined triangle method [12] with , leads to counting ’s in a graph with vertices. Since , we have .
-
(vii)
. The general case derivation yields a runtime of .
- (viii)
- (ix)
-
(x)
. The general case derivation yields a runtime of . Example: for graphs with , ’s can be counted/detected in time, whereas the other entries give time or more.
- (xi)
- (xii)
-
(xiii)
. The general case derivation yields a runtime of .
- (xiv)
The edge count method.
This method combines the extended triangle method with runtime upper bounds of algorithms for the “sparse” case of the detection problem. We illustrate the method for , with . Detecting the presence of a amounts to detecting the presence of a in a graph with vertices corresponding to the ’s , where two vertices in are adjacent if they span vertices of that form a . There are ’s in , and so by the result of [18], a in can be detected in time.
Consider three examples: . For , the new bound is better than the earlier bound:. Indeed, it is easily seen that over the entire range of . For , the new bounds are better than the earlier bounds for . Indeed, and for .
These examples are not exhaustive. For instance, one can also apply the edge count method with and use the time algorithm for triangle detection [3].
5 Conclusion
We conclude by restating a few open problems in the area of finding small complete subgraphs. Recall that triangle detection can be done in time by the algorithm of Itai and Rodeh.
-
1.
Can detection be done in time?
-
2.
Is detection as difficult as Boolean matrix multiplication? Initially posed by Alon, Yuster, and Zwick [2], it also appears as in Woeginger’s survey on exact algorithms [37] (as Question 4.3 (c)). V. V. Williams and R. Williams showed that if any of the two problems admits a truly subcubic combinatorial algorithm then also the other one does [35].
-
3.
Can detection be accomplished in time? (Question 4.3 (b) in Woeginger’s survey on exact algorithms [37]) We add our own version: Can detection be accomplished in time?
Acknowledgment.
The authors thank an anonymous reviewer for communicating the short folklore proof of Lemma 1.
References
- [1] J. Alman and V. V. Williams, A refined laser method and faster matrix multiplication, Proc. 2021 ACM-SIAM Symposium on Discrete Algorithms SODA 2021, Virtual Conference, SIAM, pp. 522–539.
- [2] N. Alon, R. Yuster, and U. Zwick, Color-coding, Journal of the ACM 42(4) (1995), 844–856.
- [3] N. Alon, R. Yuster, and U. Zwick, Finding and counting given length cycles, Algorithmica 17(3) (1997), 209–223.
- [4] R. Bar-Yehuda and S. Even, On approximating a vertex cover for planar graphs, Proc. 14th ACM Symposium on Theory of Computing (STOC), 1982, pp. 303–309.
- [5] A. Björklund, R. Pagh, V. V. Williams, and U. Zwick, Listing triangles, Proc. 41st International Colloquium on Automata, Languages, and Programming (ICALP), Copenhagen, 2014, Springer, vol. 8572 of LNCS, pp. 223–234.
- [6] N. Chiba and T. Nishizeki, Arboricity and subgraph listing algorithms, SIAM Journal on Computing 14(1) (1985), 210–223.
- [7] D. Coppersmith and S. Winograd, Matrix multiplication via arithmetic progressions, Journal of Symbolic Computation 9(3) (1990), 251–280.
- [8] T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein, Introduction to Algorithms, 3rd edition, MIT Press, Cambridge, 2009.
- [9] R. Diestel, Graph Theory, Springer, New York, 1997.
- [10] R. Duan, H. Wu, and R. Zhou, Faster matrix multiplication via asymmetric hashing, Proc. 64th Annual Symposium on Foundations of Computer Science (FOCS 2023), IEEE, pp. 2129–2138.
- [11] T. Eden, A. Levi, D. Ron, and C. Seshadhri, Approximately counting triangles in sublinear time, SIAM J. Comput. 46(5) (2017), 1603–1646.
- [12] F. Eisenbrand and F. Grandoni, On the complexity of fixed parameter clique and dominating set, Theoretical Computer Science 326(1-3) (2004), 57–67.
- [13] D. Eppstein, Arboricity and bipartite subgraph listing algorithms, Information Processing Letters 51(4) (1994), 207–211.
- [14] D. Eppstein, M. T. Goodrich, M. Mitzenmacher, and M. R. Torres, 2-3 cuckoo filters for faster triangle listing and set intersection, Proc. 36th SIGMOD-SIGACT-SIGAI Sympos. on Principles of Database Systems, PODS, 2017, pp. 247–260.
- [15] F. Harary, Graph Theory, revised, Addison–Wesley, Reading, Massachusetts, 1972.
- [16] A. Itai and M. Rodeh, Finding a minimum circuit in a graph, SIAM Journal on Computing 7(4) (1978), 413–423.
- [17] M. R. Garey and D. S. Johnson, Computers and Intractability: A Guide to the Theory of NP-Completeness, W.H. Freeman and Co., New York, 1979.
- [18] T. Kloks, D. Kratsch, and H. Müller, Finding and counting small induced subgraphs efficiently, Information Processing Letters 74(3-4) (2000), 115–121.
- [19] M. Kolountzakis, G. Miller, R. Peng, and C. Tsourakakis, Efficient triangle counting in large graphs via degree-based vertex partitioning, Internet Mathematics 8(1-2) (2012), 161–185.
- [20] T. Kopelowitz, S. Pettie, and E. Porat, Dynamic set intersection, Proc. 14th International Symposium on Algorithms and Data Structures, WADS 2015, Victoria, BC, Canada, 2015, Springer, vol. 9214 of LNCS, pp. 470–481.
- [21] M. Kowaluk and A. Lingas, A multi-dimensional matrix product—a natural tool for parameterized graph algorithms, Algorithms 15(12) (2022), 448.
- [22] F. Le Gall and F. Urrutia, Improved rectangular matrix multiplication using powers of the Coppersmith-Winograd tensor, Proc. 29th Annual ACM-SIAM Sympos. on Discrete Algorithms, SODA 2018, New Orleans, SIAM, 2018, pp. 1029–1046.
- [23] D. R. Lick and A. T. White, -degenerate graphs, Canadian Journal of Mathematics 22(5) (1970), 1082–1096.
- [24] U. Manber, Introduction to Algorithms - A Creative Approach, Addison-Wesley, Reading, Massachusetts, 1989.
- [25] J. Matoušek, Thirty-three Miniatures, American Mathematical Society, 2010.
- [26] C. St. J. A. Nash-Williams, Edge-disjoint spanning trees of finite graphs, Journal of the London Mathematical Society 36 (1961), 445–450.
- [27] C. St. J. A. Nash-Williams, Decomposition of finite graphs into forests, Journal of the London Mathematical Society 1(1) (1964), 12–12.
- [28] J. Nešetřil and S. Poljak, On the complexity of the subgraph problem, Commentationes Mathematicae Universitatis Carolinae 26(2) (1985), 415–419.
- [29] M. Ortmann and U. Brandes, Triangle listing algorithms: back from the diversion, Proc. 16th Workshop on Algorithm Engineering and Experiments, ALENEX 2014, Portland, Oregon, 2014, pp. 1–8.
- [30] C. H. Papadimitriou and M. Yannakakis, The clique problem for planar graphs, Information Processing Letters 13(4/5) (1981), 131–133.
- [31] I. Rivin, Counting cycles and finite dimensional L norms, Advances in Applied Mathematics 29(4) (2002), 647–662.
- [32] T. Schank, Algorithmic Aspects of Triangle-Based Networks Analysis, PhD thesis, Universität Fridericiana zu Karlsruhe (TH), 2007.
- [33] T. Schank and D. Wagner, Finding, counting and listing all triangles in large graphs, an experimental study, 35 pages. A short version in Proc. 4th International Workshop on Experimental and Efficient Algorithms, (WEA), Santorini Island, Greece, Springer, vol. 3503 of LNCS, 2005, pp. 606–609.
- [34] W. Tutte, On the problem of decomposing a graph into connected factors, Journal of the London Mathematical Society 36 (1961), 221–230.
- [35] V. V. Williams and R. R. Williams, Subcubic equivalences between path, matrix, and triangle problems, Journal of the ACM 65(5) (2018), 1–38.
- [36] V. V. Williams, Y. Xu, Z. Xu, and R. Zhou, New bounds for matrix multiplication: from alpha to omega, Proc. of the 2024 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), SIAM, pp. 3792–3835. https://epubs.siam.org/doi/pdf/10.1137/1.9781611977912.134
- [37] G. J. Woeginger, Open problems around exact algorithms, Discret. Appl. Math. 156(3) (2008), 397–405.
- [38] N. Zechner and A. Lingas, Efficient algorithms for subgraph listing, Algorithms 7(2) (2014), 243–252.
- [39] X. Zhou and T. Nishizeki, Edge-coloring and -coloring for various classes of graphs, Journal of Graph Algorithms and Applications 3(1) (1999), 1–18.