1491

Approximation and Parameterized Runtime Analysis of Evolutionary Algorithms for the Maximum Cut Problem Yuren Zhou, Xinsheng Lai, and Kangshun Li

Abstract—The maximum cut (MAX-CUT) problem is to find a bipartition of the vertices in a given graph such that the number of edges with ends in different sets reaches the largest. Though, several experimental investigations have shown that evolutionary algorithms (EAs) are efficient for this NP-complete problem, there is little theoretical work about EAs on the problem. In this paper, we theoretically investigate the performance of EAs on the MAX-CUT problem. We find that both the (1+1) EA and the (1+1) EA*, two simple EAs, efficiently achieve approximation √ solutions of (m/2) + (1/4)s(G) and (m/2) + (1/2)( 8m + 1 − 1), where m and s(G) are respectively the number of edges and the number of odd degree vertices in the input graph. We also reveal that for a given integer k the (1+1) EA* finds a cut of size at least k in expected runtime O(nm + 1/δ 4k ) and a cut of size at least 2 (m/2) + k in expected runtime O(n2 m + 1/δ (64/3)k ), where δ is a constant mutation probability and n is the number of vertices in the input graph. Finally, we show that the (1+1) EA and the (1+1) EA* are better than some local search algorithms in one instance, and we also show that these two simple EAs may not be efficient in another instance. Index Terms—Approximation performance, evolutionary algorithm (EA), local search, maximum cut (MAX-CUT) problem, runtime analysis.

I. I NTRODUCTION HE maximum cut (MAX-CUT) problem is a classic combinatorial optimization problem, and listed in Karp’s 21 NP-complete problems [1], [2]. It aims to decide a subset of the vertex set of a given graph such that the total weight of the edges between this subset and the complementary subset reaches possibly largest. When all edges of the input graph weight to be one, i.e., the input graph is unweighted, the MAX-CUT problem becomes to find a bipartition of the vertex set such that the number of edges crossing the bipartition is as large as possible.

T

Manuscript received March 16, 2014; revised June 14, 2014 and August 24, 2014; accepted August 26, 2014. Date of publication September 12, 2014; date of current version July 15, 2015. This work was supported by the National Natural Science Foundation of China under Grant 61170081, Grant 61472143, and Grant 61165003. This paper was recommended by Associate Editor Y. Jin. Y. Zhou is with the School of Computer Science and Engineering, South China University of Technology, Guangzhou 510006, China (e-mail: [email protected]). X. Lai is with the School of Computer Science and Engineering, South China University of Technology, Guangzhou 510006, China, and also with the School of Mathematics and Computer Science, Shangrao Normal University, Shangrao 334001, China. K. Li is with the School of Information, South China Agricultural University, Guangzhou 510642, China. Digital Object Identifier 10.1109/TCYB.2014.2354343

Besides the theoretical importance of the MAX-CUT problem, it has applications in statistic physics and circuit layout design [3], [4]. Due to its theoretical and practical importance, many researchers paid attention to find algorithms for the MAX-CUT problem. Gramm et al. [5] proposed an exact algorithm which transforms an instance of the MAX-CUT problem into an instance of the MAX-2-SAT problem, and then solves this MAX-2-SAT instance. They proved that the bound of this algorithm is poly(|E|) · 2|E|/3 , where poly(|E|) represents a polynomial of |E|, and |E| is the number of edges in the input graph. Kulikov and Fedin [6] presented another exact algorithm for the MAX-CUT problem and improved this bound to poly(|E|) · 2|E|/4 . So far, it seems unlikely to find polynomial time algorithms for NP-complete combinatorial optimization problems, and the MAX-CUT problem belongs to the class of NP-complete problems, therefore approximation algorithms attract the interests from researchers. Sahni and Gonzales [7] presented an approximation algorithm for the MAX-CUT problem which delivers a solution of value at least (1/2)OPT, where OPT is the number of edges crossing the MAX-CUT. Poljak and Turzík [8] proved that there exists an algorithm which can find a solution of the MAX-CUT problem with value at least (m/2) + (n − 1)/4 in runtime O(n3 ), where m and n are respectively the number of edges and the number of vertices in the input graph. Haglin and Venkatesan [9] proposed an approximation algorithm for the MAX-CUT problem which can efficiently find a cut of (m/2) + (m/(2n)) edges. Hofmeister and Lefmann [10] proved that if the maximum degree of the input graph is odd, then there is an algorithm for the MAX-CUT problem which efficiently computes a bipartition of size (m/2)(1 + (1/)). The first substantial progress in approximating the MAX-CUT problem was made by Goemans and Williamson [11]. They presented a randomized approximation algorithm which delivers a solution for the MAX-CUT problem with expected value at least 0.87856 times the number of edges crossing the MAX-CUT. In addition, many empirical investigations have shown that metaheuristic algorithms such as evolutionary algorithms (EAs) [12], [13], simulated annealing [14], and ant colony optimization algorithms [15] are successful alternatives to the MAX-CUT problem. However, we theoretically know nothing about the performance of these metaheuristics on the MAX-CUT problem.

c 2014 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. 2168-2267 See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.

1492

In recent years, the theoretical understanding of the performance of metaheuristics on combinatorial optimization problems has attracted great attentions from researchers. Some theoretical results, mainly focusing on EAs, have been obtained through their continuous efforts. The early work mainly analyzed the performance of EAs on pseudo-Boolean functions [16]–[19]. Then the analysis was extended to the real-world combinatorial optimization problems in P class, such as sorting and shortest paths problems [20], the maximum matching problem [21], the minimum spanning tree problem [22], and the single source shortest path problem [23]. For the combinatorial optimization problems belonging to the NP-complete class, one is interested in the approximation performance of EAs. Witt [24] investigated the approximation performance guarantee of a simple EA on the partition problem. He discovered that the (1+1) EA creates a 4/3-approximation solution in expected runtime O(n2 ). Friedrich et al. [25] revealed that the single-objective and multiobjective models of EAs have different approximation abilities on covering problems. Neumann and Reichel [26] discovered that given a set of k terminal pairs the multiobjective EA obtains a k-approximation solution for the minimum multicut problem. Yu et al. [27] investigated the approximation performance of a simple EA with isolated population (SEIP) on the set cover problem. They found that SEIP can efficiently find Hn - and (Hk − (k − 1)/(8k9 ))-approximation solutions for the unbounded and k-set cover problems, respectively. The graph bisection problem (GBP) is NP-hard, which is similar to the MAX-CUT problem. It is to partition the vertices of an undirected graph with even number of vertices into two sets having equal sizes, such that the number of edges whose ends in different sets is minimal. Greiner [28] proposed two classes of GBP instances and showed that on each class one of the (1+1) EA and the multiobjective EA is efficient while the other needs expected exponential optimization runtime. The parameterized analysis, which aims at disclosing the core of the hardness as a parameter of the problem rather than the problem size, has recently been introduced into theoretical work on EAs. The parameterized runtime of EAs has been analyzed on the maximum leaf spanning tree problem [29], the makespan scheduling problem [30], the MAX-2-SAT problem [31], the Euclidean traveling salesperson problem [32], and the vertex cover problem [33]. However, as Sutton and Neumann [30] said, it is still a challenging task to theoretically understand the behavior of EAs on NP-complete combinatorial optimization problems. In this paper, we contribute to theoretically analyze the performance of EAs on the MAX-CUT problem. We find that the (1+1) EA and the (1+1) EA* can efficiently achieve some performance guarantees. We then show that the (1+1) EA* is a randomized fixed-parameter tractable algorithm for the MAX-CUT problem, and also for the above guarantee MAX-CUT problem. Finally, we show that the (1+1) EA and the (1+1) EA* are superior to local search algorithm on an instance of the MAX-CUT problem, and we also show that these two simple EAs may be inefficient on another instance.

IEEE TRANSACTIONS ON CYBERNETICS, VOL. 45, NO. 8, AUGUST 2015

Algorithm 1 (1+1) EA 1: Begin 2: Initialization: Choose randomly an initial bit string X from search space {0, 1}n ; 3: While (the maximum cut is not found) do 4: Mutation: Create X by flipping each bit xi of X with probability 1/n; 5: Selection: Replace X by X iff fit(X ) > fit(X); 6: End while 7: End

The remainder of this paper is organized as follows. Section II describes the MAX-CUT problem and the algorithms discussed in this paper. Section III investigates the approximation performance of the (1+1) EA and the (1+1) EA* for the MAX-CUT problem, and Section IV analyzes the parameterized runtime of the (1+1) EA* for the MAX-CUT problem. Section V is the runtime complexity analysis of the (1+1) EA and the (1+1) EA* on two instances. Finally, Section VI presents the conclusion. II. P ROBLEM AND A LGORITHMS The MAX-CUT problem is one of the most fundamental graph partitioning problems. Let G = (V, E) be an undirected graph that has no loops and no multiple edges, with vertex set V and with nonempty edge set E. A cut is defined as a partition of the vertex set V into two disjoint subsets S and S : =V \ S, and the term cut also refers to the bipartition (S, S). We denote by E(S, S) the set of edges with one vertex in S and the other in S. The MAX-CUT problem is to find a cut (S, S) that maximizes |E(S, S)|, where |E(S, S)| denotes the cardinality of set E(S, S). Let V = {v1 , . . ., vn }. We use a bit string X = (x1 , . . . , xn ) ∈ {0, 1}n to represent the cut (S, S) where each bit xi of X corresponds to vertex vi ∈ V. The vertex vi is chosen in S if xi = 1 and otherwise it is chosen in S. We denote by S(X) the set of vertices whose corresponding bits in X are set to 1, and by S(X) the set of vertices whose corresponding bits in X are set to 0. Then the objective or fitness function of the MAX-CUT problem is given by fit(X) = |E(S(X), S(X))|. Assume that fit : {0, 1}n → R is the objective or fitness function to be maximized. Algorithm 1 describes a simple EA containing one individual, which employs mutation without crossover operator. We call this simple EA the (1+1) EA in this paper. As described in Algorithm 1, the criterion of the (1+1) EA for accepting a new solution is that its fitness value is strictly higher than that of the current one. Another criterion for accepting a new solution is that the fitness value of this new solution is not lower than that of the current one. Jansen and Wegener [17] showed that the criterion for accepting a new solution has important effect on the behavior of this simple EA for plateaus of constant fitness. Dong et al. [34] presented a hybrid strategy evolutionary programming algorithm using four different mutation operators. Their experimental results showed that the hybrid strategy performs as well as or better than the best of the four

ZHOU et al.: APPROXIMATION AND PARAMETERIZED RUNTIME ANALYSIS OF EAs FOR THE MAX-CUT PROBLEM

Algorithm 2 (1+1) EA* 1: Begin 2: Initialization: Choose randomly an initial bit string X from search space {0, 1}n ; 3: While (the maximum cut is not found) do 4: Mutation: With probability 1/2, create X by flipping each bit xi of X with probability 1/n; With probability 1/2, create X by flipping each bit xi of X with constant probability δ (0 < δ < 1/2); 5: Selection: Replace X by X iff f (X ) > f (X). 6: End while 7: End

pure strategies does. He et al. [35] also showed that a hybrid strategy may outperform a pure strategy. To carry out the parameterized analysis of EAs for the MAX-CUT problem, we design a simple EA employing a hybrid mutation strategy. This simple EA is called the (1+1) EA* in this paper. As described in Algorithm 2, the (1+1) EA* flips each bit of a string with a hybrid strategy that combines mutation probability 1/n with a small constant mutation probability δ. Clearly, the (1+1) EA* differs from the (1+1) EA only in the mutation operator. For completeness, we describe a random local search that will be used in this paper. It has been proven that RLS can find a cut of the size not less than 1/2 times the size of the MAX-CUT, and an instance was used to show that RLS may perform very poorly [36]. III. A PPROXIMATION P ERFORMANCE OF THE (1+1) EA AND THE (1+1) EA* FOR THE MAX-CUT P ROBLEM Local search algorithms are usually iterative improvement algorithms. At each iteration, a local search algorithm tries to improve the current solution by searching in the neighborhood of the current solution. Neighborhood for the MAX-CUT problem is defined by switching locations of vertices in a subset W ⊂ V related to a given bipartition (S, S). It changes bipartition (S, S) to a new bipartition (S , S ) : = (SW, SW), where denotes the symmetric difference of sets. In order to analyze the approximation performance of EAs for the MAX-CUT problem, we have to describe two more local search algorithms in this section, which are among the local switching algorithms for the MAX-CUT problem presented by Bylka et al. [37]. We now briefly recall some notations and techniques introduced by them. Given a graph G = (V, E), for any two (not necessarily disjoint) subsets Z, T ∈ V, we denote by E(Z, T) the set of edges with one vertex in Z and the other in T, and denote d(Z, T) = |E(Z, T)|. For Z = {v}, v ∈ V, we simply write d(v, T) instead of d({v}, T), i.e., d(v, T) represents the number of all edges from v to T. For a bipartition (S, S) of V, we define the weight function of the vertex v with respect to bipartition (S, S) as d(v, S) − d(v, S), if v ∈ S μ(v, S, S) = d(v, S) − d(v, S), if v ∈ S.

1493

Algorithm 3 Random Local Search (RLS) Initialization: Initialize an arbitrary cut (S, S); While (∃v ∈ V such that moving it from its own side to the other improves the cut) do 3: If v ∈ S then S ← S \ {v}, else S ← S ∪ {v}; 4: End while Output: the cut (S, S). 1: 2:

Algorithm 4 Local Search Algorithm With S1 -Switch Neighborhood 1: 2: 3: 4: 5: 6: 7: 8:

Initial an arbitrary bipartition (S, S); Compute the function μ(v, S, S) and find the set of switching S1 (S, S); If S1 (S, S) = ∅ then Select an element W ∈ S1 (S, S); (S, S): =(SW, SW); Goto step 2; End if Output the bipartition (S, S).

The measure of effectiveness of bipartition (S, S) is μ(S, S) = v∈V μ(v, S, S). It is easy to check [37] that |E| 1 + μ(S, S). (1) |E(S, S)| = 2 4 Therefore, the problem of finding the largest cut of G is equivalent to the problem of maximizing the measure μ over all bipartitions of V. Let (S, S) be a bipartition of G, W ⊂ V, |W ∩ S| ≤ 1 and |W ∩S| ≤ 1. For the new bipartition (S , S ) : = (SW, SW), according to (1), it is easy to derive that μ(S , S ) > μ(S, S) if and only if, either W = {v} and μ(v, S, S) < 0, or W = {v, w} and μ(v, S, S) + μ(w, S, S) < 2d(v, w). Based on the aforementioned arguments, Bylka et al. [37] defined the following sets of switchings: S1 (S, S) = {{v} ⊂ V|μ(v, S, S) < 0}, and S2 (S, S) = S1 (S, S) ∪ {{v, w} ∈ E(S, S)|μ(v, S, S)+μ(w, S, S) < 2}∪{{v} ⊂ S|μ(v, S, S) = 0}. They proved that local search algorithms with S1 - and S2 switch neighborhoods have performance guarantees. Local search algorithm with S1 -switch neighborhood is described in Algorithm 4. The local search algorithm with S2 -switch neighborhood can be derived from replacing S1 in Algorithm 4 with S2 . As long as there is a vertex such that moving it from its own side to the other increases the cut size, both Algorithms 3 and 4 move a vertex from its own side to the other. So, RLS is identical to the local search algorithm with S1 -switch neighborhood. The local search algorithm with S2 -switch neighborhood is different from Algorithms 3 and 4, since it tests whether the cut size can be increased by moving two vertices from their own sides to the others. These two local search algorithms have the following performance guarantees, which are proved by Bylka et al. [37]. Proposition 1: For any graph G = (V, E) with n vertices and m edges, let (A1 , B1 ) and (A2 , B2 ) be the locally optimal cuts with respect to the S1 - and S2 -switch neighborhoods,

1494

IEEE TRANSACTIONS ON CYBERNETICS, VOL. 45, NO. 8, AUGUST 2015

respectively, then the number of edges of the locally optimal cuts satisfies the following. 1) |E(A1 , B1 )| ≥ (m/2) + (1/4)s(G), where s(G) is the number of those vertices of odd √ degree. 2) |E(A2 , B2 )| ≥ (m/2) + (1/8)( 8m + 1 − 1). Now, we show that the (1+1) EA and the (1+1) EA* can achieve the same performance guarantees in expected polynomial time as the local search algorithms with S1 - and S2 -switch neighborhoods do. Theorem 1: For any graph G = (V, E), both the (1+1) EA and the (1+1) EA* can find: 1) a cut of size at least (m/2) + (1/4)s(G) in expected runtime O(nm); √ 2) a cut of size at least (m/2) + (1/8)( 8m + 1 − 1) in expected runtime O(n2 m). Proof: 1) We partition search space {0, 1}n into two disjoint sets A1 and A2 . A1 = {X ∈ {0, 1}n | fit(X) < (m/2) + (1/4)s(G)} and its complement set A2 = {X ∈ {0, 1}n | fit(X) ≥ (m/2) + (1/4)s(G)}. If the current string (solution) X belongs to A1 , according to Proposition 1 1), then there exists a vertex in (S(X), S(X)) such that moving it from its own side to the other will result in a new cut which corresponds to a new string Y, and increases the fitness value by at least one. Noting that the probability of the event that the (1+1) EA or the (1+1) EA* mutates from X to Y is (1/n), and the fitness function value is not greater than m, we conclude that after expected runtime O(nm) the (1+1) EA and the (1+1) EA* reach A2 . 2) The proof is similar to that of 1). While the (1+1) EA and the (1+1) EA* belong to a class of randomized heuristic algorithms, and the MAX-CUT problem is NP-complete, Theorem 1 shows that for the MAX-CUT problem they can efficiently achieve certain performance guarantees. Theorem 1 also shows that the (1+1) EA* can obtain the same approximation solutions as the (1+1) EA, though it uses a constant mutation probability with probability 1/2. However, Yu and Zhou [38] have proven that using a constant mutation probability is in general not a good idea. IV. PARAMETERIZED RUNTIME OF THE (1+1) EA* FOR THE MAX-CUT P ROBLEM Parameterized complexity is a measure of complexity of problems with multiple input parameters. An instance of a parameterized problem is a pair (x, k) where x is the input or the main part and k is the parameter. A parameterized problem is fixed-parameter tractable if instance (x, k) can be solved in runtime O( f (k)|x|c ) for some computable function f and a constant c, where |x| is the size of x. Typically, function f (k) is thought of as single exponential, such as 2O(k) , but the definition excludes functions of the form f (|x|, k), such as |x|k . The class of all fixed-parameter tractable problems is denoted by FPT. Niedermeier [39] gave a nice introduction to fixed-parameter algorithms. We consider the following parameterized version of the MAX-CUT problem.

A. Parameterizing MAX-CUT Input: A nonnegative integer k and a simple undirected graph G containing a MAX-CUT of at most k edges. Question: How long does an algorithm take to find the MAX-CUT? The above is an optimization version of the parameterizing MAX-CUT problem. A decision version of this problem can be found in [40]. The above problem is a well studied problem and has been shown to be fixed-parameter tractable [40]–[42]. The current best algorithm is due to Raman and Saurabh [40], who gave a deterministic algorithm solving the parameterized MAX-CUT problem in runtime O∗ (1.2418k ). We write O∗ (Ck ) for a runtime complexity of the form O(Ck · poly(|x|)), where C is a constant number, k is a parameter and |x| is the size of x. Here, we show that the (1+1) EA* is a randomized fixed-parameter tractable algorithm for the MAX-CUT problem. Theorem 2: Given a graph G = (V, E) and a nonnegative integer k, where G contains no isolated vertices and a MAXCUT of at most k edges, |V| = n and |E| = m, the (1+1) EA* can find the MAX-CUT in expected runtime O(nm + 1/δ 4k ). Proof: We distinguish two cases. Case 1: k ≤ (m/2). By Theorem 1, the MAX-CUT can be found in expected runtime O(nm). Case 2: k > (m/2). Since the input graph G has m edges, there are at most 2m vertices in G, i.e., n ≤ 2m. Further, we have n < 4k as k > (m/2). The probability for the event that the (1+1) EA* mutates from an arbitrary solution to the MAX-CUT in one step is at least (1/2)δ n . So the (1+1) EA* in expected runtime O(1/δ n ) = O(1/δ 4k ) can find the MAX-CUT of G. Since it is known that every graph G with m edges has a cut of size at least m/2 [37], [43], a more meaningful parameterized variant of the MAX-CUT problem is the above guarantee MAX-CUT problem, which can be described in the optimization version as follows. B. Above Guarantee MAX-CUT Input: A nonnegative integer k and a simple undirected graph G containing m edges and a MAX-CUT of at most m/2 + k edges. Question: How long does an algorithm take to find the MAX-CUT? For the above guarantee MAX-CUT problem, Mahajan and Raman [41] presented two deterministic FPT algorithms: one runs in O(n3 + m24k ) runtime and the 2 other runs in O(m + n + k2 2dk ) runtime, where d is a constant. For small values of k, the latter runtime bound is better. The first FPT algorithm uses the result by Poljak and Turzík [8] that a cut of size at least (m/2)+(n−1)/4 can be found in runtime n3 , and the second FPT algorithm exploits the matching construction and the sub-algorithm by Haglin and Venkatesen [9] that a cut of size at least (m/2) + (|M|/2) can be found in runtime m, where M is a matching in the graph. Now, we show that the (1+1) EA* is also a randomized FPT algorithm with runtime O(n2 m + f (k)) for the above guarantee MAX-CUT problem, where f (k) is a function of k alone.

ZHOU et al.: APPROXIMATION AND PARAMETERIZED RUNTIME ANALYSIS OF EAs FOR THE MAX-CUT PROBLEM

Theorem 3: Given a connected graph G = (V, E) and a nonnegative integer k, where G has a MAX-CUT of at most (m/2) + k edges, |V| = n and |E| = m, the (1+1) EA* can 2 find the MAX-CUT in expected runtime O(n2 m + 1/δ (64/3)k ). Proof: The proof is similar to that of Theorem 2. We consider two cases.√ √ Case 1: k ≤ ( 3/8) m. According Theorem 1 2), the MAX-CUT can be found in expected runtime O(n2 m). √ √ Case 2: k > ( 3/8) m. Since G is a connected graph, we have n ≤ m + 1, and then n < (64/3)k2 + 1. Hence the (1+1) EA* can in expected runtime 2 O(1/δ n )=O(1/δ (64/3)k ) find the MAX-CUT of G. That completes the proof. In the parameterized complexity, the running time is analyzed in finer detail: instead of expressing it as a function of the input size, a relevant parameter is introduced, and the effect of the parameter on the running time is investigated. The running time bounds in Theorems 2 and 3 show that EAs work on the MAX-CUT problem efficiently if the parameters of the input instance are small (even if the size of the input is large). V. P ERFORMANCE A NALYSIS OF THE (1+1) EA AND THE (1+1) EA* ON T WO I NSTANCES OF THE MAX-CUT P ROBLEM As mentioned before, local search algorithms start with an arbitrary initial solution, and then search the neighborhood of the current solution to find an improved solution until such an improved solution cannot be found anymore. Since they search at each step around the current solution rather than the whole search space, they are likely to be trapped by local optima. EAs such as the (1+1) EA and the (1+1) EA* search the whole search space at each step, so they are more likely to find the global optimum of a combinatorial optimization problem. In this section, we analyze the performance of the (1+1) EA and the (1+1) EA* on two instances G1 and G2 of the MAX-CUT problem. On the first instance it is shown that the (1+1) EA and the (1+1) EA* are superior to RLS, and on the second it is shown that these two simple EAs may be inefficient. A. Instance G1 The instance G1 is a complete bipartite graph with 2k(k ≥ 1) vertices on each side, i.e., G1 has n : = 4k vertices and 4k2 edges. This instance has been used to demonstrate that RLS may perform very poorly [36]. We divide each side into two equal subsets of size k. The left side contains two subsets A and B, and the right side contains two subsets C and D, where A = {v1 , . . . , vk }, B = {vk+1 , . . . , v2k }, C = {v2k+1 , . . . , v3k } and D = {v3k+1 , . . . , v4k }. According to (1), the MAX-CUT is (A ∪ B, C ∪ D) or (C∪D, A ∪ B) which has 4k2 edges. For RLS, the cut (A∪C, B∪D) is a local optimum as shown in Fig. 1. This is because that each vertex has exactly k edges in its own side and the other, respectively, with respect to this

Fig. 1.

1495

Local optimum of instance G1 .

cut, moving any one vertex from its own side to the other cannot increase the size of the cut. However, the (1+1) EA and the (1+1) EA* can easily escape the local optimum and efficiently find a global optimum. We use bit string X ∈ {0, 1}n to represent a cut of this instance. If xi = 1 for i ∈ {1, . . . , n}, then vi is chosen in S(X), otherwise it is chosen in S(X). In this instance, the MAXn/2 n/2 n/2 CUT can be expressed as (1, . . . , 1, 0, . . . , 0) or (0, . . . , 0, n/2

1, . . . , 1), i.e., (A ∪ B, C ∪ D) or (C ∪ D, A ∪ B). Theorem 4: The (1+1) EA and the (1+1) EA* solve instance G1 in expected runtime O(n3 ). Proof: The idea behind the proof is as follows. We first partition the search space into three disjoint subspaces. Then we analyze the expected runtime for a solution to leave each subspace enter other subspaces with higher fitness value, or to find a global optimum. Finally, we obtain the total expected optimization runtime by adding up these expected runtime. Let X ∈ {0, 1}n be the current bit string. X can be expressed as X = (X , X ), where X and X ∈ {0, 1}2k correspond to vertices from A ∪ B and C ∪ D, respectively. Let l and l be the number of vertices of A ∪ B and C ∪ D which have been chosen in S(X), respectively, i.e., l = |X | and l = |X |. We partition the search space {0, 1}n into three disjoint subspaces A1 , A2 , and A3 , where A1 = {X| fit(X) < 2k2 }, A2 = {X| fit(X) = 2k2 }, and A3 = {X|2k2 < fit(X) ≤ 4k2 }. Case 1: X ∈ A1 . In this case, l < k and l < k or l > k and l > k. This can be derived by the fitness function fit(X) = l (2k − l ) + l (2k − l ) = 2k2 −2(k − l )(k − l ). We analyze the situation that l < k and l < k, and the other situation where l > k and l > k can be analyzed similarly. When l < k and l < k, flipping any one vertex form S(X) to S(X) will be accepted by the (1+1) EA and the (1+1) EA*, since the fitness value can be increased by 2(k − l ) or 2(k − l ). The probability of the event is (1/n), which implies that the fitness value can be increased by at least one in expected runtime O(n). Note that the fitness value of each solution in A1 is less than 2k2 . Thus, X will leave subspace A1 and enter A2 ∪ A3 in expected runtime O(n3 ). Case 2: X ∈ A2 . In this case, there are three situations needed to be considered. The first one is that l = k and l = k, the second one is that l = k and l = k, and the last one is that l = k and l = k.

1496

Fig. 2.

IEEE TRANSACTIONS ON CYBERNETICS, VOL. 45, NO. 8, AUGUST 2015

Instance G2 .

Similar to the analysis of Case 1, in the first and the second situations, the fitness can be increased by at least one in expected runtime O(1). In the last situation, i.e., l = k and l = k, moving one vertex of A ∪ B (C ∪ D) from S(X) to S(X) and simultaneously moving one vertex of C ∪ D (A ∪ B) from S(X) to S(X) will increase the fitness by 2. Thus, this event can be accepted by the (1+1) EA and the (1+1) EA*. The probability of such an event is ((k/k)2 ) = (1), which implies that X will leave A2 and enter A3 in expected runtime O(1). Case 3: X ∈ A3 . In this case, l < k and l > k or l > k and l < k. Similar to the analysis of Case 1, the global optimum will be found in expected runtime O(n3 ). Altogether, the expected optimization runtime is O(n3 ). For instance G1 , RLS may be trapped in the local optimum, while the (1+1) EA and the (1+1) EA* can find a global optimum of G1 in expected polynomial runtime. So, the (1+1) EA and the (1+1) EA* are better than RLS on instance G1 . B. Instance G2 Given k ≥ 1, the instance G2 has n : = 5k + 3 vertices, which are divided into five vertex subsets Vi (i = 1, . . . , 5). The vertex subsets V1 and V2 contain k vertices, and the other vertex subsets contain k + 1 vertices, i.e., |V1 | = |V2 | = k, and |V3 | = |V4 | = |V5 | = k + 1. Each vertex in Vi (i = 1, . . . , 5) is incident to every vertex in subsets Vi−1 and Vi+1 , treating subscripts modulo 5, as shown in Fig. 2. Thus, the total number of edges in G2 is 5k2 + 6k + 2. The MAX-CUT is (V1 ∪ V2 ∪ V4 , V3 ∪ V5 ) or (V3 ∪ V5 , V1 ∪ V2 ∪ V4 ) which has 2k(k + 1) + 2(k + 1)2 = 4k2 + 6k + 2 edges, including all edges except those k2 edges between V1 and V2 . In the following, a trivial bipartition of a graph G = (V, E) means that all vertices are in one side of the bipartition, i.e., (V, ∅) or (∅, V). A flip means moving some vertex from its own side to the other. Instance G2 was proposed by Kaul and West [44] to show that starting with a trivial bipartition of G2 , there exists a flip sequence of length (2/25)(n2 + 9n − 11) which can find the MAX-CUT. However, RLS cannot always find the MAX-CUT of G2 . Assume k is odd, then Fig. 3 shows a local optimum for RLS. In fact, flipping any one vertex cannot increase the fitness value. We denote by X ∗ this local optimum. Here we show that the (1+1) EA and the (1+1) EA* can jump out of X ∗ , but the expected runtime is exponential. Theorem 5: The (1+1) EA and the (1+1) EA* need expected runtime (n(k+3)/2 ) and (min{n(k+3)/2 , 1/δ (k+3)/2 }) to jump out of X ∗ , respectively.

Fig. 3.

Local optimum of G2 .

Proof: There are two ways to jump out of this local optimum X ∗ . The first way moves all (k + 1)/2 vertices of V4 from S(X ∗ ) to S(X ∗ ) and simultaneously moves one vertex of V5 from S(X ∗ ) to S(X ∗ ). The second way moves all (k + 1)/2 vertices of V4 from S(X ∗ ) to S(X ∗ ) and simultaneously moves one vertex of V3 from S(X ∗ ) to S(X ∗ ). No matter which way to choose, the fitness value can be increased by one and the number of vertices needed to move is (k + 3)/2. The probability of flipping (k + 3)/2 vertices by the (1+1) EA is (1/n)(k+3)/2 (1 − (1/n))n−(k+3)/2 < (1/n)(k+3)/2 , which implies that the expected runtime is (n(k+3)/2 ). The probability of flipping (k + 3)/2 vertices by the (1+1) EA* is (1/2)(1/n)(k+3)/2 (1 − (1/n))n−(k+3)/2 < (1/2)(1/n)(k+3)/2 or (1/2)δ (k+3)/2 (1 − δ)n−(k+3)/2 < (1/2)δ (k+3)/2 , which implies that the expected runtime is (n(k+3)/2 ) or (1/δ (k+3)/2 ). The (1+1) EA and the (1+1) EA* may need exponential expected runtime to solve instance G2 . Theorem 6: The (1+1) EA and the (1+1) EA* solve instance G2 in expected runtime O(nk2 + n(k+3)/2 ). Proof: The idea behind the proof is as follows. We first prove that all vertices of V1 , V2 , V3 , or V5 will be moved to one side of a bipartition in expected runtime O(nk2 ), then prove that starting with this bipartition the (1+1) EA and the (1+1) EA* need expected runtime O(nk2 +n(k+3)/2 ) to find the global optimum. Therefore, the global optimum can be found in expected runtime O(nk2 + n(k+3)/2 ). Let X ∈ {0, 1}n be the current bit string. X can be expressed as X = (X1 , . . . , X5 ), where Xi = {0, 1}|Vi | corresponds to vertices from Vi . Let ji (i = 1, 2, . . . , 5) be the number of vertices from Vi in S(X), i.e., ji = |Xi |, then X can also be expressed as a vector (j1 , j2 , j3 , j4 , j5 ). The event that moves a vertex of V1 from S(X) to S(X) changes the fitness value by 2k + 1 − 2j2 − 2j5 . Conversely, the event that moves a vertex of V1 from S(X) to S(X) changes the fitness value by 2j2 + 2j5 − 2k − 1. That is to say, the fitness value can be increased by |2j2 + 2j5 − 2k − 1| through moving a vertex of V1 from its own side to the other until all vertices of V1 are in one side of a bipartition, as 2j2 + 2j5 − 2k − 1 can never be zero. The probability that the (1+1) EA and the (1+1) EA* moves one vertex of V1 from its own side to the other is (1/n), which implies that the fitness can be increased by at least one in expected runtime O(n). Note that there are altogether O(k2 ) edges in the input graph. Therefore, all vertices of V1 will be moved to one side of a bipartition in expected runtime O(nk2 ). Similarly, all vertices of V2 , V3 , or V5 will be moved by the (1+1) EA and the (1+1) EA* to one side of a bipartition in expected runtime O(nk2 ), as the fitness can be always

ZHOU et al.: APPROXIMATION AND PARAMETERIZED RUNTIME ANALYSIS OF EAs FOR THE MAX-CUT PROBLEM

increased by |2j1 + 2j3 − 2k − 1|, |2j2 + 2j4 − 2k − 1|, or |2j1 + 2j4 − 2k − 1| through moving one vertex of V2 , V3 , or V5 from its own side to the other until no vertex can be moved by the (1+1) EA and the (1+1) EA* anymore. Thus, after expected runtime O(nk2 ), ji (i = 1, 2) may be 0 or k, and ji (i = 3, 5) may be 0 or k + 1. This implies that X may be transformed to (0, 0, k + 1, ∗, k + 1), (0, k, 0, ∗, k + 1), (k, 0, k + 1, ∗, 0), or (k, k, 0, ∗, 0), where “∗” means that j4 can take any value from {0, 1, . . . , k + 1}. Since (0, 0, k + 1, ∗, k + 1) and (k, k, 0, ∗, 0), (0, k, 0, ∗, k + 1) and (k, 0, k + 1, ∗, 0) are two pairs of symmetrical solutions, we only consider the case that X has been transformed to (0, 0, k + 1, ∗, k + 1) or (k, 0, k + 1, ∗, 0) as follows, and the other cases can be analyzed similarly. Case 1: X is now (0, 0, k + 1, ∗, k + 1). In this case, moving one vertex (if exists) of V4 from S(X) to S(X) increases the fitness by 2k + 2. The probability of this event is (1/n) for both the (1+1) EA and the (1+1) EA*, which implies that the fitness can be increased by at least one in expected runtime O(n). Note that there are altogether O(k2 ) edges in the input graph. Therefore, all vertices of V4 will be moved to S(X) in expected runtime O(nk2 ), i.e., the global optimum (0, 0, k + 1, 0, k + 1) can be found in expected runtime O(nk2 ) in this case. Case 2: X is now (k, 0, k + 1, ∗, 0). According to the value that j4 takes, we consider three subcases as follows. Case 2.1: j4 = 0, i.e., X is now (k, 0, k + 1, 0, 0). In this case, moving one vertex of V5 from S(X) to S(X) increases the fitness by one. The probability of this event is (1/n) for both the (1+1) EA and the (1+1) EA*, and there are altogether O(k2 ) edges in the input graph. Therefore, X will be transformed to X = (k, 0, k + 1, 0, k + 1) in expected runtime O(nk2 ). Similarly, since for X moving one vertex of V1 from S(X ) to S(X ) increases the fitness by one, the global optimum (0, 0, k + 1, 0, k + 1) will be found in expected runtime O(nk2 ) in this subcase. Case 2.2: j4 = k + 1, i.e., X is now (k, 0, k + 1, k + 1, 0). Similar to the analysis of Case 2.1, the global optimum (k, k, 0, k + 1, 0) will be found in expected runtime O(nk2 ) in this subcase. Case 2.3: 0 < j4 < k + 1. These are local optima of G2 , and the worst case is that j4 = (k +1)/2 < (k +1)/2. According to the proof of Theorem 5, the probability that both the (1+1) EA and the (1+1) EA* jump out of X ∗ with probability ((1/n)(k+3)/2 ), which implies that X has been transformed to (k, 0, k+1, k+1, 0) or (k, 0, k+1, 0, 0) in expected runtime O(n(k+3)/2 ). According to the analysis of Cases 2.1 and 2.2, then the global optimum can be found in expected runtime O(nk2 ). Therefore, the global optimum will be found in expected runtime O(nk2 + n(k+3)/2 ) in this subcase. For instance G2 , RLS cannot find its global optimum when it is trapped in local optimum X ∗ . The (1+1) EA and the (1+1) EA* can find the global optimum of G2 . However, the

1497

expected optimization runtime of them may be exponential. So, the (1+1) EA and the (1+1) EA* may be inefficient on instance G2 . VI. C ONCLUSION The MAX-CUT problem is a classic NP-complete combinatorial optimization problem. In this paper, we analyze the approximation performance of EAs and reveal that the (1+1) EA and the (1+1) EA* have performance guarantees for this problem. We also carry out parameterized analysis of a simple EA and discover that the (1+1) EA* is a fixed-parameter algorithm for the MAX-CUT problem. Finally, we compare these two simple EAs with some local search algorithm and demonstrate that the (1+1) EA and the (1+1) EA* are superior to the local search algorithm on an instance. Nevertheless, they may be inefficient on some instances of the MAX-CUT problem. We obtain the upper bounds of optimization runtime of the (1+1) EA and the (1+1) EA* on these two instances of the MAX-CUT problem. However, we do not know the lower bounds of the optimization runtime for the (1+1) EA and the (1+1) EA* to find the global optima of these two instances. By simulating some local search algorithms, we also reveal that the (1+1) EA and the (1+1) EA* efficiently obtain some approximation solutions on the MAX-CUT problem. However, we do not know whether EAs can achieve approximation solutions which are better than those revealed by simulating these local search algorithms or not. Multiobjective EAs (MOEAs) are currently developing methods for optimization problems [45], [46], and MOEAs can be used to solve single-objective optimization problems [25], [26], [28]. Therefore, it may be another interesting work to theoretically analyze the performance of MOEAs on the MAX-CUT problem. R EFERENCES [1] R. M. Karp, “Reducibility among combinatorial problems,” in Complexity of Computer Computations, R. Miller and J. Thatcher, Eds. New York, NY, USA: Plenum Press, 1972, pp. 85–103. [2] M. Garey, D. Johnson, and L. Stockmeyer, “Some simplified NP-complete graph problems,” Theor. Comput. Sci., vol. 1, no. 3, pp. 237–267, 1976. [3] F. Barahona, M. Grötschel, M. Jünger, and G. Reinelt, “An application of combinatorial optimization to statistical physics and circuit layout design,” Oper. Res., vol. 36, no. 3, pp. 493–513, 1988. [4] R. Chen, Y. Kajitani, and S. Chan, “A graph-theoretic via minimization algorithm for two-layer printed circuit boards,” IEEE Trans. Circuits Syst., vol. 30, no. 5, pp. 284–299, May 1983. [5] J. Gramm, E. Hirsch, R. Niedermeier, and P. Rossmanith, “Worst-case upper bounds for MAX-2-SAT with an application to MAX-CUT,” Discrete Appl. Math., vol. 130, no. 2, pp. 139–155, 2003. [6] A. S. Kulikov and S. S. Fedin, “A 2|E|/4 -time algorithm for MAX-CUT,” J. Math. Sci., vol. 126, no. 3, pp. 1200–1204, 2005. [7] S. Sahni and T. Gonzalez, “P-complete approximation problems,” J. ACM, vol. 23, no. 3, pp. 555–565, 1976. [8] S. Poljak and D. Turzík, “A polynomial algorithm for constructing a large bipartite subgraph, with an application to a satisfiability problem,” Can. J. Math., vol. 34, pp. 519–524, Jun. 1982. [9] D. J. Haglin and S. M. Venkatesen, “Approximation and intractability results for the maximum cut problem and its variants,” IEEE Trans. Comput., vol. 40, no. 1, pp. 110–113, Jan. 1991. [10] T. Hofmeister and H. Lefmann, “A combinatorial design approach to MAXCUT,” Random Struct. Algorithm, vol. 9, nos. 1–2, pp. 163–175, 1996.

1498

[11] M. Goemans and D. Williamson, “.878-approximation algorithms for MAX CUT and MAX 2SAT,” in Proc. 26th Annu. ACM Symp. Theory Comput., New York, NY, USA, 1994, pp. 422–431. [12] Y. Kim and B. Moon, “A hybrid genetic search for graph partitioning based on lock gain,” in Proc. Genet. Evol. Comput. Conf. (GECCO), Las Vegas, NV, USA, 2000, pp. 167–174. [13] S. Kim, Y. Kim, and B. Moon, “A hybrid genetic algorithm for the MAX CUT problem,” in Proc. Genet. Evol. Comput. Conf. (GECCO), 2001, pp. 416–423. [14] S. Sen, “Simulated annealing approach to the max cut problem,” Proc. SPIE, vol. 1963, pp. 61–66, Mar. 1993. [15] L. Gao, Y. Zeng, and A. Dong, “An ant colony algorithm for solving max-cut problem,” Prog. Nat. Sci., vol. 18, no. 9, pp. 1173–1178, 2008. [16] S. Droste, T. Jansen, and I. Wegener, “A rigorous complexity analysis of the (1+1) evolutionary algorithm for separable functions with Boolean inputs,” Evol. Comput., vol. 6, no. 2, pp. 185–196, 1998. [17] T. Jansen and I. Wegener, “Evolutionary algorithms—How to cope with plateaus of constant fitness and when to reject strings of the same fitness,” IEEE Trans. Evol. Comput., vol. 5, no. 6, pp. 589–599, Dec. 2001. [18] S. Droste, T. Jansen, and I. Wegener, “On the analysis of the (1+1)-evolutionary algorithm,” Theor. Comput. Sci., vol. 276, nos. 1–2, pp. 51–81, 2002. [19] J. He and X. Yao, “Drift analysis and average time complexity of evolutionary algorithms,” Artif. Intell., vol. 127, no. 1, pp. 57–85, 2001. [20] J. Scharnow, K. Tinnefeld, and I. Wegener, “Fitness landscapes based on sorting and shortest paths problems,” in Proc. Parallel Probl. Solving. Nat. (PPSN VII), vol. 2439. Granada, Spain, 2002, pp. 54–63. [21] O. Giel and I. Wegener, “Evolutionary algorithms and the maximum matching problem,” in Proc. 20th Annu. Symp. Theor. Aspects Comput. Sci. (STACS), vol. 2607. Berlin, Germany, 2003, pp. 415–426. [22] F. Neumann and I. Wegener, “Randomized local search, evolutionary algorithms, and the minimum spanning tree problem,” Theor. Comput. Sci., vol. 378, no. 1, pp. 32–40, 2007. [23] B. Doerr, E. Happ, and C. Klein, “A tight analysis of the (1+1)-EA for the single source shortest path problem,” in Proc. IEEE Congr. Evol. Comput. (CEC), Singapore, 2007, pp. 1890–1895. [24] C. Witt, “Worst-case and average-case approximations by simple randomized search heuristics,” in Proc. 22nd Annu. Symp. Theor. Aspects Comput. Sci. (STACS), vol. 3404. Stuttgart, Germany, 2005, pp. 44–56. [25] T. Friedrich, J. He, N. Hebbinghaus, F. Neumann, and C. Witt, “Approximating covering problems by randomized search heuristics using multi-objective models,” Evol. Comput., vol. 18, no. 4, pp. 617–633, 2010. [26] F. Neumann and J. Reichel, “Approximating minimum multicuts by evolutionary multi-objective algorithms,” in Proc. 10th Int. Conf. Parallel Probl. Solving Nat. (PPSN), Dortmund, Germany, 2008, pp. 72–81. [27] Y. Yu, X. Yao, and Z. Zhou, “On the approximation ability of evolutionary optimization with application to minimum set cover,” Artif. Intell., vol. 180–181, pp. 20–33, Apr. 2012. [28] G. Greiner, “Single- and multi-objective evolutionary algorithms for graph bisectioning,” in Proc. Found. Genet. Algorithm (FOGA 2009), New York, NY, USA, pp. 29–38. [29] S. Kratsch, P. Lehre, F. Neumann, and P. Oliveto, “Fixed parameter evolutionary algorithms and maximum leaf spanning trees: A matter of mutation,” in Proc. 11th Int. Conf. Parallel Probl. Solving Nat. (PPSN) I, vol. 6238. Kraków, Poland, 2010, pp. 204–213. [30] A. Sutton and F. Neumann, “A parameterized runtime analysis of simple evolutionary algorithms for makespan scheduling,” in Proc. 12th Int. Conf. Parallel Probl. Solving Nat. (PPSN) I, vol. 7491. Taormina, Italy, 2012, pp. 52–61. [31] A. Sutton, J. Day, and F. Neumann, “A parameterized runtime analysis of evolutionary algorithms for MAX-2-SAT,” in Proc. Genet. Evol. Comput. Conf. (GECCO), New York, NY, USA, 2012, pp. 433–440. [32] A. Sutton and F. Neumann, “A parameterized runtime analysis of evolutionary algorithms for the Euclidean traveling salesperson problem,” in Proc. 26th AAAI Conf. Artif. Intell., 2012, pp. 1105–1111. [33] S. Kratsch and F. Neumann, “Fixed-parameter evolutionary algorithms and the vertex cover problem,” Algorithmica, vol. 65, no. 4, pp. 754–771, 2013. [34] H. Dong, J. He, H. Huang, and W. Hou, “Evolutionary programming using a mixed mutation strategy,” Inf. Sci., vol. 177, no. 1, pp. 312–327, 2007. [35] J. He, W. Hou, H. Dong, and F. He, “Mixed strategy may outperform pure strategy: An initial study,” in Proc. IEEE Congr. Evol. Comput., 2013, pp. 562–569.

IEEE TRANSACTIONS ON CYBERNETICS, VOL. 45, NO. 8, AUGUST 2015

[36] (2013, Oct. 30). Scribe Haowen Chan 15-854: Approximations Algorithms Lecturer: Anupam Gupta Topic: Max-Cut, Hardness of Approximations Date: 9/14 [Online]. Available: http://citeseerx.ist.psu.edu/viewdoc/ summary?doi=10.1.1.71.288 [37] S. Bylka, A. Idzik, and Z. Tuza, “Maximum cuts: Improvements and local algorithmic analogues of the Edwards–Erd˝os inequality,” Discrete Math., vol. 194, nos. 1–3, pp. 39–58, 1999. [38] Y. Yu and Z.-H. Zhou, “A new approach to estimating the expected first hitting time of evolutionary algorithms,” Artif. Intell., vol. 172, no. 15, pp. 1809–1832, 2008. [39] R. Niedermeier, Invitation to Fixed-Parameter Algorithms. New York, NY, USA: Oxford Univ. Press, 2006. [40] V. Raman and S. Saurabh, “Improved fixed parameter tractable algorithms for two ‘edge’ problems: MAXCUT and MAXDAG,” Inf. Process. Lett., vol. 104, no. 2, pp. 65–72, 2007. [41] M. Mahajan and V. Raman, “Parameterizing above guaranteed values: MaxSat and MaxCut,” J. Algorithm, vol. 31, no. 2, pp. 335–354, 1999. [42] J. Gramm, E. Hirsch, R. Niedermeier, and P. Rossmanith, “Worst-case upper bounds for MAX-2-SAT with an application to MAX-CUT,” Discrete Appl. Math., vol. 130, no. 2, pp. 139–155, 2003. [43] P. Erdös, “On some extremal problems in graph theory,” Israel J. Math., vol. 3, no. 2, pp. 113–116, 1965. [44] H. Kaul and D. B. West, “Long local searches for maximal bipartite subgraphs,” SIAM J. Discrete Math., vol. 22, no. 3, pp. 1138–1144, 2008. [45] L. Ke, Q. Zhang, and R. Battiti, “MOEA/D-ACO: A multiobjective evolutionary algorithm using decomposition and antcolony,” IEEE Trans. Cybern., vol. 43, no. 6, pp. 1845–1859, Dec. 2013. [46] H. Xia, J. Zhuang, and D. Yu, “Combining crowding estimation in objective and decision space with multiple selection and search strategies for multi-objective evolutionary optimization,” IEEE Trans. Cybern., vol. 44, no. 3, pp. 378–393, Mar. 2014.

Yuren Zhou received the B.Sc. degree from Peking University, Beijing, China, in 1988, the M.Sc. degree from Wuhan University, Wuhan, China, in 1991, both in mathematics, and the Ph.D. degree in computer science from Wuhan University, in 2003. He is currently a Professor with the School of Computer Science and Engineering, South China University of Technology, Guangzhou, China. His current research interests include design and analysis of algorithms, evolutionary computation, and data mining.

Xinsheng Lai received the M.S. degree from Guizhou University, Guiyang, China, in 2004, and the Ph.D. degree from the South China University of Technology, Guangzhou, China, in 2014, both in computer applied technology. His current research interests include evolutionary computation and neural computation and their applications in the real world.

Kangshun Li received the B.Sc. degree in computational mathematics from Jiangxi University (currently Nanchang University), Nanchang, China, in 1983, and the Ph.D. degree in computer software and theory from Wuhan University, Wuhan, China, in 2006. He was a Post-Doctoral Research Fellow with the Institute of Automation, Chinese Academy of Sciences, Beijing, China, from 2007 to 2009. He is currently a Professor with the School of Information, South China Agricultural University, Guangzhou, China. His current research interests include evolutionary computation and computer vision.