A multi-start iterated greedy algorithm for the minimum weight vertex cover P3 problem

Applied Mathematics and Computation 349 (2019) 359–366

Contents lists available at ScienceDirect

Applied Mathematics and Computation journal homepage: www.elsevier.com/locate/amc

A multi-start iterated greedy algorithm for the minimum weight vertex cover P3 problem Wenjie Zhang a, Jianhua Tu a,∗, Lidong Wu b a b

Department of Mathematics, Beijing University of Chemical Technology, Beijing 100029, China Department of Computer Science, The University of Texas at Tyler, Tyler, TX 75799, USA

a r t i c l e

i n f o

Keywords: Iterated greedy algorithm Minimum weight vertex cover P3 problem Heuristic algorithms Combinatorial optimization problems

a b s t r a c t Given a vertex-weighted graph G = (V, E ) and a positive integer k ≥ 2, the minimum weight vertex cover Pk (MWVCPk ) problem is to find a vertex subset F ⊆ V with minimum total weight such that every path of order k in G contains at least one vertex in F. For any integer k ≥ 2, the MWVCPk problem for general graphs is NP-hard. In this paper, we restrict our attention to the MWVCP3 problem and present a multi-start iterated greedy algorithm to solve the MWVCP3 problem. The experiments are carried out on randomly generated instances with up to 10 0 0 vertices and 250 0 0 0 edges. Our work is the first one to adopt heuristic algorithms to solve the MWVCP3 problem, and the experimental results show that our algorithm performs reasonably well in practice. © 2019 Elsevier Inc. All rights reserved.

1. Introduction Given an undirected graph G = (V, E ) and a positive integer k ≥ 2, a subset of vertices F ⊆ V is called a vertex cover Pk set (VCPk set) if each path on k vertices in G contains at least one vertex in F. The vertex cover Pk (VCPk ) problem is to find a minimum VCP3 set in a given graph. When k = 2, the VCPk problem is the well-known vertex cover problem which is a classical optimization problem in computer science and is a typical example of an NP-hard optimization problem. Thus, the VCPk problem is a natural generalization of the vertex cover problem. The minimum weight vertex cover Pk (MWVCPk ) problem is the weighted version of the VCPk problem, where vertices have non-negative weights. The study of the VCPk problem is motivated by two real-life problems. The first motivation comes from the design of secure protocols for communication in wireless sensor networks (WSN) (see [4,11]). In many applications of WSN, it is usually important to ensure the security properties of WSN including confidentiality, authenticity, date integrity and so on. Traditional security techniques cannot be applied directly to WSN, because sensor devices usually have limited capabilities of computation, energy and communications. Moreover, they are often deployed in accessible areas, where they can be rather easily captured by attackers. In general, a standard sensor device is not considered as a tamper-resistant. It is also undesirable to make all devices of a sensor network tamper-proof due to the increasing costs. Therefore, the design of WSN security protocols has become a challenge in security research field. The topology of a wireless sensor network can be modeled as a graph, in which vertices represent sensors and edges represent communication channels between sensors. The k-generalized Canvas Scheme, which was first introduced by Novotny [11], guarantees data integrity under the assumption that at least one vertex is not captured on each path of order k. Thus during the deployment and initialization of a sensor network, it should be ensured that at least one protected vertex exists ∗

Corresponding author. E-mail addresses: [email protected] (W. Zhang), [email protected] (J. Tu), [email protected] (L. Wu).

https://doi.org/10.1016/j.amc.2018.12.067 0 096-30 03/© 2019 Elsevier Inc. All rights reserved.

360

W. Zhang, J. Tu and L. Wu / Applied Mathematics and Computation 349 (2019) 359–366

on each path of order k. The problem of minimizing the cost of the network by minimizing the number of protected vertices is exactly the VCPk problem. The second motivation is related to controlling traffic at street crossings (see [15]). Increasing traffic can result in more and more traffic accidents, and this is one of the reasons why in many cities cameras are installed to monitor and control the traffic flows. It is undesirable to install cameras at every traffic junction because of the increasing costs. Therefore, one might consider to install cameras at certain junctions, ensuring that any driver will encounter at least one camera with k successive junctions. The problem of minimizing the cost of installing the cameras at certain junctions is also exactly the VCPk problem. The VCPk problem is known to be NP-hard for any integer k ≥ 2 [15]. In this paper,we restrict our attention to the MWVCP3 problem. Many efforts have been made in study of the VCP3 problem and the MWVCP3 problem. Kardoš et al. [7] gave an exact algorithm for the VCP3 problem with running time 1.5171n · nO(1) , and Chang et al. [5] improved the time-complexity to 1.4658n · nO(1) . In [18], Xiao et al. gave an exact algorithm which can solve the VCP3 problem in O∗ (1.4646n ) time and polynomial space or O∗ (1.3659n ) time and exponential space. In [14,15], Tu et al. gave two 2-approximation algorithms for the MWVCP3 problem using the primal-dual method and the local-ratio method. For parameterized algorithms of the VCP3 probelm, Fellows et al. [6] gave an algorithm with running time 2t · nO(1) , where parameter t is the size of the solution sought after. Independently, Moser et al. [10] and Tu [13] gave algorithms with the same running time. Using the Measure & Conquer approach, Wu [17] improved running time to 1.882t · nO(1) . Katrenicˇ [8] gave further improvement so that running time reaches 1.8172t · nO(1) . Given an n-vertex graph together with its tree decomposition of width at most p, Tu et al. [16] present an algorithm running in time 4p · nO(1) for the VCP3 problem. The heuristic algorithms are designed to solve problems in a faster and more efficient fashion than traditional methods by sacrificing optimality, accuracy, or completeness for speed. People consider heuristic algorithms as a choice for solving a problem more quickly when traditional methods are too slow, or for finding approximate solution when traditional methods fail to find any exact solution. To the best of our knowledge, no heuristic approach is proposed for the VCP3 problem. In this paper, we present a multi-start iterated greedy algorithm for solving the MWVCP3 problem. Our work is the first one to adopt heuristic algorithms to solve the MWVCP3 problem. The experiments are carried out on randomly generated instances with up to 10 0 0 vertices and 250 0 0 0 edges, and the experimental results show that our algorithm performs reasonably well in practice. The organization of this paper is as follows. A formal description of the MWVCP3 problem is presented in Section 2. The proposed multi-start iterated greedy algorithm is described in Section 3. An extensive experimental evaluation is given in Section 4. Finally, conclusions and an outlook to future work are offered in Section 5. 2. Description of the MWVCP3 problem The graphs considered in this paper are finite, loopless and contain no multiple edges. We follow [2] for notations and terminologies not given here. As usual, Pk is a path on k vertices. By the order of a path P we understand the number of vertices on P. Given a graph G = (V, E ), let n and m be the number of vertices and edges, respectively. The open neighborhood of a vertex, NG (v ), is the set of neighbors of a vertex v, i.e., N (v ) = {u ∈ V |(u, v ) ∈ E }. The closed neighbourhood is defined NG [v] = NG (v ) ∪ {v}. The degree of a vertex v ∈ V (G ), denoted by dG (v ), is the size of its open neighbourhood in G, |NG (v )|. Let δ (G) and (G) denote the minimum and maximum degree of G, respectively. For a vertex subset F ⊆ V, we denote by G − F the induced subgraph G[VࢨF] obtained by deleting the vertices in F from G and all edges incident with them. Let G = (V, E ) be an undirected graph with weight function w : V → R+ . The MWVCP3 problem can be formulated as follows: 

minimize w(F ) =

v∈F

w ( v ),

subject to : {vi , v j , vk } ∩ F = ∅, for each path of order 3, (vi , v j , vk ), in G, F ⊆ V. As described above, F is a subset of V and it is considered as a valid solution only if F is a VCP3 set in G. It should be pointed out that the VCP3 problem is also known as the bounded-degree-one deletion problem. Given a graph G = (V, E ), the problem is to find a minimum number of vertices such that deleting them results in a graph with maximum degree at most 1. 3. The proposed algorithm Heuristic methods that aspire to find global optima usually require some type of diversification to overcome local optimality. In recent years many techniques have been suggested. One way to achieve diversification is to re-start the search from a new solution once a region has been extensively explored. Multi-Start methods provide an appropriate framework to develop algorithms for achieving diversification. The re-start mechanism can be super-imposed on many different search methods (see [9,19]). In this section, an multi-start iterative greedy algorithm (MSIG) based on greedy strategy and interference mechanism is proposed for the MWVCP3 problem. Given a vertex-weighted graph G = (V, E ), a subset of vertices F is called a complete solution of the MWVCP3 problem if F is a VCP3 set in G, F is called a partial solution if F is a proper subset of a VCP3 set in G. We say that a complete solution F is minimal if for any v ∈ F , F − v is a partial solution, in other words, F − v is not a VCP3 set.

W. Zhang, J. Tu and L. Wu / Applied Mathematics and Computation 349 (2019) 359–366

361

The algorithm MSIG works as follows: (1) At each restart procedure, an initial solution is generated by using greedy and random strategies. Then the complete solution will be minimized. The initial solution F1 is generated by procedure GenerateInitialSolution(G) and a minimal complete solution F2 can be obtained by minimizing F1 using procedure Minimize(F1 ). (2) Then, the minimal complete solution F2 is partially destroyed using procedure Destroy(F2 ), resulting in a partial solution F3 . On the basis of F3 , a complete solution F4 is then constructed using procedure GreedySearch(F3 ). (3) We keep record of the best solutions found during the search. This process is repeated until the best objective value has not been improved within specific threshold L. Finally, we restart the previous process for a given times N in order to search in different promising areas. The proposed algorithm MSIG is described in Algorithm 1.

Algorithm 1: MSIG.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

Input: A graph G = (V, E ) with weight function w : V → R+ , parameters N and L Output: A V CP3 set F in G and its weight w(F ) F ←∅ w ( F ) ← +∞ iter ← 0 while iter ≤ N do F1 ←GenerateInitialSolution(G) // generate an initial solution F1 . F2 ←Minimize(F1 ) // minimize the initial solution F1 (see Algorithm 2). no_improve ← 0 while no_improve < L do F3 ← Destroy(F2 ) // F2 is partially destroyed, resulting in a partial solution F3 . F4 ← GreedySearch(F3 ) // construct a complete solution F4 based on F3 (see Algorithm 3). if w(F4 ) < w(F ) then w(F ) ← w(F4 ) F ← F4 no_improve ← 0 else no_improve ← no_improve + 1 end F2 ← F4 end it er ← it er + 1 end return F , w(F )

The main procedures in Algorithm 1 are detailed in the following: GenerateInitialSolution(G): At each restart iteration, an initial solution is generated using random and greedy strategies. Specifically, a subset of vertices F1 is generated by choosing each vertex of V independently with probability p (we set p := 0.3). Then, check whether F1 is a complete solution, that is, whether F1 is a VCP3 set in G. If not, the graph G − F1 contains some vertices of degree at least 2 and we use random or greedy strategy to choose one of them to add into the set F1 . More precisely, the greedy mechanism usually chooses one vertex with lowest cost (cost (v ) = d w(v()v ) ) while the random G−F1

mechanism randomly chooses one vertex among the candidate vertices. The probability on selecting the greedy mechanism and the random mechanism is equal. Repeat the process until F1 is a complete solution, i.e., the graph G − F1 contains no vertex of degree at least 2. The randomness of the procedure GenerateInitialSolution(G) guarantees that each initial solution stays farther away from the other initial solutions. Minimize: In general, the initial solution F1 generated by the procedure GenerateInitialSolution is not a minimal VCP3 set. Thus, there may be some redundant vertices in F1 . Given a vertex-weighted graph G = (V, E ) and a VCP3 set F in G, on the basis of F a minimal VCP3 set can be obtained by the procedure Minimize(F). Let

R1 := {v|N[v] ⊆ F }, R2 := {v|(v ∈ F ) ∧ (v has only one neighbour u in V

\ F ) ∧ (dG−F (u ) = 0 )}.

Let R := R1 ∪ R2 . If R is not empty, it is easy to see that each vertex in R is a redundant vertex. Order vertices of R in the decreasing order by weights. Suppose that R = {v1 , v2 , . . . , vt }. Consider each vertex in R in turn. If F \ {vi } is also a VCP3 set in G, then delete it from F. Finally, we can obtain a minimal VCP3 set in G.

362

W. Zhang, J. Tu and L. Wu / Applied Mathematics and Computation 349 (2019) 359–366

Algorithm 2: Minimize(F).

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Input: Given a vertex-weighted graph G = (V, E ) and a V CP3 set F in G Output: A minimal V CP3 set F  in G F ← F Find R1 := {v|N[v] ⊆ F  }. Find R2 := {v|(v ∈ F  ) ∧ (v has only one neighbour u in V \ F  ) ∧ (dG−F  (u ) = 0 )}. Let R := R1 ∪ R2 while R = ∅ do Order vertices in R in the decreasing order of weights. Suppose R = {v1 , v2 , . . . , vt }. for i = 1 : t do if (G[(V \ F  ) ∪ {vi }] ) ≤ 1 then F  ← F  \ {v} end R ← R \ {vi } end end Output F  .

Lemma 3.1. Given a vertex-weighted graph G = (V, E ) and a VCP3 set F in G, Algorithm 2 outputs a minimal VCP3 set F in G. Proof. We prove by contradiction. Suppose that there exists a vertex u so that F ࢨ{u} is a VCP3 set in G. Because that F ⊆ F, Fࢨ{u} is also a VCP3 set in G. Thus, u ∈ R and there exists some i so that u = vi . It is easy to see that during the algorithm run, the set F is a subset of the set in the previous step. At the step when the vertex vi is considered, F  \ {vi } is a VCP3 set and vi should be deleted from the current set F . This contradicts the assumption that u = vi is a vertex in the finial set F .  Destroy: Given a vertex-weighted G = (V, E ) and a complete solution F, each time we randomly choose one vertex in F and remove it from F. This procedure repeats pd × |F| times and then pd × |F| randomly chosen vertices are removed from F. Parameter pd is called the degree of destruction. This procedure outputs a partial solution. GreedySearch: This procedure takes a partial solution F as input. At each iteration, a new vertex is added into the partial solution F until F is a complete solution. At each iteration, we choose one vertex in the following way and add it into F. For each vertex v of degree dG−F (v ) ≥ 2 in G − F , we set two greedy cost functions:

cost1 (v ) =

w (v ) 2w ( v ) , cost2 (v ) = 2 . dG−F (v ) dG−F (v )

The first greedy cost function cost1 (v ) is the same as the one used in many greedy algorithms for the minimum weight d

( v )· ( d

(v )−1 )

G−F vertex cover problem. On the other hand, for a vertex v of degree dG−F (v ) ≥ 2, v is the median vertex of G−F 2 different paths of order 3. Thus we define cost2 (v ) as the other greedy cost function. The parameter pr is used to decide which one of the two greedy cost functions is chosen. Generate a random value α uniformly distributed over [0, 1]. If α ≤ pr , then we use the greedy cost function cost1 (v ) to choose a new vertex, otherwise we use the greedy cost function cost2 (v ) to choose a new vertex. According to the chosen greedy cost function, let vbest and 1 vbest be respectively the vertices of the lowest and the second lowest cost values. The parameter pc is used to decide which 2 one of the two vertices vbest and vbest is chosen and added into F. Generate a random value β uniformly distributed over [0, 1 2 1]. If β ≤ pc , then vbest is chosen and added into F, otherwise, vbest is chosen and added into F. The purpose of introducing 1 2 the two greedy cost functions and random numbers α , β is to ensure diversity of solutions that can prevent premature convergence to a local optimum in the search. The iterative process stops once (G[VࢨF]) ≤ 1. Finally, the complete solution will be minimized by using Procedure Minimize. The details of the procedure GreedySearch is described in Algorithm 3.

4. Experimental results 4.1. Problem instances In the study, the proposed algorithm MSIG was implemented in C using GCC 5.4 for compiling the software, and experimentally evaluated on a personal computer equipped with Intel®CoreTM i7-3770 CPU processor with 3.40 GHz and 4 GB of memory. Our computational experiments are carried out on randomly generated instances with up to 10 0 0 vertices and 250 0 0 0 edges. In particular, many of these instances are the standard benchmark instances that are always used to analysis the

W. Zhang, J. Tu and L. Wu / Applied Mathematics and Computation 349 (2019) 359–366

363

Algorithm 3: GreedySearch.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

Input: A vertex-weighted graph G = (V, E ), a partial solution F , parameters pr and pc Output: A complete solution F  F ← F while (G[V \ F  ] ) > 1 do SF  ← {v ∈ (V \ F  )|dG−F  (v ) > 1} α ←random number uniformly distributed over [0,1] if α ≤ pr then vbest ← argmin{cost1 (v )|v ∈ SF  }; 1 vbest ← argmin{cost1 (v )|v ∈ [SF  \ {vbest }]}; 2 1 β ←random number uniformly distributed over [0,1] if β ≤ pc then vbest ← vbest 1 else best v ← vbest 2 end F  ← F  ∪ {vbest } else vbest ← argmin{cost2 (v )|v ∈ SF  }; 1 vbest ← argmin{cost2 (v )|v ∈ [SF  \ {vbest }]}; 2 1 β ←random number uniformly distributed over [0,1] if β ≤ pc then vbest = vbest 1 else vbest = vbest 2 end F  ← F  ∪ {vbest } end end F  ← Minimize(F  ) // see Algorithm 2. Output F  .

heuristic algorithms for the minimum weight vertex cover problem (see [3,12]). Each instance consists of an undirected and vertex-weighted graph with n vertices and m edges. According to the scale of the instances, these instances are divided into three different classes: Class SPI: The class contains 400 small scale instances, where n takes values from {10, 15, 20, 25}. Class MPI: The class contains 720 middle scale instances, where n takes values from {50, 100, 150, 200, 250, 300}. Class LPI: The class contains of 38 large scale instances, where n takes values from {500, 800, 1000}. For the instances of all classes, the weight w(v ) of each vertex v ∈ V is randomly drawn from a uniform distribution, either from the interval [20, 120] (referred to as Type I) or from the interval [1, d 2 (v )] (referred to as Type II), where d (v ) is the degree of vertex v.

4.2. Parameters setting The proposed algorithm MSIG contains five parameters for which appropriate values must be determined. This concerns (1) the maximum number of restarts N (see Algorithm 1), (2) the consecutive iteration number of search without improvement L (see Algorithm 1), (3) the degree of destruction pd (pd ∈ (0, 1]) in the procedure Destroy, (4) the parameter pr that is used to decide which one of the two greedy cost functions is chosen (see Algorithm 3), and the parameter pc that is used to decide which one of the two vertices vbest and vbest is chosen and added into F. The values in Table 1 were considered. 1 2 When setting parameter N and L, we always let the equation N · L = 20 0 0 0 holds, for example N = 200, L = 100, thus there are 160 possible combinations of parameter values. A full factorial design approach was applied and all 160 possible combinations of parameter values were considered. For analyzing the tuning experiments, we utilize the rank-based procedure as described in [1]. For each of the problem instances the 160 different parameter settings were ordered based on the solution values they presented for the corresponding instance. Based on the comprehensive analysis of the experimental results, we obtain the appropriate parameter settings as presented in Table 2.

364

W. Zhang, J. Tu and L. Wu / Applied Mathematics and Computation 349 (2019) 359–366 Table 1 Parameter values that were considered. Parameter

Description

Values

N L pd pr pc

The maximum restart times The consecutive iteration number of search without improvement The degree of destruction Decide which one of the two greedy cost functions is chosen and vbest is chosen and added into F Decide which one of the two vertices vbest 1 2

20 0, 40 0, 80 0, 10 0 0 20, 25, 50, 100 0.3, 0.4, 0.5, 0.6 0.5, 0.6 0.4, 0.5, 0.6, 0.7, 0.8

Table 2 The appropriate parameter settings for MSIG. Class

The combination with the best average rank

SPI MPI LPI

(N, L, pd , pr , pc ) = (400, 50, 0.4, 0.5, 0.5 ) (N, L, pd , pr , pc ) = (400, 50, 0.6, 0.5, 0.6 ) (N, L, pd , pr , pc ) = (400, 50, 0.5, 0.5, 0.4 )

Table 3 Results for instances of Class SPI. Type I

Type II

n

m

OPT

AVG

Time(s)

OPT

AVG

Time(s)

10

10 20 30 40

169.3 292.8 392.1 482.9

169.3 292.8 392.1 482.9

0.0 0 0 0.0 0 0 0.0 0 0 0.0 0 0

8.5 43.3 103.1 200.6

8.7 43.3 103.1 200.6

0.0 0 0 0.0 0 0 0.0 0 0 0.0 0 0

15

20 40 60 80 100

320.9 478.9 596.9 721.8 805.4

320.9 478.9 596.9 721.8 805.4

0.0 0 0 0.0 0 0 0.0 0 0 0.001 0.002

26.0 120.5 290.4 585.7 1082.5

26.0 120.5 290.4 585.7 1082.5

0.0 0 0 0.0 0 0 0.0 0 0 0.0 0 0 0.001

20

20 40 60 80 100 120

341.0 562.1 705.8 819.3 917.9 933.4

341.0 562.1 705.8 819.3 917.9 933.4

0.0 0 0 0.0 0 0 0.0 0 0 0.001 0.002 0.003

17.6 78.5 206.1 370.5 697.7 986.4

18.2 78.5 206.1 370.5 697.7 986.4

0.0 0 0 0.0 0 0 0.001 0.002 0.008 0.010

25

40 80 100 150 200

599.6 901.0 929.9 1128.0 1297.2

599.6 901.0 929.9 1128.0 1297.2

0.0 0 0 0.001 0.002 0.004 0.007

63.3 299.3 532.3 1244.2 2555.8

63.3 299.3 532.3 1244.2 2555.8

0.001 0.003 0.009 0.010 0.012

4.3. Experimental results In the subsection, we present and analysis the experimental results. 4.3.1. Results concerning class SPI The numerical results obtained by MSIG for the instances of Class SPI are shown in Table 3. For each combination of n and m and each type, 10 instances of Class SPI are randomly generated. The algorithm MSIG was executed only once on each instance, and the results are presented as an average over the objective function values obtained for the 10 instances. In total, 400 instances of Class SPI are generated. On the other hand, a branch and bound algorithm for the MWVCP3 problem that derives the optimal solutions was also implemented. The structure of Tables 3 is as follows. The first two columns indicate the number of vertices (n) and the number of edges (m). Column OPT refers to the optimal solution values (averaged over 10 instances). Column AVG and Time(s) refer to the average solution values (averaged over 10 instances) and the average computation time (in seconds). It is easy to see that that the proposed algorithm MSIG always finds the optimal solutions. This can be confirmed by comparing the values in column OPT with the average solution values obtained by MSIG. For what concerns computation time, we can observe that MSIG is very fast. In fact, computation time is smaller than 0.01 seconds in almost all cases. Thus, MSIG performs especially well for solving small scale instances. 4.3.2. Results concerning class MPI The numerical results for the instances of Class MPI are shown in Tables 4. For each combination of n and m and each type, 10 instances of Class MPI are randomly generated. The algorithm MSIG was executed only once on each instance,

W. Zhang, J. Tu and L. Wu / Applied Mathematics and Computation 349 (2019) 359–366

365

Table 4 Results for instances of class MPI. Type I

Type II

Type I

Type II

n

m

AVG

Time(s)

AVG

Time(s)

n

m

AVG

Time(s)

AVG

Time(s)

50

50 100 250 500 750 10 0 0

803.1 1300.6 2070.9 2615.3 2828.8 3062.9

0.009 0.011 0.015 0.023 0.033 0.037

32.3 219.6 1671.2 7226.3 18429.1 33689.8

0.006 0.035 0.040 0.049 0.054 0.076

200

200 750 20 0 0 50 0 0 110 0 0 150 0 0

4419.4 7703.5 10393.2 12187.3 12907.5 13355.0

0.308 0.922 2.507 3.903 6.814 8.959

159.7 3673.4 30831.0 215502.8 1103083.1 2184046

0.284 1.067 3.407 4.640 7.913 9.643

100

100 250 500 10 0 0 20 0 0 30 0 0

2063.4 3110.4 4174.8 5184.7 6018.3 6356.3

0.034 0.051 0.060 0.384 0.679 0.695

76.7 715.6 3360.9 15558.0 69815.9 160660.9

0.043 0.096 0.134 0.287 0.532 1.011

250

250 750 30 0 0 80 0 0 150 0 0 250 0 0

5441.1 8444.8 13577.3 15570.7 16230.5 16902.4

0.326 1.423 10.693 13.578 16.623 20.688

201.2 2903.1 58578.7 470666.9 1689782.8 4825468

0.393 1.788 13.923 20.433 24.275 31.044

150

150 500 10 0 0 30 0 0 50 0 0 90 0 0

3125.7 5227.5 6901.8 8971.4 9190.2 9837.3

0.081 0.281 0.448 1.321 1.228 2.742

113.8 2211.8 9817.2 102530.2 298703.8 997540.1

0.082 0.310 0.311 1.385 1.087 3.048

300

300 10 0 0 30 0 0 10 0 0 0 20 0 0 0 30 0 0 0

6819.6 11030.0 15910.2 18943.7 19692.2 20419.2

0.445 2.752 9.823 13.791 17.336 21.879

249.1 4609.8 47271.5 597885.4 2552361 5815810.8

0.526 4.845 17.919 43.305 48.852 60.548

Table 5 Results for instances of class LPI. Type I

Type II

n

m

AVG

Time(s)

AVG

Time(s)

500

500 10 0 0 50 0 0 10 0 0 0 30 0 0 0 70 0 0 0

11389.9 14981.4 26778.3 29800.8 33101.0 33803.8

2.357 10.525 21.735 43.009 55.104 57.418

1691.1 2761.0 83887.3 346458.1 3315045.5 19561055.6

2.536 16.635 40.394 48.259 54.875 95.041

800

800 20 0 0 10 0 0 0 50 0 0 0 10 0 0 0 0 150 0 0 0

18193.1 26248.6 44763.0 52783.3 55014.2 55361.9

5.298 26.243 100.603 143.279 325.968 416.082

1557.4 7315.4 215616.1 5739581.6 23146638.4 54516391.2

4.061 40.974 117.128 192.689 361.900 463.712

10 0 0

10 0 0 10 0 0 0 20 0 0 0 40 0 0 0 10 0 0 0 0 20 0 0 0 0 250 0 0 0

24256.6 54529.7 61809.5 64122.7 66017.3 68631.7 68772.3

17.175 292.619 474.230 512.065 640.041 692.200 727.831

3264.1 169104.7 718132.0 2956979.2 19165184.7 78167662.8 126158947.1

19.05 286.392 483.369 566.160 710.591 882.040 932.258

and the results are presented as an average over the objective function values obtained for the 10 instances. In total, 720 instances of Class MPI are randomly generated. All Columns are same as described in the previous subsections for the instances of Class SPI except that Column OPT is missing. Because of their increased sizes, optimal solutions are not known for these instances. It can be observed that computation time is smaller than 1 min in almost all cases. The algorithm MSIG can quickly find approximate solutions for the middle scale instances.

4.3.3. Results concerning class LPI The numerical results for the instances of Class LPI are shown in Tables 5. For each combination of n and m and each type, only one instance of Class LPI is randomly generated. The algorithm MSIG was executed 10 times on each instance, and the results are presented as an average over 10 independent runs. In total, 38 instances of Class MPI are randomly generated. All Columns are same as described in the previous subsections for the instances of Class MPI. It can be observed that computation time is smaller than 15 min in almost all cases. Thus, the proposed algorithm MSIG can find approximate solutions for the large scale instances in an acceptable time.

366

W. Zhang, J. Tu and L. Wu / Applied Mathematics and Computation 349 (2019) 359–366

5. Conclusions No heuristic approach was proposed for the VCP3 problem in the literature. Thus, our work seems to be the first one to adopt heuristic algorithms to solve the VCP3 problem. In this paper, we have proposed a multi-start iterated greedy algorithm MSIG to tackle the MWVCP3 problem that is the weighted version of the VCP3 problem. The experiments are carried out on randomly generated instances with up to 10 0 0 vertices and 250 0 0 0 edges, and the experimental results have shown that the algorithm MSIG always finds satisfactory solutions and takes less time. In particular, MSIG can solve optimality almost all small scale instances in negligible computation time. In our algorithm, the multi-start method and destroy mechanism can effectively avoid being trapped in a local optimum or cycling search. Thus, as the size of the graph increases, our algorithm can still find the satisfactory solutions. In the future, we will investigate other heuristic algorithms for solving the MWVCP3 problem and compare these algorithms with the algorithm MSIG. On the other hand, if we want to generalize the method to the MWVCPk problem (k ≥ 4), we need to further analyse the structure of the problem and design some appropriate greedy strategies. We also will consider the heuristic algorithms for solving the MWVCPk problem (k ≥ 4). Acknowledgment We thank the referees for their helpful comments and suggestions. References [1] S. Benedettini, C. Blum, A. Roli, A randomized iterated greedy algorithm for the founder sequence reconstruction problem, in: Proceedings of the International Conference on Learning and Intelligent Optimization, Springer-Verlag, 2010, pp. 37–51. [2] J.A. Bondy, U.S.R. Murty, Graph Theory, Springer, New York, 2008. [3] S. Bouamama, C. Blum, A. Boukerram, A population-based iterated greedy algorithm for the minimum weight vertex cover problem, Appl. Soft Comput. 12 (6) (2012) 1632–1639. [4] B. Brešar, F. Kardoš, J. Katreniš, G. Semanišin, Minimum k-path vertex cover, Discret. Appl. Math. 159 (2011) 1189–1195. [5] M. Chang, L. Chen, L. Hung, Y. Liu, P. Rossmanith, S. Sikdar, An o∗ (1.4658n )-time exact algorithm for the maximum bounded-degree-1 set problem, in: Proceedings of the Thirty First Workshop on Combinatorial Mathematics and Computation Theory, 2014, pp. 9–18. [6] M. Fellows, J. Guo, H. Moser, R. Niedermeier, A complexity dichotomy for finding disjoint solutions of vertex deletion problems, ACM Trans. Comput. Theory 2 (2011) 1–23. [7] F. Kardoš, J. Katrenicˇ , I. Schiermeyer, On computing the minimum 3-path vertex cover and dissociation number of graphs, Theor. Comput. Sci. 412 (50) (2011) 7009–7017. [8] J. Katrenicˇ , A faster FPT algorithm for 3-path vertex cover, Inf. Process. Lett. 116 (2016) 273–278. [9] R. Martí, Multi-start methods, in: F. Glover, G.A. Kochenberger (Eds.), Handbook of Metaheuristics. International Series in Operations Research & Management Science, 57, Springer, Boston, MA, 2003. [10] H. Moser, R. Niedermeier, M. Sorge, Exact combinatorial algorithms and experiments for finding maximum k-plexes, J. Comb. Optim. 24 (2012) 347–373. [11] M. Novotný, in: Design and analysis of a generalized canvas protocol, Proceedings of the WISTP, in: LNCS, 6033, Springer-Verlag, 2010, p. 106-12. [12] S. Shyu, P. Yin, B. Lin, An ant colony optimization algorithm for the minimum weight vertex cover problem, Ann. Oper. Res. 131 (1–4) (2004) 283–304. [13] J. Tu, A fixed-parameter algorithm for the vertex cover p3 problem, Inf. Process. Lett. 115 (2015) 96–99. [14] J. Tu, W. Zhou, A factor 2 approximation algorithm for the vertex cover p3 problem, Inf. Process. Lett. 111 (14) (2011) 683–686. [15] J. Tu, W. Zhou, A primal-dual approximation algorithm for the vertex cover p3 problem, Theor. Comput. Sci. 412 (50) (2011) 7044–7048. [16] J. Tu, L. Wu, J. Yuan, L. Cui, On the vertex cover p3 problem parameterized by treewidth, J. Combin. Optim. 34 (2017) 414–425. [17] B. Wu, A measure and conquer approach for the parameterized bounded degree-one vertex deletion, COCOON (2015) 469–480. [18] M. Xiao, S. Kou, Exact algorithms for the maximum dissociation set and minimum 3-path vertex cover problems, Theor. Comput. Sci. 657 (2017) 86–97. [19] T. Zhou, Y. Wang, J. Ding, B. Peng, Multi-start iterated tabu search for the minimum weight vertex cover problem, J. Comb. Optim. 32 (2) (2016) 368–384.