Combining Edge Weight and Vertex Weight for Minimum Vertex Cover ...

Combining Edge Weight and Vertex Weight for Minimum Vertex Cover Problem Zhiwen Fang1 , Yang Chu1 , Kan Qiao2 , Xu Feng1 , and Ke Xu1 1

State Key Lab. of Software Development Environment, Beihang University, Beijing 100191, China {zhiwenf,mottotime,isaiah.feng}@gmail.com, [email protected] 2 Department of Computer Science, Illinois Institute of Technology, Chicago 60616, USA [email protected]

Abstract. The Minimum Vertex Cover (MVC) problem is an important NP-hard combinatorial optimization problem. Constraint weighting is an effective technique in stochastic local search algorithms for the MVC problem. The edge weight and the vertex weight have been used separately by different algorithms. We present a new local search algorithm, namely VEWLS, which integrates the edge weighting scheme with the vertex weighting scheme. To the best of our knowledge, it is the first time to combine two weighting schemes for the MVC problem. Experiments over both the DIMACS benchmark and the BHOSLIB benchmark show that VEWLS outperforms NuMVC, the state-of-the-art local search algorithm for MVC, on 73% and 68% of the instances, respectively.

1

Introduction

Given an undirected graph G = (V, E), a vertex cover of G is a subset V ⊆ V such that every edge in G has at least one endpoint in V . The Minimum Vertex Cover (MVC) problem consists of finding a vertex cover of smallest possible size. MVC is an important NP-hard combinatorial optimization problem and its decision version is one of Karp’s 21 NP-complete problems. It appears in a variety of real-world applications, such as the network security, VLSI designs and bioinformatics. MVC is equivalent to two other well-known NP-hard combinatorial optimization problems: the Maximum Clique (MC) problem and the Maximum Independent Set (MIS) problem, which have a mass of applications in the areas of information retrieval, social networks and coding theory. Due to the equivalence, algorithms for one of these problems can be applied to the others in practice. A huge amount of effort has been devoted to solve the MVC (MC, MIS) problem over the last decades in the AI community. Generally, algorithms to solve the MVC (MC, MIS) problem fall into two types: exact algorithms mainly including the branch-and-bound search [13, 20, 19, 10, 11] and heuristic algorithms including the stochastic local search [6, 17, 14, 16, 2–4]. Exact approaches guarantee the optimality, but cost exponential time in the worst case and thus fail J. Chen, J.E. Hopcroft, and J. Wang (Eds.): FAW 2014, LNCS 8497, pp. 71–81, 2014. c Springer International Publishing Switzerland 2014

72

Z. Fang et al.

to give solutions for large instances within reasonable time. Although heuristic approaches cannot guarantee the optimality, they can provide solutions which are optimal or near-optimal. Therefore, stochastic local search algorithms are frequently used to solve large and hard MVC (MC, MIS) instances in practice. Typically, stochastic local search algorithms solve the MVC problem by searching a vertex cover of size k iteratively. To solve the k-vertex cover problem, i.e., finding a vertex cover of size k, one starts from a subset of vertices with size k and then swaps two vertices until a vertex cover is obtained, where swap means to remove a vertex from the subset and add a vertex outside into it without changing its size. How to escape from the local optimal solution is a challenging problem in local search. Constraint weighting, which is first used in the satisfiability (SAT) problem and the constraint satisfaction problem (CSP) [12, 8, 18] and then introduced to the MVC problem, is a powerful technique to refrain from being stuck at a local optimal point. The edge weighting scheme and the vertex weighting scheme have been applied separately by different MVC solvers. COVER [17] introduces the edge weight to MVC for the first time. It is an iterative best improvement algorithm and updates the edge weight at each step. EWLS [2] also uses the edge weight. However, it is iterated local search and updates the edge weight only in the case of being stuck at local optimal points. EWCC [3] improves EWLS by combining the edge weight and configuration checking. NuMVC [4] introduces the forgetting technique, which allows one to decrease the weight of edges when necessary. Besides, it uses a more effective two-stage exchange strategy to achieve state-of-the-art performance. To the best of our knowledge, NuMVC is the dominating local search algorithm for MVC on the BHOSLIB benchmark. Dynamic Local Search (DLS) [14] is designed to solve the MC problem first. DLS alternates between phases of the iterative improvement and the plateau search. During the iterative improvement phase, suitable vertices are added to the current clique. While during the plateau search phase, vertices in the current clique are swapped with vertices outside. Which vertex to add or remove is guided by vertex penalties, which can be regarded as a vertex weighting scheme. Its improved version named the Phased Local Search (PLS) algorithm [15] has no instance-dependent parameters and performs well for the MC problem over a large range of DIMACS instances. Its author extends PLS algorithm to MIS and MVC problems [16]. To our best knowledge, PLS achieves the best performance on most instances from the DIMACS benchmark. As mentioned above, none of algorithms dominates all others over different kinds of benchmarks. For example, PLS achieves a better performance on Brock* instances than NuMVC and is competitive with NuMVC on most instances from the DIMACS benchmark, while NuMVC is the dominating algorithm on the BHOSLIB benchmark. The different weighting schemes are the main reason for their different performance. Taking advantages of the techniques used in other algorithms allows one to achieve a better performance. In this paper, we combine the edge weight with the vertex weight and propose a new local search algorithm named VEWLS for MVC. To our best knowledge, it is the first time that both the

Combining Edge Weight and Vertex Weight for MVC Problem

73

edge weight and the vertex weight are used together in one solver. Experimental results over widely used DIMACS and BHOSLIB benchmarks show that VEWLS is competitive with NuMVC and outperforms it on most instances from both benchmarks. The remainder of the paper is organized as follows. In the next section, we introduce some necessary background knowledge. Then we describe the VEWLS algorithm in Section 3. Experimental results are presented in Section 4. Finally, we conclude our main contributions and propose some directions for future work.

2

Preliminaries

An undirected graph G = (V, E) comprises a set V ={v1 , v2 , ..., vn } of n vertices together with a set E of m edges, where each edge e = {u, v} has two endpoints, namely u and v. The set of neighbor vertices of a vertex v is denoted by N (v) = {u|{u, v} ∈ E} and |N (v)| is the degree of v. A vertex cover of G is a subset V ⊆ V such that every edge {u, v} has at least one endpoint (u or v or both) in V and the vertex cover with k vertices is a k-vertex cover. The Minimum Vertex Cover (MVC) problem calls for finding a vertex cover of the smallest possible size. Note that more than one minimum vertex covers may exist in a graph. Local search algorithms for MVC always maintain a partial vertex cover, where a partial vertex cover is defined as a subset P ⊆ V , which covers a subset E ⊆ E and an edge is covered by P if at least one endpoint of the edge is contained in P. The MVC problem is equivalent to two other important optimization problems: the Maximum Independent Set (MIS) problem and the Maximum Clique (MC) problem. If V is a vertex cover of G, then V \ V is an independent set of G as well as a clique in the complement graph of G. Therefore, algorithms for any of the three problems can be used to solve the others in practice. MVC is NP-hard and its associated decision problem is NP-complete. Therefore, there will be no polynomial algorithms for MVC unless P = N P . Moreover, Dinur and Safra prove that the MVC problem cannot be approximated with a factor of 1.3606 for any sufficiently large vertex degree unless P = N P [5] and it cannot even be approximated within any constant factor better than 2 if the unique games conjecture is true [9]. Therefore, one usually wants to resort to heuristic methods to solve large and hard instances. Constraint weighting is a powerful technique in local search algorithms, which is widely used in SAT [12, 8, 18] and then applied to MVC by state-of-the-art local search algorithms, such as Cover [13], PLS [15, 16], EWLS [2], EWCC [3] and NuMVC [4]. Generally, two types of weighting schemes have been used for MVC. One is the vertex weighting scheme, where each vertex is associated with a non-negative weight and the other is the edge weighting scheme, where every edge has a non-negative weight. As both schemes are used in this paper, we would like to give a brief introduction of the vertex weight and the edge weight before we describe our algorithm. The state-of-the-art algorithm for MVC based on the vertex weighting scheme is PLS [15, 16], which is an improved version of DLS [14]. DLS is a dynamic local

74

Z. Fang et al.

search algorithm for MC and it refers to the vertex weight as the vertex penalty. DLS alternates between the iterative improvement phase and the plateau search phase with vertex penalties which are updated dynamically during the search. The iterative improvement phase starts with a clique consisting of a randomly selected vertex and successively extends the clique by adding vertices connected to all vertices in the clique. When the clique cannot be extended, i.e., a maximal clique is found, the plateau search starts. The plateau search phase tries to find a vertex v that is adjacent to all but one of the vertices in the current clique then swaps the vertex v with the only vertex in the clique that is not connected to v. A new clique with the same size as the old one is obtained after the plateau search phase, which makes further extension of the current possible solution. Which vertex to add or remove is an essential problem in the algorithm. In DLS, vertices are selected based on their vertex penalties. The vertex penalty works as follows: Every vertex has a vertex penalty with an initial value of zero at the beginning. Vertex penalties are updated by increasing the penalty values of all vertices in the current clique by one at the end of the plateau search phase. DLS chooses the vertex with the minimum penalty to add or remove, and choses uniformly at random if more than one such vertex exists. The selected vertex becomes unavailable for subsequent selections until penalties have been updated and perturbations have been performed. The purpose of vertex penalties is to prevent the search process from repeatedly visiting the same search space. A single control parameter named penalty delay, which depends on the input instance, is used to avoid vertex penalties getting too large. Fortunately, its improved version, PLS [14], has no instance-dependent parameters and achieves the state-of-the-art performance over a large range of instances from the DIMACS benchmark when it is extended for MVC and MIS by its author [16]. On the other hand, Cover, EWLS, EWCC and NuMVC use the edge weighting scheme. An edge weighted graph is a graph G = (V, E) combined with a weight function w : E → R+ such that each edge e is associated with a positive value w(e) as its weight. Given a graph G = (V, E) and a partial vertex cover P of G, let w be the edge weight function for G, the cost of P is defined as follows. Definition 1 cost(G, P ) =

w(e).

e∈E and e not covered by P

cost(G, P ) indicates the total weight of edges uncovered by P and P becomes a vertex cover when its cost equals 0. EWLS, EWCC and NuMVC all prefer to maintain a partial vertex cover with lower cost. To distinguish vertices by edge weight, decreasing score(dscore) is calculated for each vertex v as follows. Definition 2 dscore(v) =

cost(G, P ) − cost(G, P \ {v}) cost(G, P ) − cost(G, P ∪ {v})

if v ∈ P if v ∈ P


75

EWCC and NuMVC select vertices depending on their dscore. It is obvious that dscore(v) ≤ 0 if v is in P and the greater dscore(v) is, the less loss to remove v out of P is. In contrast, dscore(v) ≥ 0 if v is not in P and the greater dscore(v) means the more gain to add v into P .

3

VEWLS: A New Algorithm for MVC

The pseudocode of VEWLS is presented in Algorithm 1. We introduce how to use the edge weight and the vertex weight as well as how to update both weights. Then we describe how VEWLS works. The operation select add vertex selects a vertex with the highest dscore and breaks ties with a smaller timestamp to add, where the timestamp of v is the time when it is added into the partial vertex cover most recently. To remove a vertex, select remove vertex only considers vertices with confChange values equaling 1 and selects a vertex with the highest dscore and breaks ties with a smaller timestamp. confChange is defined for configuration checking, which is proposed in EWCC [3] to handle the cycle problem in local search. As shown in line 18, the value of confChange[u] is set to 1 when the state of its neighbours changes. Please note that the vertex to add always has a positive dscore while the vertex to remove has a negative dscore. To reconstruct a vertex cover, VEWLS prefers to select a vertex with higher dscore and breaks ties in favor of a smaller penalty. The weight of each uncovered edge increases by 1 after each swap. To avoid the edge weight getting too large, we make use of the forgetting technique in [4]. The edge weight should be decreased by a coefficient ρ when the average of edge weights exceeds a threshold γ. In VEWLS, we set γ = |V |/2 and ρ = 0.3, where |V | is the number of vertices. Let P be the current partial vertex cover and best be the best solution found so far. The penalty of each vertex in P should be increased by 1 when a better solution is found or a solution as good as best is found. We use at most one edge being uncovered by P as the condition for increasing vertex penalties, because P has one vertex less than best, P will become a better solution if all edges are covered and when only one edge is uncovered by P , P ∪ {v}, where v covers the only uncovered edge, will become a vertex cover with the same size as best. VEWLS works as follows: It starts with an initial vertex cover which is constructed by selecting a vertex covering more edges greedily. In VEWLS, the initial a vertex cover is constructed by adding the vertex to cover as many edges as possible each time iteratively. When a vertex cover of size k is found, it tries to find a solution with k − 1 vertices by removing a vertex from the current solution and swapping a pair of vertices until the partial vertex cover becomes a vertex cover. The edge weights will increase after each swap so that VEWLS restarts when the average value of weights exceeds the threshold. To restart, VEWLS makes use of both the edge weight and the vertex penalty to reconstruct a new vertex cover.

76

Z. Fang et al.

Algorithm 1. VEWLS(G, cutoff ), a new local search algorithm for MVC

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 29 30 31 32

33

Input: An undirected graph G=(V, E) and cutoff time cutof f Output: Vertex cover with the smallest size found so far begin construct a vertex cover P greedily best ← P foreach e ∈ E do weight[e] ← 1 foreach v ∈ V do penalty[v] ← 0 compute dscore[v] by Definition 2 confChange[v] ← 1 timestamp[v] ← 0 while not reach cutoff time do while P is a vertex cover do best ← P v ← select remove vertex(dscore, timestamp) remove v from P v1 ← select remove vertex(dscore, timestamp) foreach u in N(v1 ) do confChange[v] ← 1 v2 ← select add vertex(dscore, timestamp,confChange) swap v1 and v2 update timestamp[v2 ] foreach e = {v, u} is uncovered do weight[e] ← weight[e] + 1 update dscore[v] and dscore[u] by Definition 2 if number of uncovered edge is less than 1 then foreach vertex v in P do penalty[v] ← penalty[v]+1 if average edge weight ≥ threshold then foreach edge e = {u, v} do weight[e] ← ϕ× weight[e] update dscore[u] and dscore[v] reconstruct P greedily by dscore and break tie in favor of smaller penalty return best


77

The difference between VEWLS and NuMVC is that VEWLS adds the restart phase by making use of the vertex penalty. In fact, restart is an effective technique, which has been widely used in local search algorithms for SAT and CSP [7, 1]. Experiments, presented in next section, show that it allows one to improve the performance of NuMVC on a huge range of instances.

4

Empirical Evaluation

We evaluate the performance of VEWLS on standard benchmarks for the MVC (MIS, MC) problem, namely the DIMACS1 benchmark and the BHOSLIB (Benchmarks with Hidden Optimum Solutions)2 benchmark. We compare VEWLS with NuMVC, which dominates other algorithms, such as Cover, EWLS and EWCC [4]. In addition, NuMVC is the best local algorithm for MVC on the BHOSLIB benchmark. Table 1. Comparing VEWLS with NuMVC over the DIMACS benchmark Instance Graph brocks400 2 brocks400 4 DSJC1000.5.mis keller6 p hat1500-1 MANN a45 MANN a81 C1000.9 C2000.5 C2000.9 C4000.5

NuMVC VEWLS MVC Suc(%) Time(s) Step Suc(%) Time(s) Step 371 38 329.26 159323577 44 188.88 93389005 367 100 15.65 7653271 100 15.67 7706357 985 100 1.10 142883 100 1.04 135109 3302 100 7.49 399533 100 7.30 390686 1488 100 9.26 449552 100 8.02 387999 690 96 180.88 78768223 92 163.86 70856196 2221 4 325.64 49751930 4 310.73 46898081 932 100 3.73 1194201 100 3.74 1238411 1984 100 6.02 271050 100 5.65 243584 1921 14 228.06 37797183 20 204.19 33686264 3982 76 267.27 4471005 76 261.86 4168885

The DIMACS benchmark is taken from the Second DIMACS Implementation Challenge for the Maximum Clique problem (1992-1993). The 80 DIMACS instances are generated from real-world problems in coding theory, fault diagnosis problems, Kellers conjecture and the Steiner triple problem, in addition to randomly generated graphs and graphs where the maximum clique has been hidden by incorporating low-degree vertices. These instances range in size from less than 50 vertices and 1000 edges to greater than 3300 vertices and 5,000,000 edges. The BHOSLIB benchmark is a suit of hard random instances based on the CSP model RB [21, 22]. BHOSLIB instances are much harder than most DIMACS instances as well as an optimum solution can be hidden in the instance without reducing the difficulty to solve it. The BHOSLIB benchmark has been widely used to evaluate the performance algorithms for SAT, CSP, MC and MVC. We use 40 instances with the size from 450 vertices to 1534 vertices. 1 2

ftp://dimacs.rutgers.edu/pub/challenges http://www.nlsde.buaa.edu.cn/~ kexu/benchmarks/graph-benchmarks.htm

78

Z. Fang et al.

Table 2. Comparing VEWLS with NuMVC over the BHOSLIB benchmark Instance NuMVC VEWLS Graph MVC Suc(%) Time(s) Step Suc(%) Time(s) Step frb30-15-1 420 100 0.08 35996 100 0.07 33943 frb30-15-2 420 100 0.10 49871 100 0.09 45558 frb30-15-3 420 100 0.33 167344 100 0.30 151613 frb30-15-4 420 100 0.09 45425 100 0.09 42820 frb30-15-5 420 100 0.18 89159 100 0.20 98466 frb35-17-1 560 100 1.04 447412 100 1.05 450567 frb35-17-2 560 100 0.90 384553 100 0.87 372007 frb35-17-3 560 100 0.31 129988 100 0.32 134120 frb35-17-4 560 100 0.94 402533 100 0.89 378461 frb35-17-5 560 100 0.46 194745 100 0.46 195662 frb40-19-1 720 100 0.54 195147 100 0.62 218655 frb40-19-2 720 100 8.57 3138719 100 10.04 3685558 frb40-19-3 720 100 2.39 875947 100 2.30 842605 frb40-19-4 720 100 8.93 3279988 100 8.42 3071682 frb40-19-5 720 100 24.19 8901977 100 22.72 8293541 frb45-21-1 900 100 8.91 2738077 100 7.96 2425589 frb45-21-2 900 100 13.14 4072965 100 12.91 3981183 frb45-21-3 900 100 39.08 12186665 100 33.00 10251540 frb45-21-4 900 100 7.90 2462682 100 9.71 2981122 frb45-21-5 900 100 20.95 6498414 100 20.87 6446523 frb50-23-1 1100 90 199.19 17243802 96 204.68 17710399 frb50-23-2 1100 34 273.38 23286406 28 291.15 24955502 frb50-23-3 1100 18 261.92 22275787 20 375.30 32788511 frb50-23-4 1100 100 66.91 5661385 100 64.43 5489741 frb50-23-5 1100 100 139.89 12055015 100 136.15 11845047 frb53-24-1 1219 16 383.00 93946856 10 166.47 41231273 frb53-24-2 1219 76 199.59 48531856 62 221.86 53881695 frb53-24-3 1219 100 123.72 30025024 100 111.85 27162736 frb53-24-4 1219 44 216.97 52832600 64 257.66 62427079 frb53-24-5 1219 100 117.16 28768079 100 97.66 23565609 frb56-25-1 1344 40 226.26 52569948 54 298.45 68745658 frb56-25-2 1344 28 331.97 76976027 30 254.53 58653134 frb56-25-3 1344 90 217.31 49723429 80 195.66 45068725 frb56-25-4 1344 100 97.29 22183589 100 86.90 19958391 frb56-25-5 1344 100 71.11 16264565 100 59.89 13642697 frb59-26-1 1475 8 345.38 22837670 4 183.20 12145443 frb59-26-2 1475 2 538.61 35519067 6 574.01 38090645 frb59-26-3 1475 16 338.09 22679122 10 231.79 15455807 frb59-26-4 1475 4 334.04 22197811 8 224.94 14965750 frb59-26-5 1475 36 166.06 11012989 74 210.58 13957374


79

VEWLS is implemented in C++. We obtain the source code of NuMVC from one of its authors. Both solvers are compiled by g++ with ”-O2” option. All experiments are running on the machine with Intel Xeon CPU E5405 @ 2.00GHz and 8GB RAM under CestOS 5.7. The cutoff time for each instance is 600s (10mins) and we set γ = |V |/2 and ρ = 0.3 for all experiments. We run each instance for 50 times independently. We consider the best solution(s) found during 50 runnings as the minimum vertex cover for the instance and the size of the best solution is denoted by MVC in Table 1 and Table 2. A run is considered successful when it gives the same size as the best solution. The Success Rate (Suc for short) is computed as T /50 ∗ 100%, where T is the number of successful runs. Time (in seconds) and Step is the average time and the average steps of all successful runs, respectively. To compare the performance of solvers, we compare Success Rate first, then compare Time if Success Rates are the same and compare Step at last. Table 1 shows the results on the DIMACS benchmark. All 80 instances are used in our experiments and we do not display the instances solved by both solvers within 1s or instances solved by neither of solvers within the cutoff time. VEWLS outperforms NuMVC on 8 instances out of 11. VEWLS improves the success rate with less time consumption on brocks400 2 and C2000.9 and it cuts down the time and steps on other 6 instances. VEWLS performs extremely close to NuMVC on brocks400 4 and C1000.9. On the other hand, NuMVC performs much better than VEWLS does only on MANN a45. Table 2 presents the performance of VEWLS and NuMVC on the BHOSLIB benchmark. It shows that VEWLS outperforms NuMVC on 27 instances out of 40. For the 20 hard instances with size larger than 50*23, VEWLS improves the success rates for 8 instances of them and reduces time consumptions for all instances on which VEWLS shares the same success rate with NuMVC. Based on the empirical evaluation, we can conclude that integrating the vertex penalty into NuMVC can improve its performance on both DIMACS and BHOSLIB benchmarks. Combining the vertex weight and the edge weight takes advantages of both weighting schemes, which allows one to obtain a more effective local search algorithm for MVC.

5

Conclusion and Future Work

We present a new local search algorithm for the MVC problem, namely VEWLS, which combines the vertex weight and the edge weight. We evaluate the performance of VEWLS on both DIMACS and BHOSLIB benchmarks and compare it with NuMVC, which is the state-of-the-art local search algorithm for MVC and the dominating solver on the BHOSLIB benchmark. Experimental results show that VEWLS outperforms NuMVC on most instances from both benchmarks. To our best knowledge, it is the first time to combine the vertex weighting scheme and the edge weighting scheme for the MVC problem and it allows one to improve the performance of the best algorithm. However, the method to integrate

80

Z. Fang et al.

two weights used in our paper is quite simple and we believe that the combination can be much more powerful. How to combine them more tightly and take more advantages of both weighting schemes will be part of our future work. Acknowledgment. We would like to thank Jichang Zhao, Ge Zheng and anonymous reviewers for their helpful comments and suggestions. This research was partly supported by the fund of SKLSDE (Grant No. SKLSDE-2013ZX-06), and Research Fund for the Doctoral Program of Higher Education of China (Grant No. 20111102110019).

References 1. Biere, A.: Adaptive restart strategies for conflict driven SAT solvers. In: Kleine B¨ uning, H., Zhao, X. (eds.) SAT 2008. LNCS, vol. 4996, pp. 28–33. Springer, Heidelberg (2008) 2. Cai, S., Su, K., Chen, Q.: EWLS: A New Local Search for Minimum Vertex Cover. Proc. of AAAI-2010, pp. 45–50 (2010) 3. Cai, S., Su, K., Sattar, A.: Local search with edge weighting and configuration checking heuristics for minimum vertex cover. Artif. Intell. 175(9-10), 1672–1696 (2011) 4. Cai, S., Su, K., Luo, C., Sattar, A.: NuMVC: An Efficient Local Search Algorithm for Minimum Vertex Cover. J. Artif. Intell. Res., 687–716 (2013) 5. Dinur, I., Safra, S.: On the hardness of approximating minimum vertex cover. Ann. of Math. 162(1) (2005) 6. Evans, I.: An evolutionary heuristic for the minimum vertex cover problem. In: Proc. of EP 1998, pp. 377–386 (1998) 7. Gomes, C., Selman, B., Kautz, H.: Boosting Combinatorial Search Through Randomization. In: Proc. of AAAI 1998, pp. 431–438 (1998) 8. Hutter, F., Tompkins, D.A.D., Hoos, H.H.: Scaling and probabilistic smoothing: Efficient dynamic local search for SAT. In: Van Hentenryck, P. (ed.) CP 2002. LNCS, vol. 2470, pp. 233–248. Springer, Heidelberg (2002) 9. Khot, S.: On the power of unique 2-Prover 1-Round games. In: Proc. 34th ACM Symp. on Theory of Computing, STOC, pp. 767–775 (May 2002) 10. Li, C., Quan, Z.: An efficient branch-and-bound algorithm based on maxsat for the maximum clique problem. In: Proc. of AAAI 2010, pp. 128–133 (2010) 11. Li, C., Fang, Z., Xu, K.: Combining maxsat reasoning and incremental upper bound for the maximum clique problem. In: Proc. of ICTAI 2013, pp. 939–946 (2013) 12. Morris, P.: The breakout method for escaping from local minima. In: Proc. of AAAI 1993, pp. 40–45 (1993) 13. Ostergard, P.R.J.: A fast algorithm for the maximum clique problem. Discrete Applied Mathematics 120, 197–207 (2002) 14. Pullan, W., Hoos, H.H.: Dynamic local search for the maximum clique problem. J. Artif. Intell. Res (JAIR), 159–185 (2006) 15. Pullan, W.: Phased local search for the maximum clique problem. J. Comb. Optim 12(3), 303–323 (2006) 16. Pullan, W.: Optimisation of unweighted/weighted maximum independent sets and minimum vertex covers. Discrete Optimization 6, 214–219 (2009)


81

17. Richter, S., Helmert, M., Gretton, C.: A stochastic local search approach to vertex cover. In: Hertzberg, J., Beetz, M., Englert, R. (eds.) KI 2007. LNCS (LNAI), vol. 4667, pp. 412–426. Springer, Heidelberg (2007) 18. Thornton, J.: Clause weighting local search for sat. J. Autom.Reasoning 35(1-3), 97–142 (2005) 19. Tomita, E., Kameda, T.: An Efficient Branch-and-bound Algorithm for Finding a Maximum Clique with Computational Experiments. Journal of Global Optimization 37, 95–111 (2007) 20. Tomita, E., Seki, T.: An Efficient Branch-and-Bound Algorithm for Finding a Maximum Clique. In: Calude, C.S., Dinneen, M.J., Vajnovszki, V. (eds.) DMTCS 2003. LNCS, vol. 2731, pp. 278–289. Springer, Heidelberg (2003) 21. Xu, K., Li, W.: Exact phase transitions in random constraint satisfaction problems. J. Artif. Intell. Res (JAIR) 12, 93–103 (2000) 22. Xu, K., Boussemart, F., Hemery, F., Lecoutre, C.: Random constraint satisfaction: Easy generation of hard (satisfiable) instances. Artif. Intell. 171(8-9), 514–534 (2007)