Dual Neighborhoods Search for Solving The Minimum Dominating Tree Problem

1. Introduction

The minimum dominating tree problem for weighted undirected graphs is to find a dominating tree in a weighted undirected graph such that all vertices in this weighted undirected graph are either in or adjacent to this tree, and the sum of the edge weights of this tree is minimized [1]. Adjacent means that there is an edge between this vertex and at least one vertex in the tree. The minimum dominating tree is a concept in graph theory and one of the important classes of tree structures in graph theory.

A highly related problem, the Minimum Connected Dominating Set (MCDS), has been extensively studied for building routing backbone wireless sensor networks (WSNs) [2,3]. One of the goals of introducing MCDS in WSNs is to minimize energy consumption; if two devices are too far away from each other, they may consume too much power to communicate [4,5]. Using a routing backbone to transmit messages will greatly reduce energy consumption, which increases dramatically as the transmission distance becomes longer [6]. However, some directly connected vertices in MCDS may still be far away from each other because MCDS does not account for distance [7]. Therefore, considering each edge in the routing backbone is more in line with energy consumption purposes [8]. The Minimum Dominating Tree (MDT) problem was first proposed by Zhang et al. [9] for generating a routing backbone that is well adapted to broadcast protocols.

Shin et al. [1] proved that MDT is NP-hard and introduced an approximate framework for solving it. They also provided heuristic algorithms and mixed integer programming (MIP) formulations for the MDT problem. Adasme et al. [10] introduced two other MIP formulations, one based on a tree formulation in the bidirectional counterpart of the input graph, and the other obtained from a generalized spanning tree polyhedron. Adasme et al. [11] proposed a primal dyadic model for the minimum cost dominated tree problem and an effective inequality to improve the linear relaxation. Álvarez-Miranda et al. [12] proposed an precise solution framework that combines a primal-dual heuristic algorithm with a branch-and-cut approach to transform the problem into a Steiner tree problem with additional constraints. Their framework solves most instances in the literature within three hours and proves its optimality.

In recent years, efficient heuristic algorithms for MDT problems have flourished. Sundar and Singh [13] proposed two meta-heuristic algorithms, the Artificial Bee Colony (ABC-DT) algorithm and the Ant Colony Optimization (ACO-DT) algorithm, for the MDT problem. These two algorithms are the first meta-heuristics for the MDT problem and provide better performance than previous algorithms. They also provided 54 randomly generated instances in their work, which are considered challenging instances of the MDT problem and are widely used to evaluate the performance of algorithms for the MDT problem. Based on the latter work, Chaurasia and Singh [14] proposed an evolutionary algorithm with guided mutation (EA/G-MP) for MDT problems. Dražic et al. [15] proposed a variable neighborhood search algorithm for MDT problems. Singh and Sundar [16] proposed another artificial bee colony (ABC-DTP) algorithm for the MDT problem. This new ABC-DTP method differs from ABC-DT in the way it generates initial solutions and in the strategy for determining neighboring solutions. Their experiments show that for the MDT problem, ABC-DTP outperforms all existing problem-specific heuristics and meta-heuristics available in the literature. Hu et al. [17] proposed a hybrid algorithm combining genetic algorithms (GAITLS) and iterative local search to solve the dominated tree problem. Experimental results on classical instances show that the method outperforms existing algorithms. Xiong et al. [18] present a two-level meta-heuristic (TLMH) algorithm for solving the MDT problem with a solution sampling phase and two local search based procedures nested in a hierarchical structure. The results demonstrate the efficiency of the proposed algorithm in terms of solution quality compared with the existing meta-heuristics.

Metaheuristics have been shown to be very effective in solving many challenging real-world problems [19]. However, for some problems, due to the complexity of the problem structure and the large search space, the classical metaheuristic framework fails to produce the desired results [20]. Many researchers have relied on composite neighborhood structures. If properly designed, most composite neighborhood structures have proven successful [21]. These methods include Variable Depth Search (VDS), which searches a large search space through a series of successive simple neighborhood search operations. Although understanding of the basic concepts of VDS algorithms dates back to the 1970s [22], researchers have maintained a sustained enthusiasm for the term [23,24]. For a more detailed survey of VDS, we refer to Ahuja et al. [25,26,27]. Another idea for dealing with complex structural problems is to use a hierarchical meta-trial approach, where several trials are combined in a nested structure. Wu et al. [28] successfully implemented a two-level iterative local search for a network design problem with traffic sparing. According to their analysis, hierarchical metaheuristics must be carefully designed to balance the complexity of the algorithm and its performance. In particular, for the outer framework, keeping it as simple as possible makes the algorithm converge faster. Pop et al. [29] proposed a two-level solution to the generalized minimum spanning tree problem. Carrabs et al. [30] introduced a meta-heuristic algorithm implementing a two-level structure to solve the shortest path problem for all colors. Contreras Bolton and Parada [31] proposed an iterative local search method to solve the generalized minimum spanning tree problem using a two-level solution.

In this paper, we design a meta-heuristic algorithm for two-neighborhood search to solve the MDT problem that uses two neighborhood moves to perform the search and combines a taboo search to escape local optima. The DNS algorithm is described in detail in Section II, the experimental results of the DNS algorithm and comparison with other algorithms are given in Section III, and some comparative experiments within the DNS algorithm are done in Section IV.

2. Dual Neighborhood Search

2.1. Main Framework

The basic idea of our proposed DNS algorithm is to tackle the MDT problem by optimizing the candidate dominating tree weight using a neighborhood search based meta-heuristic with two neighborhood move operators. The search space of DNS consists of all the minimum spanning trees of all the possible dominating sets of the instance graph. The proposed NDS algorithm optimizes the following objective function:

$$f\left(T\right)=\alpha f_1\left(X\right)+f_2\left(E{}^{\prime }\right)$$

(1)

Where $T=(X,E^{\prime })$ stands for the current configuration, i.e., the candidate dominating tree; Notations X and $E^{\prime }$ represents the vertex and edge sets of T respectively. Function $f_1\left(X\right)$ calculates the number of vertices not dominated by T. Function $f_2\left(E^{\prime }\right)$ calculates the weights of the minimum spanning tree of T. And $\alpha$ is a constant parameter to balance the importance between $f_1$ and $f_2$. T is a feasible solution to the minimum dominating tree problem if and only if $f_1\left(X\right)=0$.

The algorithm primarily comprises several key steps. Firstly, an initial solution is generated, followed by a neighborhood evaluation. Subsequently, the best neighborhood move is selected and executed iteratively. During the iteration, the ever best configuration is recorded. The framework of the algorithm can be represented in pseudo-code as follows:

In Algorithm 1, $T_i$ represents the initial configuration, $T_b$ represents the recorded ever best solution, and $T_c$ represents the current configuration. In each iteration, the sub-procedure Do_NeighborEvaluate evaluates all the neighborhood moves in the current configuration. The following two sub-procedure select and execute the best move. The termination condition can be the time or iteration limits.

2.2. Initial Solution Generation

The proposed DNS algorithm uses a feasible dominating tree as the initial configuration. The sub-procedure Generate_InitialSolution generates this initial dominating tree. It first find the minimum spanning tree for the whole graph, and try to trim the tree by removing leaves iteratively until removing one more leave will break the dominancy of the tree. The pseudo-code of this procedure is defined in Algorithm 2.

The procedure starts from the minimum spanning tree $T_i$ generated by Kruskal’s algorithm. Then it tries to delete the leaf with the largest edge weight. The process terminates if no more leaf can be deleted. The algorithm returns a feasible dominating tree as the initial configuration. In the following sections, we focus on the meta-heuristic part of the proposed DNS algorithm, i.e., the neighborhood structure as well as its evaluation.

2.3. Definition

For better description, we first define some important concepts and notations used in the proposed DNS algorithm.

• X : the set of vertices in the current dominator tree.
• $X_{plus}$ : the set of vertices dominated by X and not in X.
• $A_1$ : An array of the number of un-dominated vertices, the length of the array is the number of graph vertices.

  $$A_1\left[i\right]=\left|\{j\in V\setminus (X\cup X_{plus}):(i,j)\in E,\forall k\in (X\cup X_{plus}),(k,j)\notin E\}\right|$$

  (2)
  $A_1\left[i\right]$ denotes the number of vertices not dominated by the new X if move i from X to $X_{plus}$ (or from $X_{plus}$ to X).
• $A_2$ : array of minimum spanning tree weights for X. The length of the array is the number of graph vertices.

  $$A_2\left[i\right]=\left\{\begin{array}{cc}w\left(MST\right(G[X\setminus \{i\left\}\right]\left)\right)\hfill & \mathrm{if}i\in X\hfill \\ w\left(MST\right(G[X\cup \{i\left\}\right]\left)\right)\hfill & \mathrm{if}i\in X_{plus}\hfill \end{array}\right.$$

  (3)
  $A_2\left[i\right]$ denotes the weight of the new minimum spanning tree of X if move i from X to $X_{plus}$ (or from $X_{plus}$ to X).

The following example illustrates how $A_1$ and $A_2$ are calculated.

As shown in the Figure 1, the current dominating tree is $T_{<B,D>}$ containing two vertices, B and D. Therefore, $X=B,D$. The vertices dominated by X are A, C, and E. Thus, $X_{plus}=A,C,E$. We correspond the vertices A, B, C, D, and E to the array subscripts 0, 1, 2, 3, and 4, respectively. To evaluate the neighborhood moves, the algorithm takes vertex A out and puts it in the set of the other side. The number of vertices that are not dominated by the new X after this move is 0, thus $A_1\left[0\right]$ is assigned to 0. The weight of the new minimum spanning tree of X is 13, thus $A_2\left[0\right]$ is assigned to 13. After evaluating all the neighborhood moves, the resulting arrays are $A_1=[0,1,0,1,0]$ and $A_2=[13,0,17,0,3]$. $A_1$ and $A_2$ are used to evaluate the neighborhood moves.

2.4. Neighborhood move and Evaluation

There are two kinds of neighborhood moves in DNS algorithm, one is to take out one vertex in X and put it into $X_{plus}$ , and the other one is to take out one vertex in $X_{plus}$ and put it into X. In each iteration, the best neighborhood move is selected and performed among all the two kinds of neighborhood moves. There are two criteria to evaluate the quality of the moves, one is the dominance and the other is the weight of the dominating tree. The pseudo-code for neighborhood evaluation is described in Algorithm 3.

The evaluation is done by trying to move each vertex to the other set, then calculate the $A_1$ and $A_2$ values. Based on these two arrays, the best move is selected as described in Algorithm 4.

Procedure Select_BestMove picks the move with the smallest $A_1$ and $A_2$, higher priority for $A_1$. Then, the best move selected is performed by Algorithm 5.

Procedure Execute_BestMove moves the selected vertex to $X_{plus}$ if it is in X, and vice versa. After the move, the minimum spanning tree of $G\left(X\right)$ is calculated using Kruskal’s algorithm and assigned to $T_c$ . The following example illustrates how the best move is evaluated and performed.

As shown in Figure 2, the current domination tree is $T_{<B,D>}$, $X=\{B,D\}$, $X_{plus}=\{A,C,E\}$. To evaluate vertex A, we first move it from $X_{plus}$ to X, then X becomes $\{A,B,D\}$. The number of vertices that are not dominated by the new X at this point is 0, thus $A_1\left[A\right]=0$. The minimum spanning tree weight of $X=\{A,B,D\}$ is 13, thus $A_2\left[A\right]=13$. We then move A back to its original set. The evaluation for A is done. The B, C, D, and E are evaluated sequentially by the same process. After the evaluation for each vertex, $A_1=[0,1,0,1,0]$ and $A_2=[13,0,17,0,3]$.

Then we pick the best neighborhood move, finding the minimum value from $A_1$ and $A_2$, prior to $A_1$. There are 3 minimum values in $A_1$, corresponding to A, C, and E. Then we compare the value of these three vertices in $A_2$, the minimum value is 3, corresponding to vertex E. Therefore, the best vertex is E, and the best neighboring move is to move E. After the move, the new $X=\{B,D,E\}$. We calculate the minimum spanning tree of the new X. The new minimum spanning tree is $T_{<B,D,E>}$ with a weight of 3.

2.5. Fast Neighborhood Evaluation

In order to improve the efficiency of the algorithm, this paper proposes a method to dynamically update the neighborhood evaluation matrices $A_1$, $A_2$.

2.5.1. Fast evaluation for $A_1$

The number of un-dominated vertices may increase or remain unchanged when vertices are removed from X to $X_{plus}$. The newly added un-dominated vertices must be originally in the $X_{plus}$ set and connected to the moved vertex. Since the number of un-dominated vertices is zero throughout the algorithm, we can count the newly introduced un-dominated vertices by counting the vertices in $X_{plus}$, which the moved vertex is its only connection to X.

When we move vertices from $X_{plus}$ to X, the number of un-dominated vertices may decrease or remain the same. Because X is dominated throughout the algorithm, the number of un-dominated vertices after this kind of moves is still 0. The above observation can be utilized to dynamically compute $A_1$ without having to traverse the entire graph. The formula is as follows:

$$A_1\left[i\right]=\left\{\begin{array}{cc}\left|\right\{j\in X_{plus}:(i,j)\in E\left\}\right|\hfill & \mathrm{if}i\in X\hfill \\ 0\hfill & \mathrm{if}i\in X_{plus}\hfill \end{array}\right.$$

(4)

2.5.2. Fast evaluation for $A_2$

For $A_2$, we use a dynamic Kruskal’s algorithm. The algorithm dynamically maintains a set $Roads$, which is the set of edges contained in the subgraph $G\left(X\right)$, i.e., the set of edges whose two vertices are in X. The $Roads$ set is sorted from smallest to largest by the weights of the edges. When a X to $X_{plus}$ move is performed, the edges connecting to the moved vertex and X are deleted from the $Roads$ set. Similarly, when a $X_{plus}$ to X move is performed, the edges connecting to the moved vertex and X are inserted to the $Roads$ set. Note that, edges should be inserted into the appropriate position in $Roads$ to guarantee that it is sorted. The dynamic Kruskal’s algorithm then assumes that the edges before the deletion or insertion position are sure to be in the new minimum spanning tree, then start the normal procedure from that position. The pseudo-code for dynamic Kruskal’s algorithm is described in Algorithm 6 and 7.

In Algorithm 6, The notate $E(a,b)$ represents the edge connecting vertices a and b, $T_c$ is the original minimum spanning tree, i.e., the entire algorithm of the current solution. The main job for this procedure is to update the $Roads$ set. And the Algorithm 7 calculates the spanning tree dynamically according to $Roads$.

The following example illustrates the above procedures:

As shown in Figure 3, the original tree is $T_{<A,B,D,F>}$, currently, $X=\{A,B,D,F\}$, $X_{plus}=\{C,E,G\}$, $Roads=\{<D,F>,<A,B>,<B,D>\}$, and the weights of the edges $w\left(Roads\right)=\{1,4,8\}$. Let’s evaluate the move of vertex E from $X_{plus}$ to X. After the move $X=\{A,B,D,E,F\}$, $X_{plus}=\{C,G\}$. Since E was originally in $X_{plus}$, $A_1\left[E\right]=0$. The new edge added after the move is the edge $\{<B,E>,<E,F>\}$ with weights $\{2,5\}$. Then we insert these two edges into the appropriate position in $Roads$ according to their weights from smallest to largest in $w\left(Roads\right)=\{1,2,4,5,8\}$, and the corresponding $Roads=\{<D,F>,<B,E>,<A,B>,<E,F>,<B,D>\}$. We only need to start from position of $<B,E>$ to determine the new minimum spanning tree. The edges before $<B,E>$ must be in the new minimum spanning tree. The evaluated minimum spanning tree is $T_{<A,B,D,E,F>}=\{<D,F>,<B,E>,<A,B>,<E,F>\}$ with weight 12, thus $A_2\left[E\right]=12$.

2.6. Tabu strategy and aspiration mechanism

The proposed DNS algorithm implements tabu strategy. The vertex is prohibited to be moved again within a tenure once it is moved. The tabu strategy is implemented to both kinds of moves in the algorithm. Since there is no intersection of X and $X_{plus}$, only one taboo table is needed. We denote the tabu tenure of the move from $X_{plus}$ to X as $TabuLengt{h}_1$ and the move from X to $X_{plus}$ as $TabuLengt{h}_2$. These two tabu tenures are set to the number of vertices in X and $X_{plus}$, respectively, thus implementing dynamic tabu tenures in this way. This tabu strategy improves the accuracy and efficiency makes the algorithm to jump out of the local optimum more easily.

In order to avoid missing some good solutions, an aspiration strategy is introduced. If one tabu move may improve the ever best solution, the searching process breaks its tabu status and selects it as a candidate best move.

Note that we do not describe the details of how the tabu and aspiration is implemented in the previous pseudo-codes to give a clearer layout for better understanding. For more details of tabu we recommend readers to the literature [32].

2.7. Perturbation Strategy

In order to further improve the quality of the solution, the proposed DNS algorithm implements a perturbation strategy. The specific perturbation is to move some vertices from $X_{plus}$ to X randomly. The algorithm set a parameter as the perturbation period. When the number of iterations reaches the perturbation period a perturbation will be triggered, and the number of iterations will be cleared to zero if the ever best solution is updated within this period. There are another two parameters, the perturbation amplitude and the perturbation tabu tenure. The perturbation amplitude is the number of vertices taken out from $X_{plus}$ in the perturbation. The perturbation tabu tenure is the tabu tenure used during the perturbation period. In addition, after a certain number of small perturbations, a larger perturbation needs to be triggered to give a larger spatial span to the search process. The larger perturbation is implemented by moving one-third of the vertices from $X_{plus}$ to X randomly.

3. Algorithm Experimentation

3.1. Datasets and Experimental Protocols

The experiments are carried out on the following two data sets:

• The DTP dataset is a dataset proposed by Dražic et al. [15], with the number of vertices ranging from 150 to 1000.
• The Range dataset is a dataset proposed by Sundar and Singh [13], with the number of vertices ranging from 50 to 500 and a transmission range of 100 to 150 meters.

Both datasets are randomly generated and can be downloaded online or obtained from the authors. The DNS algorithm is implemented in Java (JDK17) and tested on a desktop computer equipped with an Intel® Xeon® W-2235 CPU @3.80GHz, with 16.0GB of RAM.

3.2. Calibration

This section we conduct experiments to fix the value of key parameters of DNS algorithm:

• Parameter $DisturbPeriod$, the first perturbation period. Values from 14 to 17 are tested.
• Parameter $DisturbLevel$, the perturbation amplitude. Values from 7 to 12 are tested.
• Parameter $DisturbT{L}_1$, The tabu length of the neighborhood move of taking a vertex from $X_{plus}$ and putting it into X during perturbation. Values from 1 to 2 are tested.
• Parameter $DisturbT{L}_2$, The tabu length of the neighborhood move of taking a vertex from X and putting it into $X_{plus}$ during perturbation. Values from 3 to 8 are tested.

We select 13 representative instances to tackle the calibration experiments. Representatives are instances 200-400-1, 200-600-1, 300-600-1 and 300-1000-1 In DTP; instances 300-1, 400-1 and 500-1 respectively in Range100, Range125 and Range150. The experiment is done as following steps: First, roughly experiment with parameter combinations to select better parameter combinations. Then for each set of parameters, run these 13 instances in sequence. Each instance is run five times with different random seeds for 300 seconds each time. We compare the gap rates for each parameter setting. The gap is calculated as:

$$gap=\frac{n1-n2}{n2}$$

(5)

, where $n_1$ is the average result obtained and $n_2$ is the known best objective. Table 1 shows the result for the calibration experiment.

According to the experimental data, the minimum total $gap$ rate is 0.075, corresponding to $DisturbPeriod$ of 15, $DisturbLevel$ of 8, $DisturbT{L}_1$ of 1, and $DisturbT{L}_2$ of 4. In the following experiment, we set the parameters of the algorithm to this setting. Note that this experiment does not guarantee the optimal values of the parameters and the optimal scheme may vary from one benchmark to another. It can also be seen that for different parameter combinations, the $gap$ rate is small, indicating the robustness of the algorithm.

3.3. Comparison on DTP Data Set

In this section, we compare the proposed DNS algorithm with other methods in the literature on DTP data set. There are two DTP datasets: dtp_large and dtp_small. Since all algorithms can obtain the best results for dtp_small with little difference in speed, only the experimental results for dtp_large are shown here. The compared algorithms are TLMH, VNS, and GAITLS algorithms. For each instance, 10 runs with different random seeds are made, each lasting 1000 seconds. The best, average objective values, and average time are recorded for each instance. The experimental results and comparisons are shown in Table 2. Bolded numbers represent that the current best value has been obtained and the results are not worse than other algorithms. The start marks represent that DNS algorithm updates the best objective in the literature.

From Table 2, it can be seen that this algorithm runs most instances to the best value, and those that do not reach the optimal value are also very close to it. The overall best values are slightly worse than the TLMH algorithm but better than the VNS and GAITLS algorithms. The overall average of this algorithm outperforms other algorithms, demonstrating its stability and faster speed. It also improves the best solution for two instances.

3.4. Range Dataset Experiments

In this section, the widely used Range dataset with 54 instances is tested and compared with the TLMH, ACO-DT, EA/G-MP, and ABC-DTP algorithms. The experimental results of these algorithms compared in this paper are the best results obtained using the best parameters in the original literature. In this section, this algorithm is run 10 times for each dataset with the previously measured best parameters and different random seeds. Each run lasts 1000 seconds and the best, average objective values, and average time are calculated. The results and comparisons are shown in Table 3, Table 4 and Table 5:

==layoutwidth=297mm,layoutheight=210 mm, left=2.7cm,right=2.7cm,top=1.8cm,bottom=1.5cm, includehead,includefoot [LO,RE]0cm [RO,LE]0cm

==This algorithm obtains best solutions for most instances in the Range dataset, and those that are not optimal are close to the optimal solution. It updates the best solution for two instances and outperforms the TLMH algorithm in speed.

4. Analysis and Discussion

4.1. The Importance of the Initial Solution

A procedure for generating the initial solution was proposed in the previous chapter. To see the effect of this procedure, experiments were conducted on it in this section, where 18 instances of Range150 were tested. The objective value obtained by this procedure were compared with both the minimum spanning tree weights and the known best objective value to see how much this procedure improves on the initial solution and how close this initial solution is to the minimum domination tree. The experimental results are shown in Table 6.

In Table 6, $T_m$ represents the minimum spanning tree, $T_i$ represents the objective value obtained from the initialization procedure, $T_b$ represents the known best objective value. From the results, it can be seen that using the initialization procedure to obtain a domination tree as the initial solution improves significantly over using the minimum spanning tree as the initial solution. The weight of this initial domination tree is relatively close to that of the minimum domination tree, allowing the algorithm to converge quickly to a near-optimal solution at the very beginning. To verify this improvement, this paper also uses the minimum spanning tree of graph $G(V,E)$ as an initial solution and conducts experiments on Range150 for comparison. This method is denoted as DNS-ms. The experimental results are in Table 7.

The experimental results show that DNS outperforms the DNS-ms algorithm in terms of best, average objective values, and speed, indicating that the initial solution proposed in this paper improves the efficiency of the algorithm. It can also be seen that there is not much difference between the best and average values obtained by DNS and DNS-ms, demonstrating the robustness of the local search procedure of DNS algorithm.

4.2. The Importance of the Fast Neighborhood Evaluation

The proposed DNS algorithm uses a fast neighborhood evaluation technique. To verify its effectiveness, an experiment was conducted to test the time taken to reach the same result for 18 instances of Range150 with and without fast neighborhood evaluation. In this experiment, the perturbation is disabled while only tabu mechanism is enabled. The best objective value that can be reached at complete convergence is tested in advance for each instance and used as the target result. The random seed is fixed for each instance because the difference in speed is only due to using fast neighborhood evaluation. The program runs until it reaches the target result, and the time taken by each instance to reach the target result under these two methods is recorded separately. The results are shown in Table 8, where Method 1 represents the version without fast neighborhood evaluation and Method 2 represents the version with fast neighborhood evaluation:

From Table 8, it can be seen that the version using fast neighborhood evaluation significantly improves speed compared to the version without it, verifying the effectiveness of fast neighborhood evaluation. To observe the convergence of these two methods, scatter plots are generated by outputting the weights and corresponding times after each update. The convergence curves of some instances are shown in Figure 4, where NDNU represents the method without fast neighborhood evaluation and DNU represents the method with the fast neighborhood evaluation.

From Figure 4, it can be seen that the version using fast neighborhood evaluation converges to the target value more quickly. For the version without the fast neighborhood evaluation, the curve is slower and takes longer to converge to the same objective value.

4.3. Importance of the Perturbation

The proposed DNS algorithm also implements a perturbation strategy. In this section the effectiveness of this strategy is verified through experiments by testing the version with and without this strategy, for 18 instances in Range150. Each instance is run 5 times with different random seeds, with a time limit of 1000 seconds, and the results of the experiments are shown in Table 9:

From Table 9, it can be seen that better solutions can be obtained by the version using the perturbation strategy, especially in some larger instances, verifying the effectiveness of this strategy.

5. Conclusion

In this paper, a dual-neighborhood search algorithm is proposed to solve the minimum dominating tree problem. In order to improve the efficiency of the algorithm, a fast neighborhood evaluation method is proposed, in which the method of dynamically generating the minimum spanning tree from the sub-graph deduced from the dominating set. The tabu and the perturbation mechanisms help the algorithm jump out of the local optimum trap, thus obtaining better solutions. The DNS algorithm is demonstrated to be highly effective in tests on a collection of widely used benchmark instances where it is compared with the algorithms in the literature. Out of 72 public instances, DNS improves the best result on 4 problems while being competitive on the remaining ones with less computational time. Although the techniques proposed in this paper are specific to the minimum dominating tree problem, most of these ideas can be applied to other combinatorial optimization problems. For example, the dynamic spanning tree calculation used in the fast neighborhood evaluation can be used in problems with spanning tree structures. And the collaboration of two neighborhood structures can be also introduced to other relevant optimization problems. Finally, it is interesting to test the proposed ideas in other meta-heuristic frameworks with other optimization problems.