# Reconstructing Cactus Graphs from Shortest Path Information

(Extended Abstract)
Conference paper
Part of the Lecture Notes in Computer Science book series (LNCS, volume 9778)

## Abstract

Imagine a disaster in which all edges of a network go down simultaneously. Imagine further that the routing tables of the nodes were not destroyed but are still available. Can one “reconstruct” the network from the routing tables? This question was first asked by Kranakis, Krizanc and Urrutia in 1995 as part of an attempt to answer the question of how much information about the network is stored in the node routing tables. In this paper, we answer this question in the affirmative if the underlying network is a cactus graph by providing an algorithm that returns all node-labelled cacti consistent with a given set of routing tables. This is the first such result for a class of non-geodetic graphs.

### Keywords

Graph reconstruction Shortest path information Cactus graph

## 1 Introduction

Imagine a disaster in which all edges of a network go down simultaneously. Imagine further that the routing tables from each of the nodes were not destroyed but are still available. Can one “reconstruct” the network from the routing tables? This question was first asked by Kranakis et al. [19] in 1995 as part of an attempt to answer the question of how much information about the network is stored in the node routing tables. To be a bit more precise, assume we know the degree of each node, i, and for each other node, j, we know one of the edges adjacent to i which is on a shortest path from i to j. (If more than one edge is the first edge on a shortest path from i to j then one is chosen arbitrarily.) Is this “shortest path information” sufficient to reconstruct the underlying graph of the network?

The problem is similar in nature to many other “reconstruction” problems studied in graph theory. An early result along these lines is by Erdős and Gallai [9] who characterize those sequences that are realized as the degree sequence of a graph by providing an algorithm for reconstructing such a graph if one exists. The question of characterizing degree sequences for limited classes of graphs and finding graphs realizing a given sequence has a long history including for such classes as trees (folklore), split graphs [14, 23], 4-cycle-minor free graphs [27], unicyclic graphs [3], Halin graphs [5], 2-trees [7], and k-trees [21].

Perhaps the most famous of these reconstruction problems is the conjecture due to Kelly [18] and Ulam [28]: Given a multiset of n induced subgraphs generated by deleting each vertex of an n-node graph, can one reconstruct the graph? (Harary [15] posed the same question for edge deletions.) The problem remains open in general but a series of papers have solved the problem for a number of different classes of graphs starting with trees and regular graphs [16] and continuing with (among others) outerplanar graphs [12], unit interval graphs [29] and random graphs [6].

Perhaps most closely related to our reconstruction problem is that of reconstructing a graph from the set system of the neighborhoods of the graph’s nodes (referred to as a star system) introduced by Sabidussi and Sos [13]. For this problem it is known that for general graphs the problem is NP-complete [2, 20] and for some classes of graphs it remains NP-complete but for others it becomes solvable in polynomial time [10]. Other related (but distinct from our version) reconstruction problems include those of reconstructing trees from edge splits [8] (with applications in phylogentics), reconstructing graphs from distance queries [22] (with applications in network tomography), reconstructing graphs from embedding requests [26] (with applications to security) and reconstructing graphs with a betweenness oracle [1].

In [19], Kranakis et al. show that their reconstruction problem is solvable for unique shortest path graphs (also known as geodetic graphs) by giving a polynomial time algorithm to construct such a node-labelled graph from its shortest path information. In fact, they show that in the “full information” model, where all the first edges on a path from i to j are provided for each i and j, there is a unique graph satisfying the set of constraints this provides. In unique shortest path graphs there is only one such edge, so the full information model is equivalent to having the routing tables (with a single first edge) and their algorithm for the full information model answers the question for this class of graphs. They also show that if the underlying graph includes an even length cycle, it is possible that a given set of routing tables may be realized by more than one labelled graph. A simple 4-cycle is sufficient to show this. Building on this example, they point out that a given set of routing tables (referred to as a shortest path set system below), may have as many as $$2^k$$ different labelled graphs consistent with it, if the graph contains k “independent” 4-cycles (sharing no edges).

In this paper, we provide an algorithm for reconstructing all possible node labelled graphs consistent with a given shortest path set system assuming the graphs are from the class of cactus graphs. A cactus graph is a connected graph in which any two simple cycles have at most one node in common. This is the first such result for graphs with potentially more than one shortest path between pairs of nodes, i.e., non-geodetic graphs. Interestingly, the degree sequences of cacti have been characterized [17] and it is one of the classes for which the Ulam’s reconstruction problem is known to be solvable [11]. Cacti have been studied in their own right for applications in traffic flow [30], electrical circuits [24], wireless sensor networks [4] and genomics [25].

A shortest path set system, $$S=\{(i_1, i_2, ..., i_n), F_{i_1}, F_{i_2},..., F_{i_n}\}$$, (or set system, for short), is a set containing an n-tuple along with n sets indexed by the elements of the n-tuple. We refer to n as the size of S,  denoted |S|. Each of the sets, $$F_i$$, is made up of one or more subsets of $$V(S) = \{ i_1, i_2, \ldots , i_n \}$$ which we refer to as the vertices (or nodes) of S. I.e., each $$F_i = \{ F_{i,1}, F_{i,2}, \dots , F_{i,k} \}$$ for some $$k>0$$. We refer to k as the degree(i) and to the $$F_{i,j}$$’s as the edge sets of i. We say a set system is valid if for $$1 \le i \le n$$, we have
• $$F_{i, l}\cap F_{i, k}=\emptyset$$ for $$1\le l\ne k\le degree(i)$$, and

• $$\cup _{1\le l\le degree(i)}F_{i, l}=\{i_1, i_2, ..., i_n\}\setminus \{i\}$$.

In other words, the $$F_i$$’s form a partition of $$V(S) \setminus \{i\}$$. For a valid set system we denote by $$F_i^j$$ the unique $$F_{i,t}$$ such that $$j \in F_{i,t}$$, where $$j \ne i$$.

We say an n-node graph G with vertex set $$V(G) = \{ i_1, i_2, \ldots , i_n \}$$ is consistent with a valid set system $$S=\{(i_1, i_2, ..., i_n), F_{i_1}, F_{i_2},..., F_{i_n}\}$$ if and only, for all $$i \in V(S)$$, there is a one-to-one mapping, $$\phi _i$$, of the edge sets of $$F_i$$ to the edges adjacent to node i in G, with the following property: $$\phi (F_i^j)$$ is the first edge on a shortest path from i to j in G. In this way we can think of the set system as encoding a possible set of routing tables for the nodes of G, providing the first edge on a shortest path to each possible destination node. (Note: our graphs are unweighted, i.e., the length of a path is the number of edges in it.) Given a valid set system, we are interested in finding those node-labelled graphs that are consistent with it, if any.

As was pointed out earlier, [19] showed that even length cycles can cause problems when trying to reconstruct a graph from its shortest path set system. In particular, there is a set system that is consistent with two different node labelled 4-cycles (see Fig. 1). It turns out, if the underlying graph must be a cactus, it is only the 4-cycles that can cause such problems. Odd cycles do not introduce multiple shortest paths between nodes and we show below that even cycles of length 6 or more can be uniquely determined from their shortest path information. Building upon this, we are able to provide an algorithm that given a shortest path set system, reconstructs all of the node-labelled cacti consistent with the system or reports that none exists. The cycles in cacti are all edge-disjoint so that each restriction of a set system to 4 nodes consistent with a 4-cycle has the potential to double the number of cacti consistent with a given set system. If we let k be the number of 4-cycles in a cactus, the number of node-labelled cacti consistent with a set system derived from that cactus can be as large as $$2^k$$ depending upon how nodes are assigned to edge sets in the case where multiple shortest paths exist. We show our algorithm runs in time $$O(n^6 + 2^k n^3)$$ if the resulting reconstructed cacti have k 4-cycles. While this is not polynomial in general it is polynomial in the worst case size of the output. If we limit ourselves to the class of cacti with a fixed number of 4-cycles the algorithm becomes worst-case polynomial.

In the next section, we present our algorithm. This is followed by a proof of its correctness and an analysis of its runtime. We end with some conclusions and open problems.

## 2 The Algorithm

In this section we give an overview of the algorithm, followed by detailed pseudocode for the main procedure. Details of the sub-procedures are provided in an appendix. The input to our algorithm is a valid shortest path set system potentially representing a cactus graph, $$S=\{(i_1, i_2, ..., i_n), F_{i_1}, F_{i_2},..., F_{i_n}\}$$ and the output is the set of all n-node-labelled cacti that are consistent with S, if any. Before we begin our algorithm description we introduce a little more notation.

It is well-known that the nodes of a cactus can be partitioned into three types. Cycle nodes are nodes of degree two that appear on exactly one cycle. Non-cycle nodes are nodes that are not included in any cycle. The remaining nodes are called hinges. Observe that a hinge is of degree greater than 2 and appears on at least one cycle. We refer to non-cycle nodes of degree one as leaves and a cycle containing exactly one hinge as a leaf cycle (see Fig. 2).

The following lemma is easily established from the definitions.

### Lemma 1

Let G be a cactus graph. One of the following must hold:
1. 1.

G consists of a single vertex and no edges.

2. 2.

G consists of a simple cycle of length three or more.

3. 3.

G has a leaf.

4. 4.

G has a leaf cycle.

We denote by $$S \setminus A$$, where $$A \subset \{i_1, i_2, ..., i_n\}$$, the set system formed by removing the vertices associated with A wherever they appear in S. Note that if S is valid then $$S \setminus A$$ is valid as well. By $$S_A$$, where $$A \subset \{i_1, i_2, ..., i_n\}$$, we mean the set system S restricted to only vertices in A, i.e., $$S \setminus (\{i_1, i_2, ..., i_n\} \setminus A)$$. We represent a leaf of a cactus graph by the directed edge (ij) from the parent i to the leaf j. Given a graph G and a leaf (ij), where $$i \in V(G)$$ and $$j \not \in V(G)$$, the graph $$G + (i,j)$$ is G with the vertex j added to V(G) and the edge $$\{i,j\}$$ added to E(G). We represent a leaf cycle of a cactus graph by a pair (hC) where h is the hinge of the cycle and C is the cycle through h. Given a graph, G, and a hinge (hC), where $$h \in V(G)$$ and $$V(G) \cap V(C) = \{h\}$$, the graph $$G + (h,C)$$ is G with the cycle C added to h.

Based on Lemma 1 our algorithm is recursive. Their are two base cases:
1. 1.

the graph consistent with S consists of a single node, i.e., $$G = (\{i\}, \{\{\}\})$$ or

2. 2.

it consists of a simple cycle of length 3 or more.

Otherwise, if S represents a set system of a cactus, G, one of the following must hold:
1. 3.

G contains a leaf node or

2. 4.

G contains a leaf cycle.

Using the degree sequence implied by S, the algorithm checks for each of these cases in turn. If all of the nodes are of degree 2 then the only (connected cactus) consistent with S is a cycle of length 3 or more and the algorithm checks to see if S satisfies the necessary constraints. Note: if the set system is of size 4, then it is possible that two cycles may be consistent with S. In this case, both cycles are returned. If there are nodes of degree one then these must be leaves of the cactus. For a given leaf, (ij), the algorithm recursively finds the set of cacti, $$\mathcal {C}$$, consistent with $$S \setminus \{j\}$$ and returns the set of $$G+(i,j)$$, such that $$G \in \mathcal {C}$$ and $$G+(i,j)$$ is consistent with S. If there are no leaves and there are nodes of degree greater than 2, the algorithm checks for a potential leaf cycle. If a leaf cycle (hC) is found, the algorithm recursively finds the set of cacti, $$\mathcal {C}$$, consistent with $$S\setminus (V(C) \setminus \{h\})$$ and returns the set of $$G+(h,C)$$, such that $$G \in \mathcal {C}$$ and $$G+(h,C)$$ is consistent with S. Note: if the leaf cycle is of length 4 and there are two cycles consistent with it, both are checked against all the cacti returned after its removal.

The main complications in the above come from (1) checking if S is consistent with a cycle and finding that cycle and (2) finding a leaf cycle if one exists.

To check if a set system, S, (with all $$F_i$$ of size 2) is consistent with being a cycle comes down to three cases:
1. 1.

$$|S|= 4$$,

2. 2.

|S| is odd or

3. 3.

$$|S|>4$$ and even.

If $$|S| = 4$$ then each $$F_i$$ consists of 2 sets, one a singleton, the other of size 2. Let $$S = \{(a,b,c,d), \{A_1,A_2\}, \{B_1,B_2\}, \{C_1,C_2\}, \{D_1,D_2\},\}$$. Observe that each singleton determines an edge that must exist if S is to be consistent with a cycle of length 4. E.g., if $$A_1 = \{c\}$$ then the edge $$\{a,c\}$$ must be part of the cycle. If $$A_1 = \{c\}$$ and $$C_1 = \{a\}$$ they both determine the same edge, $$\{a,c\}$$. Regarding the determined edges there are only 3 possible cases:
1. 1.

The determined edges include a triangle. In this case, S is not consistent with a 4-cycle and $$\emptyset$$ is returned.

2. 2.

The number of determined edges is 3 or 4 (without a triangle). In this case, there is a unique 4-cycle consistent with S and it is returned (see Fig. 3).

3. 3.

The number of determined edges is 2. In this case, there are two 4-cycles consistent with S and both are returned (see Fig. 2).

If |S| is odd, the cycle is a unique shortest path graph and using techniques from [19] we can determine if S is consistent with a cycle as well as determine the edges of the unique such cycle.

For the last case, we have $$|S| = 2k$$ with $$k>2$$. In this case we pick an arbitrary vertex of S, say s, with corresponding edge sets $$F_s = \{A,B\}$$ where $$|A| = k-1$$ and $$|B| = k$$. When S is restricted to the smaller of these along with s, it must form a path starting at s, a unique shortest path graph, and again by [19] we can determine the complete path if it exists. The second node in this path must introduce either one or two nodes of B into its edge set not containing s. If one node, x, is introduced then it must be at distance k from s and we can determine the path starting at s and containing the nodes $$B \setminus \{x\}$$, if it exists. If two nodes, x and y, are introduced we can determine which, if either, is the node at distance k from s by checking which is adjacent to the last node in the path formed by the vertices in A. Say it is x. We can again determine the path starting at s and containing the nodes of $$B \setminus \{x\}$$ using the fact they must form a unique shortest path graph. Finally we can confirm that the two paths starting at s, along with x, form a cycle and if so, return the cycle, otherwise the empty set.

Once all of the leaves are dealt with, if what remains is not a single vertex or a cycle, it must contain a leaf cycle. The first step is to find all of the potential hinges and check each in turn to see if it is a hinge of leaf cycle. A node is a potential hinge if it has degree greater than 2 and it contains two edge sets of the same size (odd cycle) or that differ by one (even cycle) all of whose vertices are of degree 2. For each potential pairing of edge sets (the same size or differing by one) we check if they, together with the potential hinge, form a cycle. If a cycle is found, the cycle along with its hinge is returned as a potential leaf cycle. If the cycle is of length 4 and consistent with two different cycles, both potential leaf cycles are returned. If no leaf cycles are found, the empty set is returned.

The detailed pseudocode of the main procedure appears as Algorithm 1. The pseudocode for the remaining subroutines may be found in the full paper. In the next section we prove the algorithm’s correctness and analyze its run time. Proofs omitted due to space constraints may be found in the full paper.

## 3 Analysis of the Algorithm

In order to prove our main result we will need some lemmas. The following obvious fact is used implicitly in many of the arguments below: Say G is consistent with S. Let H be an induced connected subgraph of G with vertex set V(H). Then H is consistent with $$S_{V(H)}$$. We encapsulate its contrapositive in the following lemma:

### Lemma 2

Say that $$\mathcal {G} = \{G_1, G_2, \ldots , G_t \}$$ is the set of all connected graphs consistent with some $$S_A$$, $$A \subseteq V(S)$$. Further assume G is consistent with S. Then if the subgraph induced by A in G is connected it is in $$\mathcal {G}$$.

Observe that if G is consistent with S, the mappings $$\phi _i$$ are implied by the correspondence of the vertex sets of G and S as, if $$\{i,j\}$$ is an edge then $$j \in \phi _i^{-1} (\{i,j\})$$ (also, $$i \in \phi _j^{-1} (\{i,j\})$$) and thus we know the edge set corresponding to this adjacency. Further observe that given a graph G and a potential set system S for G, it is straightforward to verify if G is consistent with S. The following lemma is easily established:

### Lemma 3

CheckGraph(GS), returns “true” if G is consistent with S, “false” otherwise. Furthermore it runs in O(mn) time where m is the number of edges in G.

The following observation follows from the discussion in [19] and proves the correctness of a function that is used extensively in our algorithm.

### Lemma 4

If CheckEdge(abS), returns “false” then $$\{a,b\}$$ is not an edge in any G consistent with S. If it returns “true”, then $$\{a,b\}$$ is potentially an edge in some G consistent with S but need not be.

The remaining lemmas establish the correctness of our sub-procedures whose pseudo-code may be found in the full version of the paper.

### Lemma 5

Given a set system S, a distinguished vertex, s, of degree 1 in S, and the edge set A of s, FindPath(sAS), returns the unique path consistent with S, starting at s and containing all of the nodes of A, if such a path exists. Furthermore, the algorithm runs in $$O(n^2)$$ time.

### Lemma 6

Given a set system S with all vertices of degree 2, CheckCycle(S), returns all cycles that are potentially consistent with S. If $$|S| = 4$$, there may be two such cycles. Otherwise, the potential cycle is unique. Furthermore, the algorithm runs in $$O(n^2)$$ time.

### Lemma 7

Given a set system S with at least one vertex of degree 1, the procedure FindLeaf(S), returns a potential leaf, if one exists. In any graph consistent with S, the returned vertex must be a leaf with the given parent. Furthermore, the algorithm runs in $$O(n^2)$$ time.

### Lemma 8

Given a set system S and a potential hinge (a node of degree greater than 2 with at least two edge sets containing nodes all of degree 2) h, the procedure CheckHinge(hS), returns a potential leaf cycle with hinge h, if one exists. If there are two such cycles, both are returned. In any graph consistent with S, the returned cycle(s) must be a leaf cycle with the given hinge. Furthermore, the algorithm runs in $$O(n^4)$$ time.

### Lemma 9

Given a set system S with no vertices of degree 1 and at least one vertex of degree 3, FindLeafCycle(S), returns a potential leaf cycle, if one exists. If there are two such cycles, both are returned. In any graph consistent with S, the returned cycle(s) must be a leaf cycle with the given hinge. Furthermore, the algorithm runs in $$O(n^5)$$ time.

We are now ready to prove our main result:

### Theorem 1

Given a valid set system S, ConstructCactus(S), outputs all node-labelled cacti consistent with S. Furthermore, if the resulting cacti have at most k 4-cycles the algorithm runs in time $$O(\max \{n^6, 2^k n^3\})$$.

Proof. First observe that before returning any graph, G, the algorithm calls CheckGraph(GS) which by Lemma 3 correctly verifies that G is consistent with S. I.e., all graphs returned by the algorithm are guaranteed to be consistent with S. We need only show that all cacti consistent with S are returned.

The proof of this is divided into two cases: S is consistent with simple cycle or not. If S is consistent with a simple cycle then $$|S|>2$$ and all of its vertices have degree 2. In this case, ConstructCactus(S) will call CheckCycle(S) which by Lemma 6 correctly returns all possible cycles consistent with S, either 0, 1 or 2. These are checked for consistency and those that are consistent are returned.

The remaining case is shown by induction on the size of S. The case $$|S| =1$$ follows trivially. Assume the algorithm correctly outputs all cacti consistent with set systems of up to size $$n-1$$ (including simple cycles by the first case). We show that it works correctly for set systems of size n, where $$n>1$$.

Since S is not consistent with a cycle of length n, by Lemma 1 we know that to be consistent with any cacti, it must either have a leaf or a leaf cycle. If it has a leaf, then it must have a vertex of degree 1. In this case, the procedure FindLeaf(S) is called and by Lemma 7, if there is a potential leaf in S it is returned. If there is no potential leaf but S has a vertex of degree 1 then there are no cacti consistent with S and the empty set is returned. If there is a potential leaf, leaf, then it is removed from S forming a set system $$S^\prime$$ of size $$n-1$$. By induction, calling $$ConstructGraph(S^\prime )$$ will find all cacti consistent with $$S^\prime$$. In any cactus consistent with S, leaf must be a leaf of the cactus and that cactus without the leaf must be consistent with $$S^\prime$$. Therefore, by Lemma 2, inserting the leaf into each cactus returned and verifying the result is consistent with S produces all of the cacti consistent S.

If S (of size greater than 1) has no leaves (and is not consistent with a cycle) it must contain a leaf cycle. In this case, the algorithm will call FindLeafCycle(S) and by Lemma 9, if there is a restriction of S consistent with a leaf cycle, it will be found. (If it is of size 4, possibly two will be found.) Let L be the set of leaf cycles returned by FindLeafCycle(S). If $$|L| = 0$$ then there can be no cactus consistent with S and the empty set is returned. Otherwise, the algorithm makes recursive calls on $$S^\prime$$ equal to S with the nodes of the leaf cycle (but not the hinge) removed, finding, by induction, all cacti consistent with the smaller set system. Note: if $$|L|=2$$, both cycles are on the same vertex set and removing one results in the same S as removing the other. In any cacti consistent with S, the potential leaf cycle must be a leaf cycle and its removal must be consistent with $$S^\prime$$. Therefore, by Lemma 2, inserting the leaf cycle (or both, separately, if there are two) into each cactus returned and verifying the result is consistent with S produces all cacti consistent with S.

The algorithm makes at most $$n-1$$ recursive calls. The cost of such a call is dominated by either the cost of finding a leaf cycle ($$O(n^5)$$) or the cost of checking all of the possible graphs returned for consistency. Since each 4-cycle at most doubles the number of potential graphs this is bounded by $$O(2^k n^2)$$. (Note: cacti are planar and therefore have O(n) edges).   $$\blacksquare$$

## 4 Conclusions

We have shown the first reconstruction result from shortest path information for a class of graphs that potentially includes graphs with multiple shortest paths between pairs of nodes, namely cacti. The runtime of our reconstruction algorithm is not polynomial in the size of the input but is polynomial in the potential worst case size of the output. Unfortunately, the final size of the output may be much smaller than the total number of graphs investigated by the algorithm. Ideally, the algorithm would be truly output sensitive, running in time polynomial in the actual number of graphs consistent with the input. On the other hand, it would be straightforward to modify our algorithm to solve the problem for the class of cacti with a bounded number of 4-cycles resulting in a fully polynomial algorithm in that case. The modified algorithm would keep track of how many 4-cycles it has found and exit as soon as this exceeded the bound. For example, such an algorithm with a bound of 0 would run in $$O(n^6)$$ time and would reconstruct the unique cactus among the class of 4-cycle-free cacti consistent with a given set system, if one exists. With judicious use of preprocessing and clever data structures, the runtime of the algorithm could no doubt be significantly reduced but our goal here is only to establish it to be polynomial.

Using Lemma 3, one can show that the problem of deciding if there exists a graph consistent with a given set system is in NP. It would be interesting to determine if the problem is NP-complete or if there is a polynomial time algorithm to answer this question for general graphs or for other classes of graphs besides geodetic graphs or 4-cycle-free cacti.

### References

1. 1.
Abrahamsen, M., Bodwin, G., Rotenberg, E., Stöckel, M.: Graph reconstruction with a betweenness oracle. In: 33rd Symposium on Theoretical Aspects of Computer Science (STACS 2016). Leibniz International Proceedings in Informatics (LIPIcs), vol. 47, pp. 5:1–5:14 (2016)Google Scholar
2. 2.
Aigner, M., Triesch, E.: Reconstructing a graph from its neighborhood lists. Comb. Probab. Comput. 2, 103–113 (1993)
3. 3.
Beineke, L., Schmeichel, E.: Degrees and cycles in graph. In: 2nd International Conference on Combinatorial Mathematics, pp. 64–70 (1979)Google Scholar
4. 4.
Ben-Moshe, B., Dvir, A., Segal, M., Tamir, A.: Centdian computation in cactus graphs. J. Graph Algorithms Appl. 16(2), 199–224 (2012)
5. 5.
Bıyıkoğlu, T.: Degree sequences of Halin graphs, and forcibly cograph-graphic sequences. Ars Combinatoria 75, 205–210 (2005)
6. 6.
Bollobas, B.: Almost every graph has reconstruction number three. J. Graph Theor. 14, 1–4 (1990)
7. 7.
Bose, P., Dujmović, V., Krizanc, D., Langerman, S., Morin, P., Wood, D., Wuhrer, S.: A characterization of the degree sequences of 2-trees. J. Graph Theor. 58(3), 191–209 (2008)
8. 8.
Buneman, P.: The recovery of trees from measures of dissimilarity. In: Mathematics in the Archaeological and Historical Sciences, pp. 387–395. Edinburgh University Press (1971)Google Scholar
9. 9.
Erdos, P., Gallai, T.: Graphs with prescribed degrees of vertices. Mat. Lapok 11, 264–274 (1960)
10. 10.
Fomin, F., Kratochivil, J., Lokshtanov, D., Mancini, F., Telle, J.A.: On the complexity of reconstructing H-free graphs from their star systems. J. Graph Theor. 68, 113–124 (2011)
11. 11.
Geller, D., Manvel, B.: Reconstruction of cacti. Can. J. Math. 21(6), 1354–1360 (1969)
12. 12.
Giles, W.: The reconstruction of outerplanar graphs. J. Comb. Theor. Ser. B 16(3), 215–226 (1974)
13. 13.
Hajnal, A., Sos, V. (eds.): Combinatorics. In: Colloquia Mathematica Societatis Janos Bolya 18, vol. II. North-Holland (1978)Google Scholar
14. 14.
Hammer, P., Simeone, B.: The splittance of a graph. Combinatorica 1, 275–284 (1981)
15. 15.
Harary, F.: On the reconstruction of a graph from a collection of subgraphs. In: Theory of Graphs and its Applications (Proceedings Symposium Smolenice, 1963), pp. 47–52 (1964)Google Scholar
16. 16.
Harary, F.: A survey of the reconstruction conjecture. In: Bari, R.A., Harary, F. (eds.) Graphs and Combinatorics. Lecture Notes in Mathematics, vol. 406, pp. 18–28. Springer, Heidelberg (1974)
17. 17.
Havel, V.: Eine Bemerkung über die Existenz der endlichen Graphen. Casopis Pest. Mat. 80, 477–480 (1955)
18. 18.
Kelly, P.: A congruence theorem for trees. Pac. J. Math. 7, 961–968 (1957)
19. 19.
Kranakis, E., Krizanc, D., Urrutia, J.: Implicit routing and shortest path information (Extended Abstract). In: Colloquium on Structural Information and Communication Complexity, pp. 101–112 (1995)Google Scholar
20. 20.
Lalonde, F.: Le problem d’toiles pour graphes est NP-complet. Discrete Math. 33, 271–280 (1981)
21. 21.
Lotker, Z., Majumdar, D., Narayanaswamy, N.S., Weber, I.: Sequences characterizing k-trees. In: Chen, D.Z., Lee, D.T. (eds.) COCOON 2006. LNCS, vol. 4112, pp. 216–225. Springer, Heidelberg (2006)
22. 22.
Mathieu, C., Zhou, H.: Graph reconstruction via distance oracles. In: Fomin, F.V., Freivalds, R., Kwiatkowska, M., Peleg, D. (eds.) ICALP 2013, Part I. LNCS, vol. 7965, pp. 733–744. Springer, Heidelberg (2013)Google Scholar
23. 23.
Merris, R.: Split graphs. Eur. J. Comb. 24, 413–430 (2003)
24. 24.
Nishi, T.: On the number of solutions of a class of nonlinear resistive circuits. In: International Symposium on Circuits and Systems, pp. 766–769. IEEE (1991)Google Scholar
25. 25.
Paten, B., Diekhans, M., Earl, D., John, J., Ma, J., Suh, B., Haussler, D.: Cactus graphs for genome comparisons. J. Comput. Biol. 18(3), 469–481 (2011)
26. 26.
Pignolet, Y., Schmid, S., Tredan, G.: Adversarial VNet embeddings: a threat for ISPs? In: INFOCOM, pp. 415–419. IEEE (2013)Google Scholar
27. 27.
Rao, R.: Degree sequences of cacti. In: Rao, S. (ed.) Combinatorics and Graph Theory. Lecture Notes in Mathematics, vol. 885, pp. 410–416. Springer, Heidelberg (1981)
28. 28.
Ulam, S.: A Collection of Mathematical Problems. Wiley, New York (1960)
29. 29.
von Rimscha, M.: Reconstructibility and perfect graphs. Discrete Math. 47, 283–291 (1983)
30. 30.
Zmazek, B., Žerovnik, J.: Estimating the traffic on weighted cactus networks in linear time. In: Ninth International Conference on Information Visualisation, pp. 536–541. IEEE (2005)Google Scholar