Next Article in Journal
Multi-Core Parallel Gradual Pattern Mining Based on Multi-Precision Fuzzy Orderings
Previous Article in Journal
New Parallel Sparse Direct Solvers for Multicore Architectures

Algorithms 2013, 6(4), 726-746; https://doi.org/10.3390/a6040726

Article
An Efficient Local Search for the Feedback Vertex Set Problem
1
Key Laboratory of Pattern Recognition and Intelligent Information Processing, Shiling, Institutions of Higher Education of Sichuan Province, Chengdu 610106, China
2
School of Information Science and Technology, Chengdu University, Chengdu 610106, China
*
Author to whom correspondence should be addressed.
Received: 24 June 2013; in revised form: 7 August 2013 / Accepted: 28 October 2013 / Published: 1 November 2013

Abstract

:
Inspired by many deadlock detection applications, the feedback vertex set is defined as a set of vertices in an undirected graph, whose removal would result in a graph without cycle. The Feedback Vertex Set Problem, known to be NP-complete, is to search for a feedback vertex set with the minimal cardinality to benefit the deadlock recovery. To address the issue, this paper presents NewkLS_FVS(LS, local search; FVS, feedback vertex set), a variable depth-based local search algorithm with a randomized scheme to optimize the efficiency and performance. Experimental simulations are conducted to compare the algorithm with recent metaheuristics, and the computational results show that the proposed algorithm can outperform the other state-of-art algorithms and generate satisfactory solutions for most DIMACSbenchmarks.
Keywords:
feedback vertex set; local search; variable depth search; heuristic

1. Introduction

Inspired by many deadlock detection applications, the Feedback Vertex Set Problem (FVSP) is known to be NP-complete and plays an important role in the study of deadlock recovery [1,2]. For example, the wait-for graph is a directed graph used for deadlock detection in operating systems and relational database systems of an operating system. and each directed cycle corresponds to a deadlock situation in the wait-for graph. In order to resolve all deadlocks, some blocked processes need to be aborted. A minimum feedback vertex set in this graph corresponds to a minimum number of processes that one needs to abort. Therefore solving the FVSP with more efficiency and better performance can contribute to an improved deadlock recovery.
To describe the FVSP, the following concepts are predefined. Assuming G = ( V ( G ) , E ( G ) ) is a graph, then the set of vertices is denoted by V ( G ) , and the set of edges of G is denoted by E ( G ) . For S V ( G ) , the subgraph induced by S is denoted by G [ S ] . The set of vertices adjacent to a vertex, i V ( G ) , will be denoted by N ( i ) = { j V ( G ) : ( i , j ) E } and called the o p e n n e i g h b o r h o o d of the vertex, i. Let G be a graph. A feedback vertex set, S, in G is a set of vertices in G, whose removal results in a graph without cycle (or equivalently, every cycle in G contains at least one vertex in S).
The FVSP can be considered in both directed and undirected graphs.Let G be an undirected graph. A Feedback Vertex Set Problem (FVSP), S, in G is a set of vertices in G, whose removal results in a graph without cycle (or equivalently, every cycle in G contains at least one vertex in S). Let G be a directed graph. A feedback vertex set (FVS), S, in G is a set of vertices in G, whose removal results in a graph without directed cycle (or equivalently, every directed cycle in G contains at least one vertex in S).
Inspired by real world applications, several variants were proposed over the years. Some of them are summarized by the following definitions.
(a) 
FVSP: Given a graph, G, the feedback vertex set problem is to find an FVS with the minimum cardinality.
(b) 
The Parameterized Feedback Vertex Set Problem (DFVSP): Given a graph, G, and a parameter, k, the Parameterized Feedback Vertex Set Problem is to either find an FVS of at most k vertices for G or report that no such set exists.
(c) 
The Vertex Weighted Feedback Vertex Set Problem (VWFVSP): Given a vertex weighted graph, G, the Vertex Weighted Feedback Vertex Set Problem is to find an FVS with the minimum weight.
The Parameterized Feedback Vertex Set Problem is the decision version of the feedback vertex set problem. The FVSP and DFVSP were classic NP-complete problems that appeared in the first list of NP-complete problems in Karp’s seminal paper [3]. When the edges or arcs instead of vertices are considered, it becomes the corresponding edge or arc version. For example, the parameterized feedback arc set problem is to find out whether there is a minimum of k arcs in a given graph, whose removal makes the graph acyclic.
Let G be a graph. It is said that a vertex set, S, is an acyclic vertex set if G [ S ] is acyclic. An acyclic vertex set, S, is maximal if G [ S { v } ] is not acyclic for any v V ( G ) \ S . Note that if G [ S ] is acyclic, then V ( G ) \ S is a feedback vertex set.
Without loss of generality, only the feedback vertex set problem for an undirected graph is considered in this paper, and the aim is to search for the largest subset, S V ( G ) , such that G [ S ] is acyclic.
The rest of this paper is organized as follows: Section 2 presents the related work of local search heuristics. Then, Section 3 and Section 4 propose the k-opt local search (KLS)-based local search algorithm and the KLS with a randomized scheme algorithm in detail. Section 5 conducts the experiments of both the proposed algorithms and the compared metaheuristics with the results for the performance and efficiency evaluation. Finally, Section 6 discusses the contributions of this paper and draws a conclusion.

2. Related Work

As a local improved technology, the local search is a practical tool and a common technique looking for the near-optimal solutions for combinatorial optimization problems [4]. In order to obtain high-quality solutions, it was applied to many metaheuristic algorithms, such as simulating annealing, genetic algorithm, memetic algorithm and swarm intelligent algorithms, in many cases.
The local search is a common tool looking for near-optimal solutions in reasonable time for combinatorial optimization problems. Usually, the current solution is iteratively replaced by an improved solution from its neighborhood, until no better solution can be obtained. Then, the current solution is called locally optimal.
The basic local search starts with a feasible solution, x, and repeatedly replaces x with an improved one, x , which is selected from the neighborhood of x. If no better neighbor solutions can be found in its neighborhood, the local search immediately stops and returns as the final best solution found during the search [4].
Since the basic local search is usually unable to obtain a good-quality solution and often far from the optimal solution, various improved local searches were proposed, e.g., tabu search [5,6,7], variable depth search [8,9], variable neighborhood search [10,11,12], reactive local search [13,14,15,16], k-opt local search (KLS) [4,17], iterated local search [18], iterated k-opt local search [17] and phased local search [19].
In many cases, the local search can be applied into heuristic algorithms, such as simulated annealing, ant colony and particle swarm optimizations. However, normally, it is hard to obtain the best solution, or even an approximate solution with high quality, for a certain combinatorial optimization problem. Therefore, various local search methods, such as phased local search [19] and variable depth local search, were proposed. The variable depth local search was initially used to solve the Graph Partitioning Problem (GPP) [9] and the Traveling Salesman Problem (TSP) [8]. Then, it was applied to other heuristic algorithms [20,21,22,23]. In [4], it was applied to solve the maximum clique problem and successfully obtained good solutions.
Different from the previous studies, the proposed local search algorithms are based on KLS and are combined with a depth variable search, which can improve the performance and efficiency.

3. KLS-Based Local Search Algorithm

In the simple local search procedure, the current solution is changed by adding or removing one vertex. The idea of KLS-based local search is to operate more vertices for each time. That is to say, the current solution is changed by way of adding or removing more than one vertex. Furthermore, the number of operated vertices is not limited in KLS. Therefore, it is a variable depth local search, also called k-opt local search.
As a comparison, the KLS-based local search is explored to solve the feedback vertex set problem. Then, a variable depth-based local search with a randomized scheme is proposed to solve this problem. For a given graph, G, it can be observed that if S is acyclic, then V ( G ) \ S is a feedback vertex set. Therefore, such a vertex set, S, with maximum cardinality corresponds to a feedback vertex set with minimum cardinality. Hence, the goal is to find a vertex set, S V ( G ) , with maximum cardinality, for which G [ S ] is acyclic. The main framework of this algorithm is taken from K L S in [4].
The following notations will be used to describe the algorithms.
  • C F : the current vertex subset, C F , for which G [ C F ] is acyclic.
  • P A : the possible vertex set of addition. i.e., P A = { v | the subgraph induced by C F { v } is acyclic }
  • f ( v ) :the degree of v in the graph, G [ C F ] ;
  • f + ( v ) : the degree of v in the graph, G [ C F { v } ] , i.e., f + ( v ) = d G [ C F { v } ] ( v ) .
First, a vertex set, C F V , is randomly generated as an initial acyclic vertex set. If C F is not maximal, then a vertex, v P A , that minimizes f ( v ) is chosen to add to C F . On the contrary, if C F is maximal, then a vertex, v C F , with the maximum degree is chosen to be dropped. In the search process, some vertices are iteratively added or removed, ensuring that the vertex set, C F , is acyclic at each iteration. In order to avoid cycling, when a vertex, v, is added (resp.dropped), v would not be dropped (resp.added) immediately. The pseudocode of the procedure is shown in Algorithm 1 (k-opt-LS).
Algorithm 1 k-opt-LS( G , C F , P A )
Require:
  •   G: a graph with the vertex set, { 1 , 2 , , n } ;
       C F : the current acyclic vertex set;
       P A : the possible vertex set of addition;
1:
generate an acyclic vertex set, C F , randomly.
2:
repeat
3:
   C F P r e v C F ; D C F P r e v ; P { 1 , 2 , , n } ; g 0 ; g m a x 0
4:
  repeat
5:
    if P A P then
6:
      find a vertex, v, from P A P that minimizes f + ( v ) . if multiple vertices are found, select one randomly.
7:
       C F C F { v } ; g g + 1 ; P P \ { v } ;
8:
    else
9:
      if C F P then
10:
        find a vertex, v, from C F P that maximizes f ( v ) . if multiple vertices are found, select one randomly.
11:
         C F C F \ { v } ; g g 1 ; P P \ { v } ;
12:
        if v is contained in C F P r e v then
13:
           D D \ { v } ;
14:
        end if
15:
      end if
16:
    end if
17:
  until D =
18:
until g m a x 0
In this local search algorithm, if P A = , then the acyclic vertex set, C F , is maximal. In this case, a vertex, v C F , will be dropped; otherwise, a vertex v V \ C F will be added. Algorithm 1 starts with a random acyclic vertex set, C F ; then, a possibly better acyclic vertex set is obtained by adding or removing more than one vertex. Therefore, it is called the variable depth local search, and it can be applied to other heuristic algorithms, such as simulated annealing. Compared with the simple local search algorithm, where only one vertex would be added or removed to change the current solution, the variable depth local search operates more vertices and provides more efficiency in searching for the desired acyclic vertex set.

4. KLS with a Randomized Scheme for the FVSP

In Algorithm 1, when a vertex is added (resp.dropped), it is no longer dropped (resp.added) if it does not exit the inner loop. Moreover, at each iteration, a vertex that minimizes f + ( v ) or minimizes f ( v ) is selected. These conditions are too restricted, and they may trap the procedure into a local minimum. In order to overcome these drawbacks, a variable T v is used to store the moment of the last iteration, while the vertex, v, was under operation, and c is used to record the iteration number of the inner loop. If v is added (resp.dropped), then the chance is given to make v dropped (resp.added) for at most k times within a given number of iterations. Moreover, at each iteration, a vertex is selected with a probability associated with the degree of v. The modified version of Algorithm 1 is shown in Algorithm 2 (NewKLS_FVS(LS, local search; FVS, feedback vertex set)).
Algorithm 2 NewKLS_FVS( G , C F , P A , k )
Require:
  •   G: a graph with the vertex set, { 1 , 2 , , n } ;
       C F : the current acyclic vertex set;
       P A : the possible vertex set of addition;
1:
generate an acyclic vertex set, C F , randomly.
2:
repeat
3:
    C F P r e v C F ; D C F P r e v ; g 0 ; g m a x 0 ; c 0 ; T i 1 for i = 1 , 2 , , n ;
4:
   repeat
5:
       c c + 1 ;
6:
       P { v | c T v k } ;
7:
      if P A P then
8:
         find a vertex, v, from P A P with a probability, ρ.
9:
          C F C F { v } ; g g + 1 ; T v c ;
10:
      else
11:
         if C F P then
12:
            find a vertex v from C F P with a probability, ρ.
13:
             C F C F \ { v } ; g g 1 ; T v c ;
14:
            if v is contained in C F P r e v then
15:
                D D \ { v } ;
16:
            end if
17:
         end if
18:
      end if
19:
   until D =
20:
until g m a x 0

5. Experimental Results

5.1. Experimental Setup and Benchmark Instances

All the algorithms are coded in Visual C++ 6.0 and executed in an Intel Pentium(R) G630 Processor 2.70 MHz with 4 GB of RAM memory on a Windows 7 Operating System.
Two sets of testing instances are used in the experiments. One instance is a set of random graphs, which are constructed with parameter n and p with order (the vertex number) n, inserting an edge with probability p. This probability is called the edge density (or edge probability). The graph, G ( n , p ) , is used to represent a graph constructed with parameter n and p. Then, the proposed algorithm is compared with other algorithms on random graphs, G ( 400 , 0.5 ) and G ( 800 , 0.5 ) . The other instance is the well-known DIMACSbenchmarks for graph coloring problems (see [24]), consisting of 59 graph coloring problem instances. Table 1 gives the characteristics of these instances, including the number of vertices ( | V | ), the number of edges ( | E | ) and the graph density ( d e n s i t y ).
Table 1. Benchmark instances and their characteristics.
Table 1. Benchmark instances and their characteristics.
No.Instance|V||E|density
1anna.col1389860.104
2david.col878120.217
3DSJC125.1.col1257360.095
4DSJC125.5.col1253,8910.502
5DSJC125.9.col1256,9610.898
6fpsol2.i.1.col49611,6540.095
7fpsol2.i.2.col4518,6910.086
8fpsol2.i.3.col4258,6880.097
9games120.col1201,2760.179
10homer.col5613,2580.021
11huck.col746020.223
12inithx.i.1.col86418,7070.050
13inithx.i.2.col64513,9790.067
14inithx.i.3.col62113,9690.073
15jean.col805080.161
16latin_square_10.col900307,3500.760
17le450_5a.col4505,7140.057
18le450_5b.col4505,7340.057
19le450_5c.col4509,8030.097
20le450_5d.col4509,7570.097
21le450_15b.col4508,1690.081
22le450_15c.col45016,6800.165
23le450_15d.col45016,7500.166
24le450_25a.col4508,2600.082
25le450_25b.col4508,2630.082
26le450_25c.col45017,3430.172
27le450_25d.col45017,4250.172
28miles250.col1287740.096
29miles500.col1282,3400.288
30miles750.col1284,2260.519
31miles1000.col1286,4320.791
32miles1500.col12810,3961.279
33mulsol.i.1.col1973,9250.203
34mulsol.i.2.col1883,8850.221
35mulsol.i.3.col1843,9160.233
36mulsol.i.4.col1853,9460.232
37mulsol.i.5.col1863,9730.231
38myciel3.col11200.364
39myciel4.col23710.281
40myciel6.col957550.169
41myciel7.col1912,3600.130
42queen5_5.col253201.067
43queen6_6.col365800.920
44queen7_7.col499520.81
45queen8_8.col641,4560.722
46queen8_12.col962,7360.6
47queen9_9.col812,1120.652
48queen10_10.col1002,9400.594
49queen11_11.col1213,9600.546
50queen12_12.col1445,1920.504
51queen13_13.col1696,6560.469
52queen14_14.col1968,3720.438
53queen15_15.col22510,3600.411
54queen16_16.col25612,6400.387
55school1.col38519,0950.258
56school1_nsh.col35214,6120.237
57zeroin.i.1.col2114,1000.185
58zeroin.i.2.col2113,5410.16
59zeroin.i.3.col2063,5400.168

5.2. Computational Results on k-opt-LS and NewKLS_FVS

5.2.1. Impact of the Tabu Tenure

In order to observe the impact of the tabu tenure of the algorithm, NewKLS_FVS, the algorithm for the tabu tenure, k, is tested from 100 to 1,000 on four chosen graphs. Table 2 reports the best and worst solutions, respectively, for the algorithm, NewKLS_FVS, with different values of the parameter, k.
Table 2. Results with with different values of the parameter k.
Table 2. Results with with different values of the parameter k.
InstancekBestWorstAverage
inithx.i.1.col100572550553
200575552561
300575553561
400575552562
500575543555
600572548558
700573549553
800569546553
900592541563
1,000570546556
le450_25a.col100157154155
200156153155
300157155155
400157155155
500156155155
600157154155
700157154155
800156154155
900157155155
1,000157154155
G(400,0.5)100151313
200151213
300151313
400151313
500151313
600151314
700151314
800151314
900151214
1000151214
G(800,0.5)100171314
200151314
300161314
400171314
500161314
600161415
700171315
800161515
900181315
1,000171415
From the results above, it can be seen that the parameter, k, is important for the algorithm. For example, for the graph, inithx.i.1.col (resp.le450_25a.col, G(400,0.5), G(800,0.5)), k = 900 is the most suitable one.

5.3. Comparison of NewKLS_FVS with Other Algorithms

In order to verify the efficiency and performance of the proposed algorithm, the performance of the proposed heuristic for the feedback vertex set problem is also compared to that of several others. Note that the proposed problem can be solved approximately by various heuristics, including simulated annealing (SA) and variable neighborhood search (VNS).
(1)
Simulated annealing: The simulated annealing algorithm was introduced to solve combinatorial optimization problems proposed by Kirkpatrick [25]. Since then, it has been widely investigated to solve many combinatorial optimization problems. Simulated annealing allows a transition to go opposite towards achieving the goal with a probability. As a result, the simulated annealing algorithm has some opportunities to jump out of the local minima. As preparation, for a given graph, G, and a positive integer, k, a partition ( S 1 , S 2 ) of V ( G ) is found, such that G [ S 1 ] is acyclic. Then, the parameters, T 0 (initial temperature), T s (stop temperature) and α (cooling down coefficient), are required as input. For convenience, the edge numbers of G [ S 1 ] and G [ S 1 ] are denoted by e ( S 1 ) and e ( S 1 ) , respectively. After the preparation, the algorithm begins with a randomly generated partition ( S 1 , S 2 ) of V ( G ) . Then, a partition ( S 1 , S 2 ) is chosen that is obtained by swapping two elements from S 1 and S 2 . If e ( S 1 ) is fewer than e ( S 1 ) , then ( S 1 , S 2 ) is accepted. Otherwise, it is accepted according to the simulated annealing rule. At the end of each iteration, the temperature would cool down. Usually, let T = α T , where α ( 0 , 1 ) . If G [ S 1 ] is acyclic, the procedure terminates successfully, and an acyclic induced subgraph with order k would be returned. When the temperature reaches T s , the procedure also terminates. The pseudocode is presented in Algorithm 3, where u ( 0 , 1 ) denotes a random number in ( 0 , 1 ) .
Algorithm 3 SA(G, k, T 0 , T s , α,t)
1:
while Stop condition is not met do
2:
  Generate a partition ( S 1 , S 2 ) of V ( G ) with | S 1 | = k ;
3:
   T T 0
4:
  while T > T s do
5:
    Generate a new partition ( S 1 , S 2 ) by swapping two elements from S 1 and S 2 ;
6:
    if e ( S 1 ) is fewer than e ( S 1 ) then
7:
       ( S 1 , S 2 ) ( S 1 , S 2 )
8:
    else
9:
      if u ( 0 , 1 ) < e e ( S 1 ) e ( S 1 ) then
10:
         ( S 1 , S 2 ) ( S 1 , S 2 ) ;
11:
      end if
12:
    end if
13:
     T α T ;
14:
  end while
15:
end while
(2)
Variable neighborhood search: Hansen and Mladenović [10,11,12] introduced the variable neighborhood search (VNS) method in combinatorial problems. In [5], it was applied to solve the maximum clique problem. It constructs different neighborhood structures, which are used to perform a systematic search. The main idea of variable neighborhood search is that when it does not find a better solution for a fixed number of iterations, the algorithm continues to search in another neighborhood until a better solution is found.
Denote N k , ( k = 1 , 2 , , k m a x ) as a finite set of pre-selected neighborhood structures and N k ( X ) as the set of solutions in the k t h neighborhood of X. The steps of the basic VNS are presented in Algorithm 4 (see [5]).
To solve the feedback vertex set problem, the neighborhood structure is described as follows. Let ( S 1 , S 2 ) be the current partition, for a positive integer, k, with k < min { | S 1 | , | S 2 | } ; define B k ( S ) as the set of the k-subset of S. The k t h neighborhood of P is defined by:
N k ( S 1 , S 2 ) = { ( S 1 U 2 \ U 1 , S 2 U 1 \ U 2 ) | U 1 B k ( V r ) , U 2 B k ( V b ) }
The proposed algorithms operate the partition, S 1 , S 2 . They change the current partition to another solution, S 1 , S 2 , by swapping exactly k vertices between S 1 and S 2 . Therefore, the neighborhood of ( S 1 , S 2 ) is the set of all the solutions obtained from ( S 1 , S 2 ) by swapping exactly k vertices between S 1 and S 2 . The parameter, k m a x , called the radius of the neighborhood, controls the maximum k of the procedure.
The algorithms, k-opt-LS, NewKLS_FVS, VNS and SA, are carried out on several random graphs and DIMACS benchmarks for the maximum feedback vertex set. In the VNS algorithm, the value of K m a x is set to be one and two, which are called VNS1 (if K m a x = 1 ) and VNS2 (if K m a x = 2 ), respectively. In the SA algorithm, the initial temperature is set to be T 0 = 1 , 000 , and the cooling down coefficient α = 0.9997 . Table 3, Table 4, Table 5, Table 6 and Table 7 show the results of these algorithms, and each is carried out for 15 runs with a CPU-time limit of 30 min.
Algorithm 4 VNS( G , r )
1:
Initialize N k , k = 1 , 2 , , k m a x , initial solution X and stop criteria;
2:
while Stop condition is not met do
3:
   k 1 ;
4:
  Generate a partition N k = ( S 1 , S 2 ) of V ( G ) with | S 1 | = r ;
5:
  while k < k m a x do
6:
      Generate a point, X N k ( X ) ;
7:
      Apply the local search method with X as the initial solution; denote by X the obtained solution;
8:
      if X is better than incumbent then
9:
             X X ; k 1 ;
10:
      else
11:
             k k + 1 ;
12:
      end if
13:
  end while
14:
   r r + 1
15:
end while
Table 3. Results for NewKLS_FVS (LS, local search; FVS, feedback vertex set) and a CPU-time limit of 30 min for 15 runs.
Table 3. Results for NewKLS_FVS (LS, local search; FVS, feedback vertex set) and a CPU-time limit of 30 min for 15 runs.
InstanceBestWorstAverageInstanceBestWorstAverage
anna.col126126126miles1000.col202020
david.col666666miles1500.col101010
DSJC125.1.col585858mulsol.i.1.col121121121
DSJC125.5.col151515mulsol.i.2.col133133133
DSJC125.9.col666mulsol.i.3.col129129129
fpsol2.i.1.col366364365mulsol.i.4.col130130130
fpsol2.i.2.col370370370mulsol.i.5.col131131131
fpsol2.i.3.col344344344myciel3.col888
games120.col474646myciel4.col161616
homer.col520520520myciel6.col616161
huck.col525252myciel7.col122122122
inithx.i.1.col602554569queen5_5.col777
inithx.i.2.col549548548queen6_6.col999
inithx.i.3.col529529529queen7_7.col111111
jean.col636363queen8_8.col131313
latin_square_10.col131313queen8_12.col161616
le450_5a.col114108111queen9_9.col141414
le450_5b.col114109111queen10_10.col161616
le450_5c.col1049498queen11_11.col181818
le450_5d.col10497101queen12_12.col201919
le450_15b.col129126127queen13_13.col212121
le450_15c.col666364queen14_14.col232222
le450_15d.col676565queen15_15.col252424
le450_25a.col157154155queen16_16.col262525
le450_25b.col141138140school1.col777575
le450_25c.col787676school1_nsh.col716769
le450_25d.col727070zeroin.i.1.col139139139
miles250.col818080zeroin.i.2.col160160160
miles500.col434343zeroin.i.3.col156156156
miles750.col272727
Table 4. Results for k-opt-LS and a CPU-time limit of 30 min for 15 runs.
Table 4. Results for k-opt-LS and a CPU-time limit of 30 min for 15 runs.
InstanceBestWorstAverageInstanceBestWorstAverage
anna.col126126126miles1000.col202020
david.col666666miles1500.col101010
DSJC125.1.col585757mulsol.i.1.col121121121
DSJC125.5.col151515mulsol.i.2.col133133133
DSJC125.9.col666mulsol.i.3.col129129129
fpsol2.i.1.col364362362mulsol.i.4.col130130130
fpsol2.i.2.col370369369mulsol.i.5.col131131131
fpsol2.i.3.col344344344myciel3.col888
games120.col474646myciel4.col161616
homer.col520520520myciel6.col616161
huck.col525252myciel7.col122121121
inithx.i.1.col601554566queen5_5.col777
inithx.i.2.col548546547queen6_6.col999
inithx.i.3.col529528528queen7_7.col111111
jean.col636363queen8_8.col131313
latin_square_10.col131212queen8_12.col161616
le450_5a.col112107109queen9_9.col141414
le450_5b.col111106108queen10_10.col161616
le450_5c.col1069599queen11_11.col181818
le450_5d.col10497100queen12_12.col201919
le450_15b.col126123124queen13_13.col212121
le450_15c.col656062queen14_14.col232222
le450_15d.col656063queen15_15.col252424
le450_25a.col153149151queen16_16.col262525
le450_25b.col139136137school1.col767273
le450_25c.col767374school1_nsh.col696667
le450_25d.col706768zeroin.i.1.col137137137
miles250.col808080zeroin.i.2.col160159159
miles500.col434343zeroin.i.3.col155154154
miles750.col272727
Table 5. Results for variable neighborhood search 1 (VNS1) with k m a x = 1 and a CPU-time limit of 30 min for 15 runs.
Table 5. Results for variable neighborhood search 1 (VNS1) with k m a x = 1 and a CPU-time limit of 30 min for 15 runs.
InstanceBestWorstAverageInstanceBestWorstAverage
anna.col111107108miles1000.col161414
david.col575556miles1500.col1099
DSJC125.1.col424041mulsol.i.1.col383536
DSJC125.5.col121111mulsol.i.2.col494647
DSJC125.9.col666mulsol.i.3.col484445
fpsol2.i.1.col767274mulsol.i.4.col484446
fpsol2.i.2.col120113116mulsol.i.5.col494546
fpsol2.i.3.col114108110myciel3.col888
games120.col373636myciel4.col161616
homer.col327319322myciel6.col424141
huck.col484646myciel7.col565354
inithx.i.1.col125118121queen5_5.col777
inithx.i.2.col136126131queen6_6.col999
inithx.i.3.col131123127queen7_7.col111111
jean.col585657queen8_8.col121212
latin_square_10.col766queen8_12.col151414
le450_5a.col625859queen9_9.col141313
le450_5b.col615859queen10_10.col151414
le450_5c.col413839queen11_11.col161515
le450_5d.col413939queen12_12.col171717
le450_15b.col535152queen13_13.col191818
le450_15c.col302728queen14_14.col191919
le450_15d.col292728queen15_15.col212020
le450_25a.col595757queen16_16.col222121
le450_25b.col575555school1.col272525
le450_25c.col312929school1_nsh.col272525
le450_25d.col302929zeroin.i.1.col474445
miles250.col646263zeroin.i.2.col666164
miles500.col323131zeroin.i.3.col666163
miles750.col212020
Table 6. Results for VNS2 with k m a x = 2 and a CPU-time limit of 30 min for 15 runs.
Table 6. Results for VNS2 with k m a x = 2 and a CPU-time limit of 30 min for 15 runs.
InstanceBestWorstAverageInstanceBestWorstAverage
anna.col110107109miles1000.col151414
david.col585656miles1500.col1099
DSJC125.1.col424041mulsol.i.1.col393637
DSJC125.5.col121111mulsol.i.2.col504648
DSJC125.9.col666mulsol.i.3.col494647
fpsol2.i.1.col787376mulsol.i.4.col504647
fpsol2.i.2.col123118120mulsol.i.5.col504647
fpsol2.i.3.col120112115myciel3.col888
games120.col373636myciel4.col161616
homer.col336324329myciel6.col434141
huck.col474646myciel7.col565455
inithx.i.1.col131123127queen5_5.col777
inithx.i.2.col144137140queen6_6.col999
inithx.i.3.col142136138queen7_7.col111111
jean.col585757queen8_8.col121212
latin_square_10.col777queen8_12.col151414
le450_5a.col615960queen9_9.col141313
le450_5b.col625960queen10_10.col151414
le450_5c.col413839queen11_11.col161515
le450_5d.col413940queen12_12.col171717
le450_15b.col545252queen13_13.col191818
le450_15c.col302828queen14_14.col191919
le450_15d.col302829queen15_15.col212020
le450_25a.col615859queen16_16.col222121
le450_25b.col585556school1.col282626
le450_25c.col312930school1_nsh.col272525
le450_25d.col312930zeroin.i.1.col494445
miles250.col646263zeroin.i.2.col686365
miles500.col323131zeroin.i.3.col656364
miles750.col212020
Table 7. Results for simulated annealing (SA) and a CPU-time limit of 30 min for 15 runs.
Table 7. Results for simulated annealing (SA) and a CPU-time limit of 30 min for 15 runs.
InstanceBestWorstAverageInstanceBestWorstAverage
anna.col113100104miles1000.col141213
david.col544951miles1500.col988
DSJC125.1.col403737mulsol.i.1.col382932
DSJC125.5.col1099mulsol.i.2.col453942
DSJC125.9.col555mulsol.i.3.col473942
fpsol2.i.1.col906673mulsol.i.4.col473942
fpsol2.i.2.col133116123mulsol.i.5.col483842
fpsol2.i.3.col133109116myciel3.col888
games120.col363435myciel4.col161515
homer.col331325327myciel6.col403437
huck.col454142myciel7.col544650
inithx.i.1.col131124128queen5_5.col777
inithx.i.2.col148138143queen6_6.col999
inithx.i.3.col145134139queen7_7.col101010
jean.col565253queen8_8.col121111
latin_square_10.col766queen8_12.col141313
le450_5a.col615758queen9_9.col131212
le450_5b.col605758queen10_10.col141313
le450_5c.col403637queen11_11.col151414
le450_5d.col413738queen12_12.col171515
le450_15b.col544850queen13_13.col181616
le450_15c.col282627queen14_14.col181717
le450_15d.col282626queen15_15.col191818
le450_25a.col615356queen16_16.col211919
le450_25b.col565253school1.col262323
le450_25c.col302628school1_nsh.col252323
le450_25d.col302727zeroin.i.1.col513742
miles250.col615658zeroin.i.2.col675459
miles500.col312829zeroin.i.3.col635357
miles750.col191818
In order to show the performance and efficiency of various algorithms, experiments are conducted to test the algorithms (NewkLS_FVS, k-opt-LS, VNS1, VNS2, SA) on graphs huck.col, inithx.i.1.col, le450_25a.col, zeroin.i.1.col and school1_nsh.col. The convergence curves of these algorithms are reported on both running times (with a CPU-time limit of 10 min; see Figure 1) and iteration numbers (within 100 iterations; see Figure 2). The experimental results show that NewkLS_FVS outperforms other algorithms on graphs huck.col, le450_25a.col, zeroin.i.1.col and school1_nsh.col almost at any moment. The solution quality is better than any other compared algorithm after 3 min on inithx.i.1.col. Additionally, the solution quality of NewkLS_FVS is better than those of any other compared algorithm on all tested graphs after 20 iterations. It can be seen that the performance of the algorithm, k-opt-LS, is better than VNS1, VNS2 and SA on almost all these instances, and the convergence performance of k-opt-LS is improved by using the proposed approaches.
Figure 1. Comparison of the algorithms with a CPU-time limit of 10 min. (a) inithx.i.1.col; (b) le450_25a.col; (c) school1_nsh.col; (d) zeroin.i.1.col.
Figure 1. Comparison of the algorithms with a CPU-time limit of 10 min. (a) inithx.i.1.col; (b) le450_25a.col; (c) school1_nsh.col; (d) zeroin.i.1.col.
Algorithms 06 00726 g001
Figure 2. Comparison of the algorithms within 100 iterations. (a) huck.col; (b) inithx.i.1.col; (c) le450_25a.col; (d) zeroin.i.1.col.
Figure 2. Comparison of the algorithms within 100 iterations. (a) huck.col; (b) inithx.i.1.col; (c) le450_25a.col; (d) zeroin.i.1.col.
Algorithms 06 00726 g002

5.4. Evaluation of the Algorithms

From the report of Table 3, Table 4, Table 5, Table 6 and Table 7, it can be seen that the results of NewKLS_FVS and k-opt-LS are obviously better than those of VNS1, VNS2 and SA. Table 8 presents the results of the best algorithm for each instance testing DIMACS. In Table 8, the column best means the best result from the algorithms, and the column worst is the worst result from the algorithms. The column the-best-algorithm is the set of algorithms capable of obtaining the best result.
Table 8. Results for algorithm analysis.
Table 8. Results for algorithm analysis.
InstanceBestWorstThe-Best-Algorithm
anna.col126126a,b
david.col6666a,b
DSJC125.1.col5858a
DSJC125.5.col1515a,b
DSJC125.9.col66a,b,c,d
fpsol2.i.1.col366364a
fpsol2.i.2.col370370a
fpsol2.i.3.col344344a,b
games120.col4746a,b
homer.col520520a,b
huck.col5252a,b
inithx.i.1.col602554a
inithx.i.2.col549548a
inithx.i.3.col529529a
jean.col6363a,b
latin_square_10.col1313a
le450_5a.col114108a
le450_5b.col114109a
le450_5c.col10494a
le450_5d.col10497a
le450_15b.col129126a
le450_15c.col6663a
le450_15d.col6765a
le450_25a.col157154a
le450_25b.col141138a
le450_25c.col7876a
le450_25d.col7270a
miles250.col8180a
miles500.col4343a,b
miles750.col2727a,b
miles1000.col2020a,b
miles1500.col1010a,b
mulsol.i.1.col121121a,b
mulsol.i.2.col133133a,b
mulsol.i.3.col129129a,b
mulsol.i.4.col130130a,b
mulsol.i.5.col131131a,b
myciel3.col88a,b
myciel4.col1616a,b
myciel6.col6161a,b
myciel7.col122122a
queen5_5.col77a,b,c,d,e
queen6_6.col99a,b,c,d,e
queen7_7.col1111a,b,c,d
queen8_8.col1313a,b
queen8_12.col1616a,b
queen9_9.col1414a,b
queen10_10.col1616a,b
queen11_11.col1818a,b
queen12_12.col2019a,b
queen13_13.col2121a,b
queen14_14.col2322a,b
queen15_15.col2524a,b
queen16_16.col2625a,b
school1.col7775a
school1_nsh.col7167a
zeroin.i.1.col139139a
zeroin.i.2.col160160a
zeroin.i.3.col156156a
Procedures used in Table 8: a: NewkLS FVS; b: k-opt-LS; c: VNS1; d: VNS2; e: SA.
Table 8 shows that NewKLS_FVS obtains the best result for all the tested instances, and k-opt-LS obtains 34 best results. From the report, it can be seen that they both perform better than other test procedures for the feedback vertex set problem.

6. Concluding Remarks

This paper addresses an NP-complete problem, the feedback vertex set problem, which is inspired by many applications, such as deadlock detection in operating systems and relational database systems of an operating system. An efficient local search algorithm, NewkLS_FVS, is proposed to solve this problem, and it was compared with popular heuristics, such as variable depth search and simulated annealing. From the experiments on random graphs and DIMACS benchmarks, it can be seen that NewkLS_FVS is able to obtain better solutions than the variable depth search, and it has good performance by setting the parameter, tabu tenure, to a suitable value.

Acknowledgments

The authors would like to thank the reviewers for their careful reading of this manuscript. This project is supported by the National Natural Science Foundation of China under grant No. 61309015.

Conflicts of Interest

The authors declare no conflict of interest.

References

  1. Silberschatz, A.; Galvin, P. Operating System Concepts, 4th ed.; Addison Wesley: Reading, MA, USA, 1994. [Google Scholar]
  2. Gardarin, G.; Spaccapietra, S. Integrity of Databases: A General Lockout Algorithm with Deadlock Avoidance. In Modeling in Data Base Management System; Nijsssen, G., Ed.; North-Holland: Amsterdam, The Netherlands, 1976; pp. 395–411. [Google Scholar]
  3. Karp, R.M. Reducibility among Combinatorial Problems. In Complexity of Computer Computations; Plenum Press: New York, NY, USA, 1972; pp. 85–103. [Google Scholar]
  4. Katayama, K.; Hamamoto, A.; Narihisa, H. An effective local search for the maximum clique problem. Inf. Process. Lett. 2005, 95, 503–511. [Google Scholar] [CrossRef]
  5. Hansen, P. The Steepest Ascent Mildest Descent Heuristic for Combinatorial Programming. In Congress on Numerical Methods in Combinatorial Optimization; Capri, Italy, 1986. [Google Scholar]
  6. Glover, F. Tabu search-part I. ORSA J. Comput. 1989, 1, 190–205. [Google Scholar] [CrossRef]
  7. Glover, F. Tabu search-part II. ORSA J. Comput. 1990, 2, 4–32. [Google Scholar] [CrossRef]
  8. Lin, S.; Kernighan, B.W. An effective heuristic algorithm for the traveling salesman problem. Oper. Res. 1973, 21, 498–516. [Google Scholar] [CrossRef]
  9. Kernighan, B.W.; Lin, S. An efficient heuristic procedure for partitioning graphs. Bell Syst. Tech. J. 1970, 49, 291–307. [Google Scholar] [CrossRef]
  10. Hansen, P.; Mladenović, N. An Introduction to Variable Neighborhood Search. In Metaheuristics, Advances and Trends in Local Search Paradigms for Optimization; Voss, S., Ed.; Kluwer Academic Publishers: Dordrecht, The Netherlands, 1999; pp. 433–458. [Google Scholar]
  11. Hansen, P.; Mladenović, N. Variable neighborhood search: Principles and applications. Eur. J. Oper. Res. 2001, 130, 449–467. [Google Scholar] [CrossRef]
  12. Mladenović, N.; Hansen, P. Variable neighborhood search. Comput. Oper. Res. 1997, 24, 1097–1100. [Google Scholar] [CrossRef]
  13. Battiti, R.; Protasi, M. Reactive local search for maximum clique. Algorithmica 2001, 29, 610–637. [Google Scholar] [CrossRef]
  14. Hansen, P.; Mladenović, N.; Urošević, D. Variable neighborhood search for the maximum clique. Discret. Appl. Math. 2004, 145, 117–125. [Google Scholar] [CrossRef]
  15. Gendreau, M.; Soriano, P.; Salvail, L. Solving the maximum clique problem using a tabu search approach. Ann. Oper. Res. 1993, 41, 385–403. [Google Scholar] [CrossRef]
  16. Blöchliger, I.; Zufferey, N. A graph coloring heuristic using partial solutions and a reactive tabu scheme. Comput. Oper. Res. 2008, 35, 960–975. [Google Scholar] [CrossRef]
  17. Katayama, K.; Sadamatsu, M.; Narihisa, H. Iterated k-opt local search for the maximum clique problem. Lecture Notes Comput. Sci. 2007, 4446, 84–95. [Google Scholar]
  18. Katayama, K.; Narihisa, H. Iterated Local Search Approach Using Genetic Transformation to the Traveling Salesman Problem. In Proceedings of the Genetic and Evolutionary Computation Conference, Orlando, Florida, USA, January 2000; pp. 321–328.
  19. Pullan, W. Phased local search for the maximum clique problem. J. Comb. Optim. 2006, 12, 303–323. [Google Scholar] [CrossRef]
  20. Applegate, D.; Cook, W.; Rohe, A. Chained Lin–Kernighan for large traveling salesman problems. Inf. J. Comput. 2003, 15, 82–92. [Google Scholar] [CrossRef]
  21. Johnson, D.S. Local Optimization and the Traveling Salesman Problem. Automata, Languages and Programming: Lecture Notes in Computer Science 1990, 443, 446–461. [Google Scholar]
  22. Merz, P.; Freisleben, B. Memetic algorithms for the traveling salesman problem. Complex Syst. 2001, 13, 297–345. [Google Scholar]
  23. Merz, P.; Freisleben, B. Fitness landscapes, memetic algorithms and greedy operators for graph bipartitioning. Evol. Comput. 2000, 8, 61–91. [Google Scholar] [CrossRef] [PubMed]
  24. DIMACS Benchmarks. Available online: http://mat.gsia.cmu.edu/COLOR/instances.html (accessed on 31 October 2013).
  25. Kirkpatrick, S.; Gelatt, C.D.; Vecchi, M.P. Optimization by simulated annealing. Science 1983, 220, 671–680. [Google Scholar] [CrossRef] [PubMed]
Back to TopTop