Multi-Start Local Search Algorithm for the Minimum Connected Dominating Set Problems

Abstract

The minimum connected dominating set (MCDS) problem is a very significant NP-hard combinatorial optimization problem, and it has been used in many fields such as wireless sensor networks and ad hoc networks. In this paper, we propose a novel multi-start local search algorithm (MSLS) to tackle the minimum connected dominating set problem. Firstly, we present the fitness mechanism to design the vertex score mechanism so that our algorithm can jump out of the local optimum. Secondly, we use the configuration checking (CC) mechanism to avoid the cycling problem. Then, we propose the vertex flipping mechanism to change the vertex state by combing the CC mechanism with the vertex score mechanism. Finally, we propose a multi-start local search framework based on these mechanisms. We compare the algorithm MSLS with other compared algorithms on extensive instances. The results of experiment show that MSLS is superior to other algorithms in solution quality and time efficiency on most instances.

1. Introduction

Given an undirected connected graph G = (Vt, Eg), the minimum dominating set problem is to seek a minimum vertex subset S such that each vertex in Vt\S is adjacent to at least one vertex in S, where vertices a, b are adjacent if there exists an edge (a, b)$\in$Eg. In a real network, there are some important issues that can be modeled through dominating sets. Especially in operations research, the location of key or auxiliary stations in a traffic network can be described by a framework based on a dominant set. Other applications come from areas such as sensor networks [1], medicine of cancer therapy [2,3] viral marketing in web based social networks [4], sociology [5], and biology [2,6].

The connected dominating set (CDS) problem is a classical dominating set problem with constraints. That is, a dominating set S is a connected dominating set if the subgraph G(S) = (S, Eg(S)) is connected, where Eg(S) = {(a, b)$\in$Eg |a∈S, b$\in$S}. The minimum connected dominating set (MCDS) problem is to seek a connected dominating set S with minimum cardinality. The MCDS problem plays a significant role in many real-world applications such as network testing [7], wireless sensor networks [8], and wireless ad hoc networks [9,10].

It is proved that the minimum connected dominating set problem is NP-hard [11]. Many researchers have devoted themselves to different algorithms to get the optimal solution or near-optimal solution of the problem. In recent years, some researchers have proposed a number of approximate algorithms to tackle the minimum connected dominating set problem. The literature [12] is a good survey for this problem in ad hoc networks. Marathe et al. proposed efficient approximations for the problem on unit disk graphs, the size of the solution by proposed algorithm is at most 8|S*| + 1, and the time complexity is O(n²) steps [13]. In [14], Bharghavan et al. proposed a distributed approximation algorithm. Its approximation ratio is O(H(Δ)), and both its message complexity and time complexity are O(n²), where Δ is the maximum degree and H() is the harmonic function. Wu et al. proposed a different distributed approximation algorithm in unit disk graphs [15]. Its approximation ratio is O(n), and its message complexity and time complexity are Θ(m) and O(n³), respectively. In [16], the approximation ratio is 8, and message complexity and time complexity of the both algorithms are O(n) and O(nΔ), respectively. In [17], the approximation ratio is 8, and message complexity and time complexity are O(nlogn) and O(n), respectively. In [18], Wu et al. proposed a distributed approximation with approximation ratio O(1) in unit disk graphs. In [19], the approximation ratio is O(1), and both its message complexity and time complexity are O(n). Simonetti et al. presented new valid inequalities, an integer programming formulation, and a branch-and-cut algorithm [20]. Gendron et al. proposed the branch-and-cut, benders decomposition, and memetic approaches for the problem [21]. However, the solution obtained by the approximate algorithm is usually much worse than the optimal solution. Recently, researchers are committed to heuristic development for the MCDS problem in order to produce a good or near optimal solution in a reasonable time. They are mainly one-step based algorithm [8] or two-step based algorithms [7,22,23], or greedy heuristic based algorithms [24,25]. Misra et al. proposed a multi-step collaborative cover heuristic approach in literature [9]. The MCDS problem was also solved by neural networks method [26], simulated annealing with tabu search [27], and the ACO algorithm [28,29]. Li et al. proposed the algorithm GRASP, which incorporates an efficient local search algorithm based on two key components (the tabu strategy and the greedy function) [30]. Wang et al. presented a variable-depth neighborhood search (VDNS) algorithm for solving the MCDS problem [31]. Salim et al. presented an ant colony optimization algorithm based on a reduced variable neighborhood search [32]. However, fewer heuristic algorithms are designed for solving the problem. Thus, in our paper, we propose a multi-start local search with a vertex score mechanism and configuration checking mechanism for solving the MCDS problem.

First, a vertex fitness based vertex score mechanism is proposed to enable the search to jump out of local optimum to a new area to continue the search. In the vertex score mechanism, each vertex’s score value is dynamically updated according to the vertex fitness mechanism. Second, we use a configuration checking mechanism to reduce the cycling problem in the local search phase. The configuration checking (CC) mechanism was proposed for solving a minimum vertex cover problem in the literature [33]. The CC mechanism considers the environmental information of the vertex to change its state rather than the direct properties of the vertex. The CC mechanism has been applied in local search algorithms for combinatorial optimization problems such as minimum weighted vertex cover [34,35] and set covering [36], as well as constraint satisfaction problems such as satisfiability [37,38,39], maximum satisfiability [40], and a minimum weighted clique problem [41]. However, as far as we know, the configuration checking mechanism has not been applied to MCDS problem.

In order to improve the robustness and efficiency of the algorithm, the multiple-start mechanism is adopted. By incorporating the mechanisms described above, an efficient algorithm MSLS is presented to tackle the MCDS problem. In order to verify the effectiveness of MSLS, we compare it with five other algorithms, called Greedy [42], ACO [28], ACO+PCS [28], GRASP [30], and VDNS [31]. The results of the experiment describe the fact that the presented algorithm performs better than other algorithms in solution quality and time efficiency, and we obtain new upper bounds on some instances.

The rest of this paper is structured as follows. The related definitions and concepts are introduced in Section 2. The vertex fitness mechanism and the vertex score mechanism are described in Section 3. Section 4 introduces how to apply the CC mechanism to the minimum connected dominating set problem. Section 5 designs a new vertex flipping mechanism to guide the direction of local search. Section 6 shows the presented multi-start local search algorithm, called MSLS. Section 7 shows and analyzes the results of the experiment. Finally, Section 8 summarizes the whole paper and briefly discusses the future direction of work.

2. Preliminaries

Given an undirected connected graph G = (Vt, Eg), where Vt = {v₁, v₂,$\cdots$, v_n} is the vertex set and Eg = {e₁, e₂,$\cdots$, e_m} is the edge set. The network is modeled as an undirected connected graph, where the vertices represent the nodes and the edges represent the communication links. We use N(a) = {b$\in$Vt| (a, b)$\in$Eg} to denote the set of neighbors of a vertex a, and use d(a) = |N(a)| to denote the degree of a. We denote N[a] = N(a)$\cup${a}. Given a candidate solution S, we use x_j$\in${0, 1} to denote the state of a vertex a_j, where x_j = 1 means a_j$\in$S, and x_j = 0 means a_j$\notin$S. We say a vertex a$\in$Vt dominates b$\in$Vt if a = b or (a, b)$\in$Eg. In addition, we call the vertices belonging to S as dominating vertices, whereas we call the remaining vertices as dominated vertices. We define several different versions of dominating set problems as follows.

Definition 1 (dominating set (DS)).

In an undirected graph G = (Vt, Eg), the dominating set problem is to find a vertex subset S$\subseteq$Vt, such that every vertex in Vt\S has at least one neighbor in S.

Definition 2 (minimum dominating set (MDS)).

In an undirected graph G = (Vt, Eg), the minimum dominating set problem is to find a dominating set S with the minimum cardinality.

Definition 3 (connected dominating set (CDS)).

In an undirected connected graph G = (Vt, Eg), the connected dominating set problem is to seek a dominating set S, such that the subgraph G(S) = (S, Eg(S)) is connected, where Eg(S) = {(a, b)$\in$Eg |a$\in$S, b$\in$S}.

Definition 4 (minimum connected dominating set (MCDS)).

In an undirected connected graph G = (Vt, Eg), the minimum connected dominating set problem is to seek a connected dominating set S with minimum cardinality. The linear programmin g model can be stated as follows:

$$\mathrm{Minimize}{{\displaystyle \sum }}_{a_i\in Vt}{x}_i,$$

(1)

$$\mathrm{Subject}\mathrm{to}:{{\displaystyle \sum }}_{a_j\in N\left[a_i\right]}{y}_{ji}\ge 1,\forall a_i\in Vt,$$

(2)

connected(x)

(3)

$$y_{ij}\le x_i,\forall a_i,a_j\in Vt,$$

(4)

$$x_i,y_{ij}\in \left\{0, 1\right\},\forall a_i,a_j\in Vt,$$

(5)

where x_i is an indicator variable that is equal to 1 if vertex a_i is included in the candidate solution and otherwise x_i is equal to 0; y_ij is an indicator variable that is equal to 1 if vertex a_i dominates vertex a_j and otherwise y_ij is equal to 0. Equation (2) ensures that each vertex a_i$\in$Vt\S is dominated by at least one vertex in S and Equation (3) imposes the connectivity of the subgraph induced by S, by enforcing articulation points [21]. Equations (4) and (5) are the integer constraints.

3. Vertex Fitness Based Vertex Score Mechanism

In the local search procedure for solving the MCDS problem, the vertex score mechanism plays a key role in selecting which vertices to flip, which will allow the search to be conducted in a more efficient direction. In this paper, the vertex score mechanism mainly depends on the fitness value of the vertex. We shall describe the vertex fitness as follows.

3.1. Vertex Fitness Mechanism

The vertex fitness mechanism plays an important role in vertex score mechanism. Specifically, in the vertex fitness mechanism, each vertex is associated with an integer number, which is known as fitness. In the local search process, each undominated vertex’s fitness in Vt\S will be increased by one. The updating of fitness value will affect the scores of the related vertices, so that the algorithm can effectively jump out of the local optimal optimum. It is worth noting that the vertex fitness mechanism in our algorithm MSLS is a very generalized strategy, similar to a vertex weighting strategy, which has been successfully applied to solve MVC [33], MWVC [35], and MKDS [42]. To illustrate the problem, we first give the definition of vertex fitness.

Definition 5 (vertex fitness).

In an undirected graph G = (Vt, Eg), each vertex a$\in$Vt is assigned a positive integer number fitness(a), which is dynamically updated in the local search procedure.

In our implementation, we update the fitness values of the vertices according to the following two rules.

Rule 1.

During initialization, the fitness value (fitness(a)) of each vertex a$\in$Vt is assigned to 1.

Rule 2.

During the local search process, we will check if each vertex a$\in$Vt is dominated at the end of the iteration, and add the fitness value of the undominated vertex by 1.

3.2. Vertex Score Mechanism

Based on the vertex fitness mechanism introduced in the Section 3.1, we propose a vertex scoring mechanism to measure the benefits of flipping the vertex state. The score of vertex a is denoted by v_score(a) as follows:

v_score(a) = solution_score(S) − solution_score(S’),

(6)

where S denotes the current candidate solution, S’ = S\{a} if a$\in$S, and S’ = S∪{a} otherwise, and solution_score(S) denotes the total fitness of vertices undominated by S. solution_score(S) is used to measure the quality of candidate solution S, and the smaller the value solution_score(S), the better the quality of the solution S. When the value solution_score(S) is 0, the candidate solution S is feasible. solution_score(S) is defined as follows:

$$solution\_score\left(S\right)={{\displaystyle \sum }}_{a\in Vt\backslash S:N\left(a\right)\cap S=\varnothing }fitness\left(a\right).$$

(7)

4. Configuration Checking Mechanism

The cycling problem is an inherent problem in local search, and the effective mechanism of avoiding cycling problem can improve the performance and efficiency of the search algorithm. The configuration checking mechanism is designed to avoid the cycling problem, which is originally introduced in [33] for solving minimum vertex cover problem. We first introduce the basic idea of configuration checking mechanism. For vertex a, its configuration denotes the states of its all neighbor vertices. If a’s configuration is not changed since it was deleted from the candidate solution, then it is inhibitory added back into the candidate solution. The configuration checking mechanism is generally implemented with a Boolean vector called config, if config(a) equals 1, then the vertex a is permitted to be added into the candidate solution; otherwise, vertex a is not allowed to be added into the candidate solution.

The configuration checking mechanism for MVC can be modified for the MCDS problem straightforwardly. In the beginning, the value of config(a) is initialized as 1 for each vertex in Vt. Afterwards, if a vertex a is removed from S, then the value of config(a) is assigned to 0 and for each vertex b$\in$N(a), config(b) is assigned to 1. Similarly, if a vertex a is added into S, for each vertex b$\in$N(a), config(b) is assigned to 1.

5. Vertex Flipping Mechanism

The process of local search for solving the connected dominating set is to flip the state of a vertex in each iteration in order to obtain a new candidate solution and judge whether the candidate solution is better than the current optimal solution. It is important to flip the state of which vertex in each iteration. Using the vertex fitness based vertex score mechanism introduced in Section 3 and the CC mechanism introduced in Section 4, we propose the vertex flipping mechanism. First, we shall describe the definition of solution connected elements.

Definition 6 (solution connected elements (SCE)).

Solution connected elements are vertices with the most times appearing in the neighbors of each connected component of the candidate solution S [30].

One of the difficulties in solving the connected dominating set problem is how to guarantee the connectivity of the solution. Just like reference [30], we also use SCE to guarantee the connectivity of the solution. According to the definition of SCE, if the number of the connected components is equal to the time that vertex a appearing in each connected component neighbors and vertex a is flipped, then the candidate solution will change from not connected to connected. If they are not equal, then the algorithm will flip the vertex with the most times appearing in each connected component neighbors, so that the candidate solution can more easily connect in the future local search step.

Based on previous consideration, Algorithm 1 describes which vertex’s state is flipped to add it into the candidate solution. In Algorithm 1, from the vertices in SCE with config value of 1, the procedure prefers to flip the vertices with the maximum v_score value (lines 3–6). If there are multiple vertices, Algorithm 1 will flip the vertex with the old age (lines 7–8). At the end of the procedure, the state of the flipped vertex will change from 0 to 1 (line 11), the configs and v_scores of related vertices and SCE set will be updated accordingly (lines 12–16).

Algorithm 1 Vertex_flipping_add()

1: Initial max_score = −$\infty$, add_v = −1;

2: for each vertex a in SCE

3:   if config(a)==0 continue;

4:   if v_score(a) > max_score

5:      max_score = v_score(a);

6:      add_v = a;

7:   elseif v_score(a)==max_score && age(a) > age(add_v)

8:      add_v = a;

9:   endif

10: endfor

11: S←S$\cup${add_v};

12: for each vertex b in N(add_v)

13:   config(b) = 1;

14: endfor

15: update v_scores of related vertices;

16: update SCE;

Similarly, Algorithm 2 describes which vertex’s state is flipped to remove it from the candidate solution. In Algorithm 2, from the candidate solution, we prefer to flip the vertices with the maximum v_score value (lines 3–5). If there are multiple vertices, Algorithm 2 will flip the vertex with the old age (lines 6–7). At the end of the procedure, the state of the flipped vertex remove_v will change from 1 to 0 (line 10), and the configs and v_scores of related vertices and SCE set will be updated accordingly (lines 11–16).

Algorithm 2 Vertex_flipping_remove()

1: initial max_score = −$\infty$, remove_v = −1;

2: for each vertex a in the candidate solution

3:   if v_score(a) > max_score

4:      max_score = v_score(a);

5:      remove_v = a;

6:   elseif v_score(a)==max_score && age(a) > age(remove_v)

7:      remove_v = a;

8:   endif

9: endfor

10: S←S\{remove_v};

11: config(remove_v) = 0;

12: for each vertex b in N(remove_v)

13:   config(b) = 1;

14: endfor

15: update v_scores of related vertices;

16: update SCE;

6. Framework of MSLS

In this section, we will discuss the main framework of our algorithm MSLS and its parts. Before we introduce the framework of MSLS, we first introduce the construction of the initial solution.

6.1. Initial Solution Construction

Algorithm 3 describes how to construct an initial solution in each restart of our MSLS algorithm. At the beginning of the procedure, each vertex’s v_score in Vt is initialized to the vertex’s degree. Afterwards, the candidate solution S is initialized NULL, and SN (solutions neighbors) is used to store the neighbors of the vertices in the candidate solution S, flipping such a vertex does not break the candidate solution’s connectivity. If the candidate solution S is empty, each vertex in Vt can be flipped into S, so SN is initialized to Vt; otherwise, SN contains the neighbors of the vertices in the candidate solution S, that is, SN ← ${\cup }_{a\in S}N\left(a\right)\cup Vt\backslash S$. In the main loop of the initial solution construction procedure, the v_score of each vertex in Vt is first calculated according to Formula (6). Then, a vertex is flipped to be added into the candidate solution greedily (breaking ties randomly) from SN to construct the initial solution. The cycle will continue until the candidate solution becomes a feasible solution.

Algorithm 3 Initial_solution()

1: Initialize v_score(a) = d(a), a$\in$Vt;

2: S← $\varnothing$;

3: SN←Vt;

4: While S is not CDS do

5:   b← such a vertex with greatest v_score in SN, breaking ties randomly;

6:   S← S$\cup${b};

7:   SN← ${\cup }_{a\in S}N\left(a\right)\cup Vt\backslash S$;

8: endwhile

9: return S;

6.2. Algorithm MSLS

Our algorithm MSLS (Algorithm 4) is based on a multi-restart framework. In the multi-restart framework, the algorithm repeatedly performs the initial solution construction stage (line 3) and the local search stage (lines 4–14). Local search starts with the initial candidate solution to find a higher quality solution. Specifically, the initial candidate solution is constructed by the greedy method (line 3), on which we use the local search method to seek the local optimal optimum (lines 6–12). Once a connected dominating set S is obtained, the algorithm flips a vertex in the candidate solution to remove it from S (line 8) until there are some undominated vertices. Then, the algorithm exchanges two vertices iteratively until S becomes a feasible solution (lines 11 and 12). Repeat this process until the best solution has not been improved within specific threshold MAX_no_improve (lines 5–14). Finally, we restart the previous process for a given time in order to search in different promising areas. With the techniques above, MSLS is described as follows in Algorithm 1. Note that S denotes the local optimum found by local search, S^* records the best solution obtained so far, and N_start indicates the maximum restarting times. In our experiments, N_start is set to be 100, and MAX_no_improve is set to be 10,000.

Algorithm 4 Pseudo-code of MSLS

Input: An undirected connected graph G = (Vt, Eg), Nstart, MAX_no_improve

Output: The best solution S*

1: iter←0; S*←$\varnothing$;

2: while iter < Nstart do

3:   S←Initial_solution();           /*see Section 6.1*/

4:   no_improve←0;

5:    while no_improve < MAX_no_improve do

6:     if S is better than S*;

7:      S*←S;

8:      vertex_flipping_remove(); /*see Section 5*/

9:      no_improve←0;

10:      endif

11:     vertex_flipping_remove();      /*see Section 5*/

12:     vertex_flipping_add();        /*see Section 5*/

13:     no_improve←no_improve+1;

14:    endwhile

15:   iter←iter+1;

16: endwhile

17: return S*;

7. Computational Experiments

In this section, we will test the performance of our algorithm MSLS. We compare our algorithm MSLS with the current best algorithms on a large number of benchmark instances. In addition, we analyzed the effectiveness of each proposed mechanism.

7.1. Benchmark Instances

We use the benchmarks provided in [21] and [28] to test our algorithm. The benchmark instances are divided into three categories. The first group of instances (Type I) was tested on the Tenth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR’09) [28]. The second benchmark instances (Type II) corresponds to ad hoc network clustering problems [28], which are generated by Jovanovic et.al presented in the paper [43]. The third one (Type III) was introduced in [44] used in [21]. The densities of the third instances are ranging from 5 to 70%, and the vertex number of each instance is ranged from {30, 50, 70, 100, 120, 150, 200}.

7.2. Comparison with State-of-the-Art Algorithms

In this section, we compare our proposed algorithm MSLS with the current best algorithms, i.e., Greedy [7], ACO [28], ACO+PCS [28], GRASP [30], and VDNS [31]. The greedy algorithm first uses a greedy heuristic approach to find a dominating set, and then applies a steiner tree algorithm to make the dominating set connected. ACO algorithm is a basic Ant Colony Optimization Algorithm. ACO+PCS is an improved version of ACO, which incorporated the Pheromone Correction Strategy. The GRASP algorithm integrates two key components (greedy function and tabu strategy) to ensure the high efficiency. VNDS is a variable-depth neighborhood search algorithm with an effective partition-based neighborhood structure, pruning the search branch strategy, and the incremental evaluation technique. Note that our presented algorithm is executed 10 times on each instance of the three types of instances like algorithms ACO, ACO + PCS, and GRASP.

Our algorithm MSLS is coded in C, and it runs on a computer with Intel(R) Xeon(R) CPU E7-4830 (Dell, Xiamen, China) with 2.13 GHz. LPNMR’09 runs on a computer with Genuine Intel Intel(R) Core(TM)2 CPU 6600 with 2.40 GHz. ACO and ACO + PCS run on a computer with Genuine Intel Intel(R) Core(TM)2 CPU E8500 with 3.16 GHz. GRASP runs on a computer with Intel(R) Xeon(R) CPU E7-4830 with 2.13 GHz. VNDS runs on a computer with Intel i3 CPU of 2.1 GHz.

7.3. Experimental Results

To test the effectiveness of MSLS algorithm, we compare MSLS with other current best algorithms in terms of both the best solutions and running time. We also show the lower bound (denoted LB) obtained from the Lagrangian dual problem solved by the subgradient method and the lower bound can be used as a stopping criterion to verify if optimum has been found. Our heuristic algorithms all give the upper bound of the objective value. In

Table 1. Results of each algorithm on Type I instances.

Problem	LB	LPNMR	Greedy	ACO			ACO + PCS			GRASP			VDNS		MSLS
				Avg	St.	Tim	Avg	St.	Tim	Avg	St.	Tim	Avg	Tim	Avg	St.	Tim
40 × 200	5	5	10	5.8	0.6	3.2	5.3	0.45	4.1	5	0	7.1	5	<1	5	0	0.05
45 ×250	5	5	15	5.8	0.4	3.5	5.5	0.5	4.3	5	0	8.7	5	<1	5	0	0.06
50 × 250_1	6	8	15	8.1	0.54	4.8	8	0	6.1	7	0	9.8	8	<1	7	0	0.05
50 × 250_2	6	7	17	7.5	0.5	5	7.1	0.3	6.5	7	0	9.9	7	<1	7	0	0.06
55 × 250	6	8	20	8.8	0.98	5.6	8.3	0.45	7.3	8	0	9.8	8	<1	8	0	0.06
60 × 400	5	7	15	7	0	6.1	7	0	9.1	7	0	12.7	7	<1	7	0	0.08
70 × 250	11	13	32	14.2	0.74	11	13.9	1.04	13.5	12	0	11.5	13	<1	12	0	0.06
80 × 500	7	9	20	10	0.44	12	9.8	0.4	16.9	9	0	15.1	9	<1	9	0	0.08
90 × 600	7	10	19	10.9	0.83	14	10.6	1.01	17.3	9	0	17.2	10	<1	9	0	0.09
Average	6.4	8.0	18.1	8.7			8.3			7.7			8.0		7.7

, we give the experimental results of the Type I instances.

In Table 1, the first column Problem indicates the number of vertices and edges. In addition, the third column LPNMR shows the best results known as originally provided in literature [28]. In all benchmark instances, algorithms ACO, ACO + PCS, GRASP, VDNS, and MSLS can obtain the optimal solutions, so we omit the best found solutions. Column Avg indicates the average objective values of each algorithm. For Avg, our algorithm MSLS and GRASP are better than other algorithms on two instances (70 × 250, and 90 × 600). For standard deviation (St.), algorithms MSLS and GRASP both obtain 0 for each instance, which means that MSLS and GRASP obtain best solutions each run. Columns Tim shows average running time in second for 10 runs. Our algorithm MSLS is faster than other algorithm on most instances. The bold values indicate the best solution values obtained among the compared algorithms. The bold values in other tables mean the same thing.

In

Table 2. Results of each algorithm on Type II instances.

Problem	LB	Greedy	ACO		ACO + PCS		GRASP			VDNS		MSLS
			Min	Avg	Min	Avg	Min	Avg	Tim	300 s	30 s	Min	Avg	Tim
400_80_60	12	48	20	21.6	19	21.2	19	19.8	7.1	18	18	18	18.0	4.6
400_80_70	10	33	16	17.0	15	16.2	14	15.1	7.8	14	14	14	14.0	4.8
400_80_80	8	35	12	14.0	12	13.1	12	12	7.9	12	12	12	12.0	5.3
400_80_90	7	41	11	11.8	11	11.6	10	10.6	8.4	10	10	10	10.0	5.6
400_80_100	6	23	8	9.0	8	8.9	8	8.2	8.6	8	8	8	8.0	5.9
400_80_110	6	25	8	8.5	8	8.5	7	7.8	9.0	7	7	7	7.0	5.6
400_80_120	5	17	7	7.5	7	7.2	6	6.1	9.8	6	6	6	6.0	7.0
600_100_80	14	38	23	24.7	22	23.6	22	22.9	9.0	21	21	21	21.0	5.8
600_100_90	14	40	22	23.8	21	23.6	20	20.7	9.7	19	19	19	19.0	5.3
600_100_100	11	38	17	20.0	17	19.0	17	17.9	10.0	16	16	16	16.0	6.1
600_100_110	10	35	15	17.2	15	16.8	15	15.9	9.6	15	15	14	14.5	6.1
600_100_120	9	36	15	16.2	14	15.5	13	13.8	17.5	13	13	13	13.0	6.4
700_200_70	26	96	46	50.7	46	49.6	45	46.5	44.2	39	39	39	39.6	13.7
700_200_80	22	89	41	43.7	41	43.9	35	37.5	40.8	33	33	33	33.0	12.3
700_200_90	18	84	34	36.0	33	35.7	30	30.9	37.8	27	27	26	26.8	11.8
700_200_100	16	75	28	30.8	28	31.0	25	25.8	35.2	23	23	22	22.5	11.2
700_200_110	14	70	23	27.4	22	26.4	22	22.7	35.6	20	20	20	20.0	11.5
700_200_120	12	68	21	23.6	21	23.4	18	19.1	34.7	17	17	17	17.0	12.3
1000_200_100	26	96	46	50.7	46	49.6	45	46.5	44.5	39	39	39	39.6	13.5
1000_200_110	22	92	43	44.9	42	44.8	37	39.5	41.5	34	34	34	34.1	11.7
1000_200_120	20	82	37	39.9	37	39.8	34	35.4	41.5	30	30	29	30.3	11.5
1000_200_130	18	91	32	34.7	32	34.9	29	30.5	38.4	26	26	26	26.8	11.5
1000_200_140	16	76	30	31.3	29	31.3	25	25.7	35.3	23	23	23	23.1	10.9
1000_200_150	15	83	28	29.6	26	28.8	23	24.3	35.8	21	21	21	21.1	11.0
1000_200_160	14	86	24	26.6	25	26.5	22	22.3	35.0	20	20	19	19.6	11.5
1500_250_130	33	158	60	64.5	60	64.3	57	58.6	58.3	49	49	49	50.0	17.7
1500_250_140	30	144	53	57.2	52	57.0	50	52.3	55.6	44	44	44	44.3	15.9
1500_250_150	27	170	51	54.9	51	54.4	46	48.5	51.0	41	41	41	41.6	16.7
1500_250_160	25	151	47	50.5	45	49.8	43	43.7	49.4	38	38	37	37.7	14.7
2000_300_200	28	178	55	58.6	52	58.8	49	50.4	61.2	42	43	43	43.1	19.3
2000_300_210	26	151	51	53.5	50	52.8	45	46.1	60.1	39	39	38	38.6	18.1
2000_300_220	24	140	47	48.9	45	48.4	40	42.1	59.0	36	36	36	36.3	16.9
2000_300_230	23	166	44	47.5	44	46.9	39	39.8	56.4	36	36	34	34.8	18.1
2500_350_200	41	198	79	82.0	79	81.5	73	75.4	83.1	61	61	61	61.3	25.6
2500_350_210	39	185	75	79.1	74	78.2	67	70	80.8	58	58	56	57.0	24.8
2500_350_220	36	205	68	72.6	69	73.8	62	67	78.1	56	56	52	54.3	25.2
2500_350_230	34	193	66	69.2	66	68.9	59	60.9	76.1	50	50	50	51.6	24.4
3000_400_210	51	259	99	101.6	98	104.0	90	94.7	116.1	76	77	74	76.3	35.7
3000_400_220	48	225	88	95.4	91	97.6	82	87.9	108.9	72	73	71	71.9	33.8
3000_400_230	45	205	86	91.4	86	90.3	78	81.6	105.2	67	68	66	67.0	32.3
3000_400_240	42	210	82	85.8	80	84.1	74	76.1	100.4	63	65	61	62.5	31.7
Average	22.0	108.2	40.4	43.3	40.0	43.0	36.8	38.4		32.7	32.8	32.2	32.7

, we show the results of the Type II instances. The first column Problem indicates the instance names. For these types of instances, we only compared the best found solutions (Min) and the average solutions (Avg) for the five algorithms ACO, ACO+PCS, GRASP, VDNS, and MSLS. We observed that the greedy algorithm performs poorly on most problems compared to other algorithms. Compared with the greedy algorithm, ACO and ACO+PCS methods can improve the best solution by about 2–3 times, GRASP, VDNS and MSLS methods improve the best solution by about 3–4 times. Specifically, MSLS improves the best found solutions on 14 instances, obtains the best found solutions for other 26 instances, and only gets a worse solution (2000 × 300 × 200) than algorithm VDNS. For the average solution, MSLS improves the result quality in 40 instances except one (400 × 80 × 80). For the instance, GRASP and MSLS obtain the same average solution. Comparing the MSLS algorithm and GRASP algorithm, MSLS is faster than GRASP by 1–3 times. Comparing the MSLS algorithm and VDNS algorithm, VDNS obtained the best solutions within 30 s, and MSLS could obtain the same or better solutions within less than 30 s.

In

Table 3. Results of each algorithm on Type III instances.

Problem	OPT	LB	GRASP			VDNS		MSLS
			Min	Avg	Tim	Avg	Tim	Min	Avg	Tim
30_d10	15	12	15	15	3.5	15	7	15	15	3.1
30_d20	7	6	7	7	2.9	7	<1	7	7	2.4
30_d30	4	4	4	4	3.5	4	<1	4	4	2.9
30_d50	3	2	3	3	3.1	3	<1	3	3	4.3
30_d70	2	2	2	2	3.7	2	<1	2	2	5.2
50_d5	31	21	33	33.7	2.5	31	<1	31	31	5.2
50_d10	12	11	12	12	2.3	12	<1	12	12	3.0
50_d20	7	6	7	7	3.1	7	<1	7	7	4.5
50_d30	5	4	5	5	2.4	5	<1	5	5	5.7
50_d50	3	3	3	3	3.3	3	<1	3	3	10.4
50_d70	2	2	2	2	2.8	2	<1	2	2	13.6
70_d5	27	22	29	30.6	5.1	27	<1	27	27	4.8
70_d10	13	11	13	13	3.4	13	<1	13	13	4.6
70_d20	7	6	7	7	3.0	7	<1	7	7	6.1
70_d30	5	4	5	5	2.9	5	<1	5	5	9.9
70_d50	3	2	3	3	1.9	3	<1	3	3	17.6
70_d70	2	2	2	2	3.2	2	<1	2	2	21.4
100_d5	24	21	26	26.7	4.2	24	18	24	24	5.2
100_d10	13	11	13	13	2.8	13	1	13	13	6.6
100_d20	8	5	8	8	3.2	8	1	8	8	10.3
100_d30	6	4	6	6	1.7	6	1	6	6	14.8
100_d50	4	2	4	4	1.7	4	1	4	4	27.1
100_d70	3	2	3	3	1.8	3	1	3	3	41.4
120_d5	25	23	27	27.8	2.1	25	3	25	25	6.4
120_d10	13	11	14	14.3	1.9	13	1	13	13	7.9
120_d20	8	5	8	8.2	1.7	8	2	8	8	13.1
120_d30	6	4	6	6	1.7	6	3	6	6	19.5
120_d50	4	2	4	4	2.1	4	1	4	4	35.2
120_d70	3	2	3	3	2.0	3	1	3	3	56.2
150_d5	26	22	27	28.2	2.0	26	15	26	26	8.4
150_d10	14	11	15	15.3	2.2	14	17	14	14	11.1
150_d20	9	5	9	9	1.9	9	195	9	9	17.8
150_d30	6	4	6	6	1.6	6	8	6	6	26.5
150_d50	4	2	4	4	1.7	4	3	4	4	50.0
150_d70	3	2	3	3	1.6	3	3	3	3	82.3
200_d5	27	22	29	30.7	2.2	28	18	27	27	11.8
200_d10	16	10	16	16.9	2.1	16	247	16	16	16.6
200_d20	9	5	9	9.7	1.8	9	163	9	9	26.5
200_d30	7	4	7	7	1.7	7	59	7	7	40.4
200_d50	4	2	4	4	1.7	4	9	4	4	79.4
200_d70	3	2	3	3	1.7	3	2	3	3	136.0
Average	9.6	7.5	9.9	10.1		9.6		9.6	9.6

, we show the results of the Type III instances. The first column Problem indicates the instance names. For these types of instances, we compared the best found solutions (Min) and the average solutions (Avg) of the three algorithms GRASP, VDNS, and MSLS. The optimal solutions are given in the literature [21]. Column OPT indicates the optimal solution of each instance. For 41 instances, GRASP can obtain 33 optimal solutions, VDNS can obtain 40 optimal solutions, and MSLS can obtain all optimal solutions. From Table 1, Table 2 and Table 3, we can see that there’s a big gap between the solution obtained by MSLS and the lower bound (LB) for most instances.

7.4. Comparison of Different Versions of MSLS

From the above experimental results and discussion, it can be seen that our algorithm MSLS is superior to other comparison algorithms in most cases. In this section, we will further study the influence of various important factors in our presented algorithm MSLS: vertex fitness mechanism (Section 3), configuration checking mechanism (Section 4). These experiments are tested on the Type II Instances.

We obtain two variants of MSLS algorithm by rewriting the algorithm.

MSLS-CC: the algorithm does not use the configuration checking mechanism.

MSLS-VF: the only difference between MSLS-VF and MSLS is that MSLS-VF uses a static score function instead of the vertex fitness based dynamic score functions described in Section 3.

We test the two variants together with MSLS on the Type II Instances. As is shown in

Table 4. Results of MSLS-CC, MSLS-VF and MSLS on Type II graphs.

Problem	MSLS-CC		MSLS-VF		MSLS
	Min	Avg	Min	Avg	Min	Avg
400_80_70	15	15.0	14	14.0	14	14.0
400_80_110	7	7.4	7	7.0	7	7.0
400_80_120	6	6.0	7	7.0	6	6.0
600_100_100	17	17.0	16	16.0	16	16.0
600_100_110	15	15.0	14	14.9	14	14.5
600_100_120	14	14.0	13	13.0	13	13.0
700_200_100	24	24.5	23	23.1	22	22.5
700_200_110	21	21.0	20	20.3	20	20.0
700_200_120	18	18.0	17	17.1	17	17.0
1000_200_130	27	27.8	26	26.4	26	26.8
1000_200_140	24	24.8	23	23.7	23	23.1
1000_200_160	20	20.5	19	19.8	19	19.6
1500_250_130	50	51.2	50	50.1	49	50.0
1500_250_140	44	45.0	44	44.4	44	44.3
1500_250_160	37	38.4	37	37.2	37	37.7
2000_300_210	38	39.1	38	38.6	38	38.6
2000_300_220	36	36.6	36	36.1	36	36.3
2000_300_230	36	36.0	34	34.8	34	34.8
2500_350_200	61	62.5	61	61.5	61	61.3
2500_350_210	58	59.5	56	57.2	56	57.0
2500_350_220	54	55.8	52	53.5	52	54.3
3000_400_220	72	73.2	71	72.0	71	71.9
3000_400_230	68	69.1	66	67.0	66	67.0
3000_400_240	62	64.3	61	62.6	61	62.5

, MSLS performs better than MSLS-CC on almost all instances for best solutions (Min) and average solutions (Avg). For best solution, MSLS and MSLS-VF could obtain similar solutions. For average solutions, MSLS outperforms MSLS-VF on most instances. Therefore, we can come to the conclusion that the configuration checking mechanism and the vertex fitness mechanism presented in our algorithm are really efficient and play a significant role in tackling the MCDS problems.

8. Conclusions

In this paper, we presented a new local search algorithm, namely MSLS, to solve the minimum connected dominating set problem. The vertex score mechanism can make the algorithm jump out of the local optimum when it is trapped in the local optimum. Then, the configuration checking mechanism was applied to avoid the cycling problem in local search phase. Furthermore, we proposed a vertex flipping mechanism to change the vertex state by combing the CC mechanism with the vertex score mechanism. Based on the above mechanisms, we proposed the multi-start local search algorithm. We compared our algorithm MSLS with other state-of-the-art algorithms on a number of benchmark instances. The results of the experiment show that our proposed algorithm is superior to other algorithms in solution quality and time efficiency. For the Type I instance, MSLS found optimal solutions for all nine instances. For the Type II instance, MSLS improved 14 optimal solutions of 41 instances. For the Type III instance, MSLS obtained optimal solutions for all 41 instances. In the future work, our algorithm can be extended to solve other combinatorial optimization problems, such as the set–union knapsack problem [45], the minimum conductance graph partitioning problem [46], the set k-covering problem [47], and the partial vertex cover problem [48].