Finding multi-objective supported efficient spanning trees

This article introduces a new algorithm for computing the set of supported non-dominated points in the objective space and all the corresponding efficient solutions in the decision space for the multi-objective spanning tree (MOST) problem. This algorithm is based on the connectedness property of the set of efficient supported solutions and uses a decomposition of the weight set in the weighting space defined for a parametric version of the MOST problem. This decomposition is performed through a space reduction approach until an indifference region for each supported non-dominated point is obtained. An adjacency relation defined in the decision space is used to compute all the supported efficient spanning trees associated to the same non-dominated supported point as well as to define the indifference region of the next points. An in-depth computational analysis of this approach for different types of networks with three objectives is also presented.


Introduction
The minimum spanning tree (MST) problem is a combinatorial optimization problem with many real-world applications [2,37,38], which are present in almost our daily life aspects (including our interactions with respect to social networks, computer networks, telecommunications networks, transportation networks, water supply networks, electrical grids, and much more). Other practical applications of minimum spanning tree include clustering analysis, taxonomy, circuits design, image registration and segmentation, handwriting recognition, automatic speech recognition, socio-geographic applications, surface homogeneity tests, classification problems, amongst others [8,13,24,26,30,32].
Real-life problems deal very often with conflicting objectives. Consider, for example, a broadcasting network to send files to several connected endpoints. It is natural that the best and most reliable network links have a better performance when sending files, but simultaneously are more expensive if they are used.
Moving from single objective spanning tree problems to multiple objective spanning tree (MOST) problems means to replace the concept of optimal spanning tree (solution) by that of efficient spanning tree in the decision space. The image of an efficient solution in the objective space is called non-dominated point. The search for the entire set of efficient spanning trees and/or the corresponding non-dominated points is a fundamental problem in multi-objective combinatorial optimization [10].
A relevant subset of the set of efficient spanning trees is called the set of supported spanning trees. These spanning trees are optimal for the weighted sum of several objective functions. It is easier to find a supported efficient spanning tree than an efficient spanning tree in general; the latter is an NP-hard problem whereas the former can be solved with classical algorithms, such as Kruskal algorithm, in polynomial amount of time. For this reason, this subset of spanning trees are usually found in a pre-processing phase and used for pruning within implicit enumeration strategies.
For the bi-objective spanning tree problem, Ahuja et al. [2] devised an algorithm to obtain the set of supported spanning trees. The algorithm exploits the relations between supported spanning trees and adjacent trees. Two trees are adjacent if and only if they share all but one edge. The algorithm starts by calculating a lexicographical optimal spanning tree w.r.t. one objective function, and then, by searching amongst its adjacent trees, it calculates the weightings for which that tree is optimal for the scalarized version of MOST with respect to the weighted sum (so called parametric problem). To find those weightings the algorithm needs to find, among all the neighboring trees, the one that has a better weighted sum for a larger value of the objective function considered initially. Such tree is the next supported spanning tree. The process is repeated until the lexicographical optimal solution w.r.t. the second objective function is found.
Seipp proposed an algorithm to calculate a subset of the supported spanning trees (the extreme supported spanning trees) by performing a division on the weight set for the tri-objective spanning tree problem [33]. In his work, the weight set is intersected with a polyline for each pair of edges. Every sub-space generated leads to a subset of the weighted set. For each weight set division, a parametric optimal spanning tree problem is solved. Sub-weight sets are merged whenever they lead to the same optimal spanning tree. Although partially described, the author does not give implementation details and do not report any experimental analysis. It is not clear which data structures could be used to store the decomposed weight set and how could the algorithm be implemented efficiently.
In this article, we propose an algorithm that finds the whole set of supported efficient solutions for the MOST problem. Our approach is based on the identification of the relations among supported efficient solutions and their immediate neighborhood solutions in terms of adjacency both in the decision and in the objective space. Similarly to the bi-objective version described in [2], we calculate the weight set region for which every supported solution is optimal for the parametric problem. Such a region in the general MOST problem is a polytope, which we refer to as an indifference region. This algorithm starts by finding a lexicographical solution by calculating the single objective minimum spanning tree for a problem with edges ordered lexicographically. The remaining supported spanning trees of the problem and the indifference region associated to each spanning tree are calculated by performing neighborhood search starting from a lexicographical optimal solution.
This article is organized as follows. Section 2 is devoted to concepts, definitions, and notation. Section 3 deals with the presentation of the proposed algorithm. Section 4 provides an illustrative example. Section 5 presents a computational study. Finally, Sect. 6 presents some conclusions and future work.

Concepts, definitions, and notation
This section introduces the minimum spanning tree problem along with some fundamental results, the presentation of its multi-objective variant, the weightedsum spanning tree problem, and some algorithmic aspects for the three-objective spanning tree problem.

The minimum spanning tree problem
Consider an undirected and connected valued graph, G ¼ ðV; E; cÞ, where V is the set of vertices and n ¼ jVj, E is the set of edges where m ¼ jEj, and c is a set of values, one per edge. An edge connecting vertex i to vertex j is denoted by fi; jg and c ij 2 R þ denotes the value of such an edge. The minimum spanning tree (MST) problem consists of finding a spanning tree in G whose sum of edge values is as small as possible. Let T Ã denote an optimal spanning tree.

Proposition 1 (MST optimality condititions)
(a) Cut-based optimality condition: For all edges fi; jg 2 T Ã , c ij 6 c k' for all edges fk; 'g belonging to the cut formed by removing edge fi; jg from T Ã . (b) Path-based optimality condition: For all edges fk; 'g 6 2 T Ã , c ij 6 c k' for all edges fi; jg belonging to the path of T Ã from vertex k to vertex '.
These conditions are important for devising algorithms and for proving their correctness (see [2]). The asymptotically fastest algorithms in the literature are the approach described in Karger et al. [20], which is a randomized algorithm that solves the minimum spanning tree in expected linear time, and in Chazelle [7], which consists of a deterministic algorithm that is able to solve the problem in Oðmaðm; nÞÞ time, where aðm; nÞ is the inverse Ackermann function [1]. The implementation of these very efficient algorithms is rather complex. In general, variants of Kruskal's and Prim's algorithms are considered [22,26]. The first runs in Oðm log nÞ while the second runs in Oðn 2 Þ. Let us remark that when using a Fibonacci heap, Prim's algorithm runs in Oðn þ m log mÞ.
Let T be the set of all feasible spanning trees in G and let function z : T ! R. The set T & E nÀ1 is the feasible region in the decision space. The cardinality of T for a complete graph is given by the Cayley's formula [6], i.e., jT j ¼ n nÀ2 .
The MST problem can also be stated as follows: min zðTÞ, subject to T 2 T , where is the objective function to be minimized. The concept of adjacent spanning trees (see page 538 in [2]) is important in the context of this work.
Definition 1 (Adjacency in the decision space) Consider two feasible spanning trees, T 0 , T 00 2 T . They are said to be adjacent if both share all, but an edge.
The edge swapping that allows to move from T 0 to T 00 is called an elementary move and it is composed of two edges fi; jg, and fk; 'g, where fi; jg 2 T 0 , and fk; 'g 2 T 00 ; we denote it by s T 0 ;T 00 ¼ hfi; jg $ fk; 'gi. All the trees that are reachable by elementary moves from T 0 are called the immediate neighbors of T 0 .
The adjacency relation in Definition 1 allows to form an adjacency graph [11] composed of adjacent spanning trees. For a given set of such spanning trees, if the graph is connected, we say that the set is connected. Let T Ã denote the set containing all MSTs. Such set is connected [31].
Proposition 2 (Connectedness of all MSTs [31]) Let T 0 and T 00 denote two minimum spanning trees. There is a sequence of elementary moves yielding T 00 from T 0 such that all spanning trees constructed in this sequence are minimum spanning trees.
We remark that it is easy to see, from linear programming, that the set of all MSTs is connected. We can associate a f0; 1g variable, x ij , with each edge fi; jg 2 E. This variable x ij is equal to 1 if edge fi; jg belongs to a tree; otherwise, it assumes the value 0. A tree T can be represented by a solution or vector x with components 1 for the edges in T and 0 for the edges in EnT. Let X denote the set of all feasible solutions (trees) and conv(X) the convex hull of X. Observe that conv(X) is a polytope with at most ðn À 1Þ dimensions, where all the extreme points are with f0; 1g components. It means that it is possible to relax variable x ij to be nonnegative since its value will only be either 0 or 1. Now, when optimizing a linear function over conv(X), all the optimal solutions can be computed. When there is no degeneracy (in which case there is no change in the basic variables with x ij ¼ 1) a non-basic variable x k' will replace a basic variable x ij ¼ 1. For the computation of all alternative optimal solutions, see Chapter 4 in Steuer [36]. For the degenerate pivoting, the value of the objective function does not change. As for the nondegenerate pivoting if the optimal solutions were not connected the entering variable would degrade the value of the objective function, which is not possible. In case the value of the objective function improves, the previous solution was not at the optimum, which is also not possible. Hence, we can prove that the optimal solutions are connected in the sense of linear programming. Note that there is an equivalency between the linear programming adjacency and the combinatorial concept of adjacency (see page 95 in Gorski [16]).
A naïve algorithm to find all MSTs based on Proposition 2 runs in time OðmnjT Ã jÞ since for each minimum spanning tree, all elementary moves from that tree to another tree are required to be tested. Eppstein proposed a faster algorithm to generate T Ã that runs in Oðm þ n log n þ jT Ã jÞ [12]. Eppstein's algorithm is based on the transformation of the valued graph, G, into a non-valued auxiliary graph,Ĝ. This transformation is performed such that there is a one-for-one correspondence between each spanning tree ofĜ and each minimum spanning tree of G. Such transformation is performed by first calculating an MST of G, T Ã , and then performing a succession of modifications to the edges of GnT Ã based on the weights of such edges and the weights of the edges of T Ã . All the spanning trees ofĜ are listed using an algorithm proposed in Kapoor and Ramesh [19].

The multi-objective spanning tree problem
Let c 1 ij ; . . .; c ' ij ; . . .; c p ij denote the vector of values assigned to each edge fi; jg 2 E. The notation C is used to encompass all these vectors and our valued graph becomes G ¼ ðV; E; CÞ. Thus, when taking into account multi-objective spanning tree (MOST) problems, z is a function such that z : T ! R p þ . This problem considers a vector of p objective functions, zðTÞ ¼ ðz 1 ðTÞ; . . .; z ' ðTÞ; . . .; z p ðTÞÞ, each of which to be minimized, subject to the same constraint, i.e., T 2 T . The image of T according to all the objective functions, denoted by Z ¼ zðT Þ & R p , is the feasible region in the objective space.
A fundamental concept in multi-objective optimization is the dominance concept, which can be defined as follows (see [10,36]).
Definition 2 (Dominance) Let z 0 ; z 00 2 R p denote two points in the objective space. Then, z 0 dominates z 00 , denoted by z 0 Mz 00 , if and only if z 0 z 00 and z 0 6 ¼ z 00 (i.e., z 0 ' 6 z 00 ' for all ' ¼ 1; . . .; p, and z 0 ' \z 00 ' for ' 2 f1; . . .; pg). Consider a feasible point z 2 Z; this point is called a non-dominated point if and only if there is no other point z 2 Z such that zM z. Otherwise, z is a dominated point. Let N denote the set of all non-dominated points. A spanning tree T 2 T is said to be a Pareto or efficient spanning tree if and only if there does not exist another spanning tree T 2 T , such that zðTÞMzð TÞ; otherwise, it is called inefficient. Let P denote the set of all Pareto or efficient spanning trees.
Consider a non-dominated point z 2 N; this point is called a supported nondominated point if and only if z 2 bd ðZ ! ). If z is a supported non-dominated point and it is also an extreme point of Z ! , z is said to be a supported extreme nondominated point. A point z 2 Z is said to be an unsupported non-dominated point if and only if z 2 N and z 2 int ðZ ! Þ. The same concepts apply to the decision space. Finally, let NS denote the set of all supported non-dominated points and let PS the set of all supported efficient spanning trees.

The weighted-sum spanning tree problem
Our approach is based on weight set decomposition to define adjacency amongst spanning trees. A fundamental concept to that decomposition is the weight set, which is defined as follows: Definition 3 (Weight set) The weight set, W & R p , can be stated as follows, Note that the dimension of the weight set, W, is p À 1, denoted by dim(W)¼ p À 1, since w p ¼ 1 À P pÀ1 '¼1 w ' . Definition 4 (Parametric problem) The parametric or weighted-sum problem (wMOST), for some parameter or weight vector w 2 W, can be defined as follows.
The optimal spanning trees (points) of this w MOST problem are supported efficient spanning trees (points) of the MOST problem (see [10,15]).
Definition 5 (Indifference region) Let fz 1 ; . . .; z i ; . . .; z r g, denote the set of nondominated supported points. All the weighting vectors, w 2 W, that lead to the same non-dominated supported point, z i 2 Z ! , for i ¼ 1; . . .; r, of the MOST problem, form the set W i , which is referred to as the indifference region in the weight set associated with point z i .
In the literature, some authors have proposed approaches to compute the set of extreme supported non-dominated points. Przybylski et al. [27] and Bökler et al. [5] compute a weight set decomposition, while Ö zpeynirci et al. [25] identify non-dominated faces. Alves and Costa [3] proposed an algorithm to obtain all extreme supported non-dominated solutions adjacent to a given solution by exploring the weight space for multi-objective integer and mixed-integer linear programming problems. The algorithms are based on an exploration of the weight set taking advantage of geometrical properties of indifference regions. Moreover, several properties related to indifference regions are presented in Przybylski et al. [27]. In this article, we propose an algorithm to decompose the weight set and to enumerate the whole set of supported efficient trees from this decomposition. From Proposition 3(a) and (c) it can be inferred that the number of extreme supported points is equal to the number of polytopes of dimension p À 1 (sub-divisions of the weight set). Thus, an interior point from each of these polytopes can be used to provide the weights of a weighted-sum MOST problem to obtain all extreme supported trees. Non-extreme supported trees can also be enumerated by finding the appropriate weights for weighted-sum problems. These weights correspond to interior points of intersections between indifference regions of dimension p À 1. Interior points of regions corresponding to intersections of indifference regions of extreme solutions can be used to create weights for the weighed-sum MOST problem, where these non-extreme supported trees are optimal solutions. In Sect. 3, we provide a detailed description and a correctness proof of the algorithm.

Solution approaches to the MOST problem
Literature on the MOST problem is rather scarce. For the bi-objective problem, Ahuja et al. [2] developed a parametric programming approach (see Definition 4) to find the set of supported trees by using the concept of adjacent spanning trees (see Definition 1) in a network model (i.e., a neighborhood search technique through elementary adjacent moves). Their approach starts from a lexicographic optimal spanning tree for one of the objective functions and, by the adjacency relation, moves to the next supported spanning tree until the optimal spanning tree for the second objective is reached.
Two two-phase based methods have been proposed to find all non-dominated points in the objective space [29,35]. In Ramos et al. [29], the first phase finds the set of all supported spanning trees by using a different technique from the one proposed in Ahuja et al. [2]. Their approach starts from two lexicographical optimal spanning trees for both objectives and finds the remaining spanning trees by iteratively bisecting the objective space for each pair of points corresponding to the supported spanning trees that were previously found (see also [18]). The second phase finds the remaining efficient spanning trees with a branch-and-bound algorithm, which makes use of the information provided by a continuously updated set of efficient spanning trees, and a lower bound on each partial solution, to avoid branching.
Sourd and Spanjaard proposed a branch and bound, initialized with a set of extreme supported solutions, using neighborhood search after the first initialization, and by applying tighter bounds within the branch-and-bound algorithm [34]. Note that their approach only computes one efficient spanning tree for each nondominated point.
The approach proposed in Steiner et al. [35] constructs the set of supported solutions as in Ramos et al. [29], but it makes use of k-best solutions based algorithm for the second phase, in order to search for the remaining efficient spanning trees. This algorithm solves a single-objective minimum spanning tree problem for each pair of consecutive supported spanning trees. In this new singleobjective problem, the costs of the edges are obtained by weighting the costs of both objectives in relation to the costs of the consecutive pair of trees. The k-best algorithm is run to obtain the remaining spanning trees. Similar approaches have been proposed for obtaining an approximation of the non-dominated set. In Hamacher et al. [18], the first phase follows the same principle as in Ramos et al. [29]. The second phase is based on neighborhood search. Amongst each pair of consecutive spanning trees in the current set, ordered according to one of the objectives, the approach searches for a spanning tree that is not under a certain euclidean distance between the corresponding objective points from the pair. Andersen et al. [4] introduced a similar two-phase based technique, but considering further variants in the second phase.
Other approximation methods have been proposed, in particular, evolutionary based algorithms. Zhou et al. [39] proposed an evolutionary algorithm approach to find an approximation of the non-dominated set. This approach makes use of the Prufer encoding to represent a spanning tree. Knoweles et al. [21] also proposed an evolutionary algorithm that makes use of three encoding techniques as well as evolutionary operators for each encoding.
Seipp introduced an approach to find the set of non-dominated extreme points of the tri-objective spanning tree by using a weighted space decomposition technique [33]. The weight set is divided into the maximal possible divisions for which all the points in such a subspace have the same MST in the objective space for the parametric spanning tree problem. Then, for each subspace, an exact algorithm for the MST, such as the Kruskal algorithm, can be applied to obtain the corresponding supported non-dominated point. The author was mainly interested in showing that the number of non-dominated extreme points is polynomially bounded with respect to the instance size for a fixed number of objectives. No implementation of the algorithm has been made, and no description on how to efficiently encode and store the candidate indifference regions was proposed.
Corley [9] proposed a generalization of the Prim's algorithm [26] to find the whole set of efficient spanning trees. However, the approach was shown to be incorrect in Hamacher and Ruhe [18]. More recently, Lacour proposed to integrate a ranking strategy in a branch-and-bound algorithm [23]. The ranking procedure of the algorithm starts by finding a subset of supported trees and improves that set with a neighbourhood search. Then, the efficient spanning trees of the problem are found by several runs of the ranking procedure with different ranking directions. This algorithm is integrated in a branch-and-bound scheme, where the ranking procedure runs at a branching node level of the search tree rather than for the whole problem. Pugliese et al. [28] proposed a dynamic programming approach that builds all the spanning trees in a Prim-like scheme. Each partial solution is a spanning tree of a subset of vertices and is extended by adding an edge connecting it to a vertex that does not belong to such a subset. A dominance relation is used to prune partial solutions that represent spanning trees of the same subset of vertices.
Our review of the existing methods suggests that several techniques have been applied to design efficient algorithm for solving the bi-objective spanning tree problem. Most of these algorithms make use of bounds for pruning the search space. We also noticed that, for problems with three or more objectives, the solution approaches are rather scarce and elementary; they make no use of advanced pruning techniques. For example, the dynamic programming approach of Pugliese et al. [28] could certainly benefit of using a good bound to prune candidates even further. For bi-objective problems, an efficient bound that is quite often used is the set of supported non-dominated points, see [14] for the bi-objective knapsack problem. However, when dealing with more than two objectives, it is not trivial to devise an algorithm that efficiently calculates such a set. For instance, Lacour devised a very elementary method, which computes only a subset of supported nondominated points using parametric programming for a ''well dispersed'' subset of weight sets [23]. Seipp proposed to calculate the full set of extreme points by dividing the weight set in several sub-spaces and solving a single objective problem for each subspace [33]. The computation of all weight sets would require that generated sets would be efficiently stored while they are being computed. There can exist at most m ¼ nðn À 1Þ=2 edges for an instance of size n, which means that mðm À 1Þ=2 different polylines (corresponding to edge swaps) may intersect the weight set and split them into different weight sets. This result bounds the number of different p À 2 weight sets that can be decomposed (see Proposition 3). Such an algorithm seems to require efficient implementations with regards to memory usage and time performance. Nevertheless, the work in Seipp does not give any details on how to implement it [33]. Additionally, this algorithm would not take into account that optimal solutions for neighboring indifference regions have adjacency relations between them, and it can be infered from the edge swaps that generate the different regions. Instead, several independent runs of the single objective versions of the problem need to be made in order to identify those solutions. Finally, this algorithm only provides a single solution per each extreme supported non-dominated point, ignoring alternative solutions that can be of interest for a decision maker, and ignoring non-extreme supported efficient solutions.
In the following, we introduce an algorithm that is able to compute the whole set of supported non-dominated points and supported solutions, avoiding to run several times an MST algorithm.

An algorithm for generating all supported spanning trees
This section presents an algorithm to obtain the set of supported efficient spanning trees. It starts by introducing some additional theoretical concepts. Then, it presents a description of the pseudo-code of the algorithm. The proof of its correctness is also presented. Finally, an example on a tri-objective problem illustrates the main steps of the algorithm.

Some additional concepts
In the following, we introduce the concept of candidate spanning tree, which is important for the connectedness of the set of efficient spanning trees.
Definition 6 (Candidate spanning tree) Let T 0 denote a supported spanning tree and T 00 one of its immediate neighbors. T 00 is called a candidate spanning tree if and only if: (a) T 0 and T 00 does not dominate each other (the elementary move, or swapping, that allows to obtain T 0 from T 00 is called an eligible move). (b) zðT 0 Þ and zðT 00 Þ are adjacent points in Z ! (T 00 is obtained after filtering the eligible moves that bound the indifference region of T 0 . In what follows we call them candidate moves).
There is a relation between the extreme points of Z ! and the corresponding spanning trees. For each extreme point of Z ! there is at least one corresponding spanning tree. Moreover, the adjacency relation between extreme points of Z ! has a correspondence with the adjacency of spanning trees (see [17]). In fact, according to the notion of adjacency in Definition 1, the set of extreme supported spanning trees is connected [17] and polynomial bounded (see page 77 in Seipp [33]).

Proposition 4 (Connectedness)
The set of extreme supported spanning trees is connected.
Proposition 5 (Cardinality) The number of extreme supported non-dominated points of a MOST problem is at most 2m 2ðpÀ1Þ .
In the following, we introduce the concept of separating hyperplane, which is useful to show that our algorithm calculates only and all the supported efficient spanning trees. Consider a swap s T 0 ;T 00 ¼ hfi; jg $ fk; 'gi, allowing a move from T 0 to T 00 . For a given weight vector w, let c w ij ¼ P p q¼1 c q ij w q denote the cost of vertex fi; jg 2 T 0 , and c w k' ¼ P p q¼1 c q k' w q denote the cost of vertex fk; 'g 2 T 00 in the wMOST problem. Let H 2 R p denote a subspace of dimension p À 1. H is called an hyperplane of R p and separates R p in two convex sets, called half spaces.
Note that the set H ij;k' \ W contains all the weight vectors w for which edges fi; jg and fk; 'g weight the same for the parametric spanning tree problem. From this observation, the definition of a separating hyperplane can be devised as follows (see page 61 in [33]).
Proposition 6 (Separating hyperplane) Consider a weight set W 0 W, and an hyperplane H ij;k' . The hyperplane W ij;k' ¼ H ij;k' \ W 0 is called a separating hyperplane if and only if dimðW ij;k' Þ ¼ p À 2.

The general algorithmic framework
The algorithm presented in this section generates the whole set of efficient supported spanning trees and corresponding supported non-dominated points of the MOST problem by applying local search techniques in a neighborhood that takes into account the definition of adjacency (see Definition 1). As input the algorithm requires the valued graph, G ¼ ðV; E; CÞ, and the weight set W. The main output is the above mentioned sets of supported efficient solutions and supported nondominated points. In addition, the algorithm also outputs W split into all indifference regions W 1 ; . . .; W i ; . . .; W r . Algorithm 1 starts by finding a lexicographic efficient spanning tree T 0 . This is performed by ordering the edges of E in a lexicographic way, with respect to the values of each objective function, z 1 ; . . .; z ' ; . . .; z p . For calculating such a tree, we use the function, lexicographic_MST(G), which requires as input the graph G. At each step, the algorithm adds, to the current forest, the least lexicographically ordered edge.
In what follows, we shall consider two lists: • MðT 0 Þ is a list containing all the filtered eligible elementary moves that can be performed from T 0 ; function swap_filter(T 0 ) lists those moves. • L is a list containing extreme supported spanning trees; function extract(L) extracts a candidate spanning tree T 0 , and updates L; The fundamental goal of the main loop of the algorithm is to calculate the indifference region associated with an extreme supported spanning tree, T 0 , and to generate the supported spanning trees neighbors of T 0 . It works as follows: While the list L is not empty, a tree, T 0 , is extracted from this list, through the use of the function extract(L). Then, the function swap_filter(T 0 ) is applied to generate the list of eligible elementary moves that can be applied to T 0 . This filtering is a performance improvement over the algorithm proposed in Seipp [33]. The swaps that are filtered are those that lead to infeasible, dominated and equivalent solutions.
These swaps do not contribute to the generation of the indifference region, as it will be proved in the following section. The indifference region W 0 is calculated by using the function build_indif(T, MðT 0 Þ; W). Note that all the spanning trees associated to two extreme points that bound this region, and all the spanning trees associated to eventual supported nonextreme points in that face, are optimal for the parametric problem for every point w 2 W 0 . Note also that the optimal trees for the parametric spanning tree problem corresponding to points that belong to intersections of boundaries of W 0 are the union of the optimal trees of the parametric problem for every point in these boundaries. Thus, for each pair of boundaries of W 0 with a non-empty intersection, its intersection point needs to be calculated. For all boundaries with no intersections with any other boundary, an interior point is computed. All minimum spanning trees corresponding to parametric problems for weights based on weight set points calculated as described are computed. All those trees are added to the set of supported trees, PS, and their correspondent objective points are added to the set NS. L is updated with the inclusion of one of the trees corresponding to the newly calculated point, which is potentially a candidate extreme point. In order to improve CPU-time performance, and correctly halt the algorithm when all the points have been calculated, some additional lists are added to the algorithm: A list that contains all the supported extreme points already computed and a list containing points of the weight set that were already expanded. This is done to avoid recomputing weight set points and indifference regions.
In the following, we give some more details about the procedures and their time complexity: • extract(L): This function extracts a tree T 0 , from the list of candidate spanning trees, L, according to a heuristic selection rule (e.g., first-in-first-out, last-in-lastout, randomly). This function runs in Oð1Þ and the order in which the trees are selected does not affect its performance (note that choosing a different selection rule may yield to a different performance in practice. However, there does not seem to exist an obvious reason to choose a different rule in our case). • swap_filter(T 0 ): This function is divided into two main phases: (i) The generation of eligible moves; and (ii) the filter of those moves by considering only the candidate moves.
(i) In the first phase, the list of eligible moves that can be applied to T 0 is created. This step is performed in linear time with respect to the maximum number of moves for each edge of the tree (the total number of moves per tree is bounded above by ðn À 1Þðm À 1Þ). (ii) In the second phase, the filtering of moves occurs. A eligible move s T 0 ;T 000 is removed from the list of candidate moves if, and only if, there exists another eligible move s T 0 ;T 00 in which W T 0 ;T 000 & W T 0 ;T 00 . Then, each eligible move is compared against each other. Consequently, and as the number of eligible moves is bounded above by ðn À 1Þðm À 1Þ, the overall complexity of the filtering is Oðn 2 m 2 Þ.
• build_indif(T 0 ; MðT 0 Þ; W): This function calculates the weight set that represents the indifference region of the tree T 0 . This task is performed by considering initially the weight set W, and by reducing such set by generating the separating hyperplane associated to each candidate move. Considering t candidate moves, the number of operations of this function is bounded by Oðt 2 ). Note that the maximum number of candidate moves is bounded above by the minimum between the number of extreme spanning trees (2m 2ðpÀ1Þ ) and the number of possible eligible moves ðn À 1Þðm À 1Þ. Thus, the complexity of this function is bounded above by Oðminfn 2 m 2 ; m 4ðpÀ1Þ gÞ. Each indifference region is represented by the vertices of the boundary of each region. • build_ST(T 0 ; s T 0 ;T 00 ): This function generates a candidate spanning tree, T 00 , by copying all the edges of the supported extreme spanning tree, T 0 , but one, and swapping the edges according to the move s T 0 ;T 00 . The complexity of copying a tree is linear with respect to the number of edges of each tree (n À 1). The swapping operation can be performed either when copying the original tree, or in a separated step. In the first case, the swap is done in constant time, while in the second case it runs linearly with respect to the number of edges. The overall complexity is thus OðnÞ, independently on the strategy to select the swapping of edges. • computed_weight_points(W i ): This function receives the weight set of dimension p À 2 calculated in build_indif, W 0 , and returns points of this weight set, in such a manner that all supported points of the problem can be computed. Each p À 2-dimensional weight set is delimited by p À 3-dimensional weight sets, and, in general, each p À k-dimensional weight set is delimited by p À ðk þ 1Þdimensional weight sets, for all k\p. Thus, W i is delimited by weight sets of dimension k where 0 k p À 2. For each of this delimiting weight sets, at least one interior point is added and returned by this function.
(a) For each pair of 0-dimensional delimiting point of W i that does not belong to the weight set, it is checked if they belong to any 1-dimensional delimiting weight set of W i and it belongs to the weight set. If affirmative, an interior point of this 1-dimensional delimiting weight set is returned. If not, the 1-dimensional weight is added to a new temporary set to be used as it is described in the following: (b) Procedure (a) is recursively applied for each k-dimensional delimiting sets, for 1 ! k ! p À 2, stored in the temporary set in the previous iteration, until no k þ 1-dimensional weight sets are added, or k ¼ p þ 2. All interior points found in such a way are returned by the function.
• all_MST(G ¼ ðV; E; wCÞ): This function receives the graph, with vertices, and edges, and the weights for the costs of each edge. It returns all the minimum spanning trees of that problem. After computing this function, the corresponding indifference region can be discarded. This is performed for efficiency reasons, since although the number of indifference regions is polynomially bounded, it may require a large amount of memory. • candidate(PS i;k ): This function receives a set of supported spanning trees and returns the list of candidate supported extreme trees that has not been computed so far.
Algorithm 1 Listing all the supported spanning trees for the MOST problem. w ← computed weight points(W i ); 12: for w ∈ w do 13:

Correctness of the algorithm
Our algorithm is based on the solution of parametric problems and a neighborhood search technique. It makes use of the concept of indifference region, and starts by calculating a lexicographically MST, which is an extreme supported spanning tree. The algorithm solves the problem of determining all the supported efficient spanning trees.
Theorem 1 (Correctness of the algorithm) Algorithm 1 outputs only all supported spanning trees for MOST problem.
Proof The algorithm correctness consists of proving the following two statements.
1. If T 0 is found by the algorithm at step 1 or 14, then T 0 is an efficient supported spanning tree (soundness). 2. The algorithm finds all the supported efficient spanning trees (completeness), that is, at step 18, NS contains only and all supported efficient spanning trees.
Soundness is proved by construction, while completeness is done by contradiction. In case 1, we claim that, if T 0 is found by the algorithm, then T 0 is an efficient supported spanning tree. There are two possible cases: (a) Either T 0 is an extreme supported efficient spanning trees, or; (b) T 0 is a non-extreme supported efficient spanning tree.
In Case (a), T 0 has an indifference region of dimension p À 1 (Proposition 3a), while in the Case (b), T 0 has an indifference region of at most dimension p À 2 (Proposition 3b).
The algorithm works by building indifference regions adjacent to already calculated indifference regions. This is performed in such a manner that the whole indifference region W is created. Let fz 1 ; . . .; z i ; . . .; z r g denote the set of nondominated extreme points, and W i denote the indifference region associated to trees with objective value z i , for all i ¼ 1; . . .; r. From Proposition 3(c) we know that The algorithm stops when W is entirely built, and there is no supported efficient solution left to be explored, that is, list L is empty (Line 6, Algorithm 1). As described in Sect. 3.2, the edges of E are ordered in a lexicographic order with respect to the values of each objective function, z 1 ðTÞ; . . .; z ' ðTÞ; . . .; z p ðTÞ, for all T 2 T . The first supported efficient tree T 0 is obtained by an application of the Kruskal algorithm, with edges ordered in a lexicographical order with respect to one of the objectives. It should be noted that at this step, only a single lexicographic minimum spanning tree is calculated. The corresponding non-dominated point in the objective space and the solution are added to the list of supported points/solutions (Line 3 and 4, Algorithm 1). If there are multiple optimal extreme supported spanning trees for this minimum lexicographic extreme non-dominated point, they will be computed after computing the indifference region for T 0 . (Lines 7-9, Algorithm 1) Thus, the p À 1 dimensional indifference region, W 0 , associated with T 0 is built by the algorithm.
The indifference region of T 0 , W 0 , is delimited by a set of indifference regions that are single points of the weight set, which are the intersection of W 0 with other regions. From Proposition 3b, we know that the parametric problem with weight sets of each of these indifference regions have at least one alternative optimal spanning tree. Thus, T 0 has at least the same number of adjacent spanning trees as the number of adjacent indifference regions W 0 . These adjacent spanning trees are extreme spanning tree solutions (Case a)).
Non-extreme supported efficient trees (Case b)) are optimal in points of the weight set that do not belong exclusively to a p À 1 dimensional weight region (otherwise they would be extreme supported trees, according to Proposition 3a). Thus, these trees are optimal in points of ðp À iÞ dimensional indifference regions (for p > i > 2). From W 0 we can calculate the points to find such trees. These trees are calculated by finding the optimal solutions corresponding to the points extracted from the delimiting indifference regions computed by function com-puted_weight_set (where the adjacent spanning trees of T 0 are also alternative optimal). The next step of the algorithm is to pick a vector of weights from each of the indifference regions delimiting W 0 , where multiple optimal supported spanning trees can be found (Line 12, Algorithm 1). For each selected vector of weights, all_MST algorithm is applied for the corresponding parametric spanning tree problem (Line 13, Algorithm 1). The union of the outcome of the computation of all runs of the all_MST procedure leads to a subset of supported efficient spanning trees (Lines 15-16, Algorithm 1). From this subset, the trees that have already been computed are discarded, whereas the remaining are added to the list of computed spanning trees. Note that at that point it is not possible to know if the new supported efficient spanning trees are extreme (Case a)) or not (Case b)). However, there is the guarantee that at least one of the new supported efficient solutions is extreme. The only exception is the case where there exists only one indifference region in the whole weight set. Therefore, the new supported efficient spanning trees are added to the list. (Line 15, Algorithm 1) The algorithm is applied to all the efficient spanning trees in the candidate set (Line 6, Algorithm 1). The efficient spanning trees that generate p À 1 dimensional indifference regions are extreme spanning trees (Case a)), and are used for computing new supported efficient spanning trees. The efficient spanning trees that generate indifference regions with at most p À 2 dimensions, are non-extreme (Case b)) and this indifference region will not be used to further computations, as they were previously computed.
Note that T 0 can never be a non-supported spanning tree, otherwise it would have an empty indifference region, which is not the case for any spanning tree solution found by the algorithm, as either it is a lexicographic minimum (which has a corresponding p À 1 dimensional indifference region), or it is found as an alternative optimal solution for a parametric problem of a given weight set, thus having a non-empty indifference region. In other words, by construction, it is clear that the set NS in Line 18 cannot contain inefficient or unsupported efficient spanning trees, since it makes use of the parametric problem. Thus, the output is always a supported efficient spanning tree.
We now prove 2). Assume that T 0 is a supported spanning tree that was not found by the algorithm. The only reason for this to happen is because the algorithm was not able to find the indifference region to which T 0 belongs to. However, since the indifference regions are connected, and since function All_MST finds all supported efficient spanning trees, it is not possible to have missed that indifference region. h

An illustrative example
This section introduces a small illustrative example with three objective functions. In the first subsection, we report all the MSTs for a parametric problem as well as the adjacency graph. Then, all the non-dominated points and corresponding efficient spanning trees are listed. Finally, we illustrate the main steps of the algorithm in this particular case. Figure 1 presents an example of a complete graph with 7 vertices and 21 edges. For this graph, the total number of spanning trees, according to the Cayley formula, is n nÀ2 ¼ 7 5 ¼ 16807.

A complete graph and the set of all optimal spanning trees
Consider the parametric problem with weight k ¼ ð6=60; 4=60; 50=60Þ. There is a total of 12 MSTs with z k ðT Ã Þ ¼ 52=5 (see Table 1). Figure 2 shows the adjacency graph of these MSTs. This is in accordance with the result of Proposition 2.  All 16 points are supported, of which z 1 , z 2 , z 3 , z 4 , z 5 , z 6 and z 7 are extreme. Figure 3 shows a three-dimensional representation of the set of non-dominated points. Points in red correspond to supported extreme, points in green color correspond to supported non-extreme points that are on the edges of the convex hull defined by nondominated points, and points in black are supported non-extreme points that are not in those edges. The non-dominated facets are also represented. ''Appendix A'' presents all the efficient spanning trees associated with all non-dominated points for this particular instance.

Computing all the supported spanning trees
In the following, we ilustrate the main steps of Algorithm 1 for the illustrative example. First, a lexicographic spanning tree T 0 is calculated (Line 1), where zðT 0 Þ ¼ ð13; 17; 11Þ. This tree is added to list L (Line 2) and, since T 0 is an extreme supported tree, sets NS and PS are updated (Lines 3 and 4). T 0 is the first tree, thus, from hereafter, it is referred to as T 1 . Variable i is updated (Line 5). Then, the main loop starts (Line 6). T 1 , the only tree in L, is extracted from L (now temporarily empty) to T 0 (Line 7). Method swap_filter is applied to T 0 to extract the elementary moves that lead to immediate neighbors of T 0 . Table 2 shows the list of elementary moves that lead to trees that are not dominated by T 1 (Line 8). This list of elementary moves is filtered out in order to contain the minimum amount of edge swaps that allow the generation of the indifference region W 1 associated to T 1 (Line 9).
Note that there are 24 edge swaps that lead to spanning trees that are not dominated by T 1 , but they only generate 6 distinct separating hyperplanes. Figure 4 displays the 6 distinct hyperplanes. The gray filled area represents the weight set. This weight set corresponds to the region k 1 [ 0; k 2 [ 0; k 1 þ k 2 \1, therefore, it is delimited by k 1 ¼ 0, k 2 ¼ 0 and k 1 ¼ 1 À k 2 , but they are not included in the set. Note that T 1 is a lexicographical optimal solution considering that k 1 refers to the first objective. First, only one swap from each group of distinct separating hyperplanes is kept by the filter function. Thereafter, pairwise comparisons amongst the remaining swaps are performed. The goal of those comparisons is to find if any other edge swap can be removed before calculating the indifference region W 1 . A swap s is filtered if, when calculating W 1 , there is at least one other swap that would reduce the region in such a way that the separating hyperplane generated by s would not intersect the reduced region. In this example, the separating hyperplane represented by the straight line in gray in Fig. 4 is discarded, because it would not intersect a reduced region after computing the separating hyperplane in orange (k 2 ¼ 1 9 k 1 þ 4 9 ). Table 3 shows the edge swaps that return from function swap_filter (Line 8) and that are used as input for function build_indif (Line 9), to generate the indifference region W 1 . The indifference region is intersecting the weight set region with each filtered separating hyperplane, and reducing the weight set at each step. The indifference region W 1 is shown in Fig. 5.
After calculating the indifference region, the p À 2 dimensional facets that bound W 1 are obtained. These are the facets in which the alternative supported spanning trees are found, and from which the next extreme solutions can be calculated. In this Table 2 Elementary moves associated to T 1 Edge out Edge in Separating hyperplane , there are four p À 2 facets that are used to calculate the alternative and upcoming spanning trees. This calculation is represented in Algorithm 1 in the inner for loop, and is explained as follows. Each p À 2 dimensional facet of W 1 is explored by computing weight points w Ã , where w Ã 2 W 1 (Line 11) and for all facets W 10 2 W 1 , at least one point w 0 2 w Ã belongs to W 10 . The algorithm retrieves all the spanning trees that are minimal for the parametric spanning tree problem with weights w (Line 13), for each w 2 w Ã . The trees and points found in this step are added to lists PS (Line 14) and NS (Line 15), respectively. Then, a spanning tree with objective function different than zðT 1 Þ per each facet is calculated and added to L (Line 16). In our numerical example a large number of alternative trees is calculated in this step. Table 4 shows, in a simplified form, the trees calculated within these steps. A and B represent the points of the two 0-dimensional weight sets that bound each of the 1-  Table 3 Elementary moves associated to T 1 after the filtering Edge out Edge in Separating hyperplane weight set W 10 , while w represents an interior point of the 1dimensional weight set. For a 3-objective problem, no more weight points than A, B and w needs to be taken into account as potential points to find supported nondominated points of the problem. Some considerations about how to chose between A, B and w are provided below. Next column shows the number of alternative spanning trees that are optimal for that facet. The number of new trees corresponds to the number of supported trees that is first discovered in this facet. Note that in the first facet only one out of 46 trees is not new; such tree is T 1 . After this procedure, 52 new supported spanning trees are found. Note that it is not necessary to use A, B and w to find all supported trees. In fact, A and B belong to the 0-dimensional weight set, but they are also points that belong to the 1-dimensional point facet that we are computing. However, in some cases, A and B might fall outside the full weight set (e.g. A ¼ ð0:5; 0Þ, and B ¼ ð1; 0Þ), and, for these cases, the weight point w needs to be used to compute alternative supported points. Let us look at W 1;1 . Point A is excluded as it lies outside the set of weights (it is in k 2 ¼ 0), thus all supported trees found in point w will also be found in B (but  not necessarily vice-versa). In case of W 1;2 , where both A and B are inside the weight set, all the trees found in w will be present in A and in B, but eventually some trees in A will not be present in B and w, and some trees in B will not be present in A and w. This property also holds for problems with more than 3 objectives. Table 5 displays the non-dominated points that are found in each facet, and one of the trees corresponding to each non-dominated point. Note that the last point presented in the table per each facet corresponds to the next extreme point. Therefore, trees T 4 , T 5 , T 6 , and T 7 are added to list L.
In the next step of the inner while cycle, 4 trees are found in list L ¼ fT 4 ; T 5 ; T 6 ; T 7 g. The first one is extracted to T 0 and the process is repeated until L is empty. Note that, in the following steps, extreme trees corresponding to points calculated in a previous step are not included to L. This step is important to avoid generating cycles and calculating the same indifference region multiple times.

Computational experiments
This section presents an experimental analysis of our approach on a wide range of MOST instances. Algorithm 1 was implemented for MOST instances with 3 objective functions. The code was written in C?? programming language and compiled using compiler g?? with the optimization flag ''-O3''. The experiments were performed in an Intel (R) Core I7 4770 3.4 GHz with 32 GB Ram at 1600 MHz, with operating system Ubuntu version 16.04 LTS Xenial Xerus.

The design of the experiments
The majority of the experimental studies for this problem uses complete graphs [4,29,34], grid graphs [4,34,35], graphs with varying density [28,35] and specifically modified hard graphs [34]. In most cases, the weight costs are generated randomly, although, in some studies, correlated instances are also considered [4,35]. Most graphs used on these studies have a relatively small amount of vertices (up to 50); only Sourd and Spanjaard in [34] report results on instances up to 500 vertices, and Steiner in [35] with uncorrelated grid instances up to 121 vertices. In Pugliese et al. [28], they report results on MOST instances with more than two objectives, with 10-20 vertices and, at most, 170 edges. Additionally, they have considered instances with 50-100 vertices but with a very low density of edges, from 62 to 125.
For our experimental analysis, three main types of graphs were considered: 1. Density graphs: graphs in which an edge between a pair of vertices is generated with a probability d (d ¼ 0:1; 0:4; and 0.7). 2. Complete graphs: graphs with one edge connecting all pairs of vertices; note that a complete graph is a density graph with d ¼ 1:0. 3. Grid: Vertices displayed in a n Â n square, where each vertex is connected to the left, right, up and down neighbor vertices, except for the vertices in the limits of the grid.
The edge weight costs were randomly generated using an uniform distribution in the interval [1,1000] for every objective value. Tests were performed for complete graphs from 10 to 60 vertices, density graphs from 10 to 110 vertices and grid graphs from 25 to 256 vertices. Additionally, a set of instances was generated with conflicting objectives in order to simulate a more realistic scenario. For those conflicting instances, the costs of the two first objectives, c 1 ij ; c 2 ij , were generated similarly to non-correlated instances. The costs in the third objective were computed as follows: c 3 ij ¼ Àað1 À c 1 ij Þ þ ð1 þ aÞb, where a 2 ½À1; 0 is the correlation parameter and b is a randomly generated value using an uniform distribution in the interval [1,1000]. We consider a ¼ À0:4 (correlated instances) and a ¼ À0:8 (highly correlated instances) for our experiments. For each combination of graph type, density (whenever applicable), type of weight cost relation (random, conflicting or highly conflicting), and size, we generated 30 different test cases. Tables 6 and 7 characterize the density and grid graphs, respectively, in terms of the number of vertices.

Experimental results
According to Seipp, the number of extreme points in a MOST problem is bounded by 2q pÀ1 , where q is the number of separating hyperplanes that can divide the weight region [33]. The author estimated that the number of hyperplanes is at most m 2 , where m ¼ jEj. However, the number of separating hyperplanes is at most mðm À 1Þ=2, as each edge can only be swapped with the other m À 1 edges, and amongst each pair of edges, independently of which edge is going in/out of the tree, only one separated hyperplane is generated. Therefore, the upper bound on the number of extreme points of the tri-objective MOST problem is m 4 À 2m 3 þ 2m 2 . Figure 6 shows a comparison between the upper bound on the number of extreme points and the number of points obtained from our experiments for two different types of graphs (density and complete graphs). The number of solutions obtained is considerably smaller than the theoretical upper bound. Note that our algorithm obtains first each extreme tree and only thereafter it obtains the corresponding indifference region for the obtained tree. In contrast, in Seipp [33], the candidate indifference regions are built, and then, the extreme optimal solution associated to each region are calculated. This might result in the merge of several regions. As a consequence, the number of regions constructed and, consequently, the number of parametric spanning tree problems that the algorithm proposed in [33] has to solve can be as large as the maximum theoretical number of indifference regions. Thus, the large difference between the number of regions obtained by our algorithm and the maximum number of possible regions suggests that an algorithm that computes firstly the set of indifference regions might generate a large amount of regions Table 7 Average number of vertices in grid graphs of size n   n  25  36  49  64  81  100  121  144  169  196  225   Vertices  40  60  84  112  144  180  220  264  312 364 420 Fig. 6 Maximum number of extreme points and the number of extreme points obtained for density graphs with d ¼ 0:1 (left), and for complete graphs (right) leading to the same solution. That means that such an algorithm would spend a considerable amount of time recalculating spanning trees that were already found.
In the following, we present experimental results on the average CPU-time of our approach on the different types of instances. ''Appendix B'' contains three tables that summarize the average CPU-time results obtained for density, complete and grid graphs, respectively. Each table shows the number of vertices, correlation, density, average number of edges, average number of extreme points and average CPU-time in seconds for 30 runs on different instances per each setting. Note that the average number of supported spanning trees and extreme trees are omitted from the results as such number is almost the same in most cases. The reason for such a similarity may be related to the wide range of edge costs considered in our setting ([1, 1000]), which would unlikely lead to the generation of identical edges and, consequently, to increase the number of extreme or supported spanning trees in comparison to the number of extreme points. Table 8 shows the effect of increasing the number of vertices and the number of edges on the running-time of our approach. Clearly, as the instance size grows, the algorithm requires more time to terminate. Table 9 shows the effect of changing the correlation value. Our results suggests that the correlation parameter has some impact on the performance of our approach.

Conclusions
The minimum spanning tree problem is a combinatorial optimization problem used in a wide range of different applications. The majority of real-life problems have often multiple conflicting objectives. These leads to the multiple objective spanning tree problem, which goal is to find the set of efficient spanning trees. This problem as been tackled in the majority for the bi-objective case, where several approaches have been developed. The majority of the approaches developed to generate the set of efficient trees are based on a two phases procedure, where in the first phase a pool of ''good'' candidates is calculated, usually the set of supported trees, to then be used as a bound to prune the search space. Literature is scarce on scenarios with three or more objectives, where few solutions have been proposed. To the best of our knowledge, the main works still do not exploit this reduction of the search space, possibly because either the efficient generation of the set of supported trees for that specific problem has not been properly studied in the literature, or the algorithms proposed have not been implemented or tested.  In this article, we propose an algorithmic framework to calculate the set of supported spanning trees. We experimentally tested the algorithm on severel triobjective spanning tree problem instances. The algorithm takes advantage of the connectedness properties of the set of supported solutions. It calculates this set of trees by generating the indifference regions associated to each supported spanning tree, and by searching in the boundaries of that region for neighbor trees that are also supported. The algorithm terminates when the union of the calculated indifference regions is equivalent to the entire weight set region. Our experimental results shows that our algorithm finds the set of supported spanning trees in a reasonable amount of time on a wide range of different instances. These results suggest that our approach can be used as a first phase within two-phase algorithmic frameworks for this problem. Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http:// creativecommons.org/licenses/by/4.0/.
Appendix A: All efficient spanning trees and non-dominated points See the Table 10.  Table 10 All efficient spanning trees for the numerical example P N