TIVC: An Efficient Local Search Algorithm for Minimum Vertex Cover in Large Graphs

1. Introduction

Given an undirected graph $G=(V,E)$, a vertex cover (VC) $C\subseteq V$ of G is a subset of vertices such that every edge $e\in E$ has at least one endpoint belonging to C. The minimum vertex cover (MVC) problem is to find a VC with the smallest size in a graph, which is a classical NP-hard problem with an approximation factor of 1.3606 [1]. MVC plays an important role in graph theory for its extensive applications, including scheduling [2], cyber security [3], and wireless sensor networks (WSNs) [4]. For example, a WSN can be modeled as an undirected graph, where vertices and edges represent infrastructures and communication links, respectively. Then, elements in VCs can be used for various purposes such as monitoring link failures, facility location, clustering, and data aggregation, since each communication link (edge) is incident with at least one vertex in a VC. Figure 1 shows an example of simulating a wireless sensor network using a unit disk graph[5], where each vertex is the center of a circle and there is an edge between it and the other vertices within its radius.

The MVC problem has been extensively studied and many algorithms have been proposed, including exact and approximate algorithms. Regarding exact algorithms, branch-and-reduce methods currently have the best time complexity [6,7]. However, the exact algorithms are still exponential-time, which cannot solve the MVC problem in a reasonable time, especially on large graphs. Therefore, approximate algorithms are proposed to solve MVC. Greedy algorithms are the common method used for approximately solving intractable problems, such as connected dominating sets [8], weighted vertex covers [9], and independent sets [10]. While greedy algorithms can quickly produce feasible solutions, the quality of solutions is generally not high enough to meet real-world requirements.

In practice, tackling intractable problems often resorts to heuristic approaches for obtaining a high-quality solution within a reasonable time, and a number of such algorithms have been proposed to address various problems, such as job shop scheduling [11], partition coloring [12], and critical nodes problem [13]. Local search is one of the extensively studied heuristics for solving NP-hard problems [14,15,16,17,18]. Regarding the MVC problem, it has been shown that the local search outperforms other heuristics [19]. The primary idea of local search algorithms for solving graph theory problems can be described as follows: initiate with a feasible solution and iteratively update it by removing, adding, or swapping vertices until a cutoff time is reached. A common strategy is $(j,k)$-swaps, i.e. removing j vertices from a solution and adding k vertices to it. We refer to a $(j,k)$-swap as a j-improvement [20]. The local search algorithms have the advantages of simple implementation and effective performance. However, they do suffer from a few challenges: The cycling phenomenon (i.e., revisiting recently visited vertices) [21,22] leads to the algorithm wasting too much computational time, resulting in a local optimum; moreover, complex vertex selection strategies may diminish the efficiency of the local search, resulting in a poor performance in large graphs. To address these issues, researchers have proposed many strategies, which will be described in detail in Section 3.

This paper proposes an efficient algorithm for the MVC problem on large graphs named TIVC, which has two main ideas. The first one is a 3-improvements framework with a tiny perturbation. State-of-the-art local search algorithms for MVC are based on 2-improvements frameworks, and both 2-improvements and 3-improvements aim to search for a feasible solution of size ($k-1$) based on a k-sized feasible solution. However, 3-improvements have a chance to directly search for a solution of size ($k-2$) after adding the first vertex, which enhances the efficiency of the algorithm. Moreover, during the vertex-removing phase, the third vertex is removed from the solution in a perturbation manner, which expands the algorithm’s search space and enhances its ability to deal with local optima dilemmas. Second, we use an effective edge selection strategy to accelerate search speed. When selecting uncovered edges for covering, it is essential to consider both the effectiveness and complexity of the selection strategy. During the vertex-removing phase, different vertex selection strategies can result in different numbers of uncovered edges (for example, a greedy-based vertex selection strategy generates fewer uncovered edges, while a random vertex selection strategy produces more). Adding vertices to the solution by traversing all uncovered edges is not only time-consuming but can also easily lead the algorithm into local optima. Based on these considerations, we combine the edge age based best from multiple selections (EABMS) technique [19] with a random vertex selection method to choose the uncovered edges to be covered.

We conduct experiments to compare TIVC with state-of-the-art local search algorithms for MVC on the Network Repository benchmark, including 72 real-world large instances. TIVC shows the best accuracy performance and significantly outperforms other algorithms on many instances.

The remainder of this paper is organized as follows. Section 2 presents basic definitions. Section 3 gives a brief review of the related work of MVC. Section 4 describe the TIVC algorithm. Section 5 is devoted to the design and analysis of experiments, and Second Section 6 provides concluding remarks.

2. Preliminaries

This section introduces some preliminary knowledge.

2.1. Notations and Terminologies

Denote by $G=(V,E)$ an undirected graph with vertex set V and edge set E. For an edge $e=(u,v)$, the two vertices u and v are called endpoints of e. A vertex is adjacent to another vertex if they are the two endpoints of an edge, and one is called a neighbor of the other. An edge is incident with each of its endpoints. The set consisting of all neighbors of a vertex $v\in V$, denoted by $N\left(v\right)$, is the neighborhood of v, and $N\left[v\right]=N\left(v\right)\cup \left\{v\right\}$ is the closed neighborhood of v. The degree of v is the number of edges incident with v. For a vertex set $S\subseteq V$, let $N\left[S\right]={\bigcup }_{v\in S}N\left[v\right]$ and $N\left(S\right)=N\left[S\right]\setminus S$.

For a graph $G=(V,E)$ and a set of vertices $S\subseteq V$, an edge $e\in E$ is covered by S if at least one endpoint of e belongs to S; otherwise, e is uncovered by S. If all edges of G are covered by S, then S is called a vertex cover (VC) of G. A VC with the smallest cardinality is called a minimum vertex cover (MVC) of G. Note that a graph $G=(V,E)$ may have more than one MVC. We use $E_u\left(S\right)\subseteq E$ to denote the set of edges uncovered by S, and use $E_c\left(S\right)\subseteq E$ to denote the set of edges covered by S. The MVC problem is to find a MVC from a graph.

2.2. Local Search

From this section, C represents a candidate (or partial) solution of the MVC problem. The general scheme of local search for MVC is to construct an initial VC first and then iteratively improve the solution to a smaller one by vertex swapping. Generally, local search algorithms use gain(v) and loss(v) to measure the importance of a vertex v, where gain(v) denotes the number of edges uncovered by C but covered by $C\cup \left\{v\right\}$, and loss(v) the number of edges covered by C but uncovered by $C\setminus \left\{v\right\}$. The age of a vertex v, denoted by age(v), is the number of the steps since it was last removed from C. age values are usually used to break ties, where ties mean the existence of multiple vertices with the same gain or loss. In addition, the age of an edge e, denoted by age(e), is the number of steps since it was last uncovered by C, which is often used as a criterion for selecting edges [19].

3. Related Work

This section provides a brief review on heuristic algorithms for MVC. In 2013, Cat et al. [23] proposed a two-stage strategy that allows to select a pair of vertices separately and exchange vertices in two stages, based on which a NuMVC algorithm for MVC is developed, addressing the drawback (time-consuming) of previous algorithms that requires selecting vertices simultaneously [21,24,25]. However, with the rapid development of the Internet and the widespread deployment of sensors, the size of datasets has dramatically increased, and many algorithms fail to solve MVC on large instances. For this, Cai et al. [26] introduced the Best from Multiple Selections (BMS) heuristic, which randomly samples k vertices in C and removes one with the minimum loss value from C. This heuristic aims to obtain a trade-off between efficiency and accuracy. Based on BMS, an algorithm named FastVC is developed for solving MVC well on large instances. By combining BMS and the best-picking strategy [23], Ma et al. [27] proposed a best-picking with a noisy strategy and developed an algorithm NoiseVC; they also proposed a BMS with random walk strategy (WalkBMS) in another literature [28], to handle the issue that FastVC easily gets trapped in a local optimum. Subsequently, Cai et al. [29] proposed an improved version of FatVC, named FastVC2+p, by integrating some processing techniques and initial solution construction methods. In 2021, Quan et al. [19] proposed a new edge weighting method based on edge age (EABMS), which randomly samples a edges in $E_u\left(C\right)$ and selects one edge with the maximum age value for covering (by adding one of its endpoints to C). Based on EABMS, an algorithm EAVC and its variant EAVC2+p are developed for MVC. Both EAVC and EAVC2+p showed superiority on large graphs compared with FastVC and its variants. To date, FastVC, EAVC, and their variants are state-of-the-art MVC local search algorithms for large instances. To demonstrate the effectiveness of TIVC, we compared our algorithm with the baseline algorithms, i.e., FastVC and EAVC.

4. Main Algorithm

In this section, we describe our algorithm TIVC. We first introduce the top-level architecture of TIVC, and then describe the algorithm in detail.

4.1. Top-Level Architecture

The top-level architecture of TIVC is shown in Algorithm 1. TIVC starts with constructing an initial VC C for the graph G (line 1), and then enters a loop for finding a VC as small as possible within a given cutoff time (lines 2–10). Specifically, when obtaining a VC C, it updates the best solution $C^{*}$ and then removes a vertex from C (lines 3–6). If C is not a feasible solution, then the algorithm iteratively exchanges vertices until C becomes a VC. First, it removes vertices from C until $\left|C\right|=|C^{*}|-3$ (lines 7). Next, it selects an uncovered edge and adds one of its endpoints to C (line 8). If C remains infeasible, it selects another vertex adding to C in the same way (lines 9–10). Finally, the best-found vertex cover $C^{*}$ is returned when the cutoff time is reached (line 11).

4.2. The TIVC algorithm

Our TIVC algorithm is shown in Algorithm 2, which encompasses two stages, i.e. construction and search.

In the construction stage, the algorithm constructs an initial VC C of G (line 1) by EdgeGreedyVC [19,26], which is a commonly used approach for MVC algorithms. The process starts with an empty set C and proceeds iteratively by checking and covering edges to extend C. Once a VC is obtained, redundant vertices are removed from C, where redundant vertices are those with loss=0 and removing them does not produce new uncovered edges.

In the search stage, the algorithm attempts to search for a VC smaller than the current $C^{*}$. At the beginning of the algorithm, it repeatedly removes a vertex with the minimum loss from C, until C is not a VC (lines 3–6). Second, the algorithm repeatedly performs vertex swapping. Each swapping step contains a removing phase (lines 7–11) and an adding phase (lines 12–17). In the removing phase, the first vertex $u_1$ is selected by the BMS heuristic and removed from C (lines 7–8); then the second vertex is selected randomly in C and removed from C to perturb the solution slightly (lines 9–10). The above implementation lead to $|C^{*}|=|C|-3$. In the adding phase, it first selects an uncovered edge $e\in E_u\left(C\right)$ and adds the vertex with greater gain in its endpoints to C (lines 11–13); if there are uncovered edges ($E_u\left(C\right)\ne \varnothing$), then it choose one edge in $E_u\left(C\right)$ randomly and add the vertex with greater gain to C (lines 14–17). Finally, the best-found VC $C^{*}$ is returned when the cutoff time is reached (line 18).

4.3. Complexity Analysis

In this section, we analyze the time complexity of TIVC. For a given graph $G=(V,E)$, let $\left|V\right|=n,\left|E\right|=m$.

• TIVC (Algorithm 2) runs in $O(m+n)$. First, the ConstructVC procedure (line 1) constructs an initial solution by EdgeGreedyVC, which has a time complexity of $O\left(m\right)$ [26]. Second, lines 3–6 take $O(m+n)$ time since the procedure traverses E and V once. Third, lines 7–17 take $O\left(m\right)$ time because the time complexity of BMS and EABMS has already been proven to be $O\left(1\right)$ [19,26]; the time complexity of removing a vertex from a solution C and adding a vertex to C are $O\left(1\right)$, while line 14 need to traverse E once for checking the condition whether $E_u\left(C\right)\ne \varnothing$. Thus, the time complexity of TIVC is $O(m+n)$. □

5. Results and Discussion

In this section, we evaluate TIVC on the Network Repository benchmark1 [30]. This benchmark includes enormous amounts of graphs from various areas. To assess the performance of TIVC on large graphs, we specifically selected instances with vertex numbers ranging from ${10}^4$ to ${10}^7$, encompassing 72 instances.

5.1. Experiment Setup

TIVC is implemented in C++ and compiled by gcc 7.1.0 with the `-O3’ optimization option. All experiments are run under CentOS Linux release 7.6.1810 with Intel(R) Xeon(R) Gold 6254 CPU@3.10GHz with 128GB RAM. The parameters of FastVC and EAVC are set to the same as those used in the original literature [19,26]. TIVC incorporates two tunable parameters: k for the BMS and a for the EABMS. These parameters are set to 50 and 24, respectively, aligning with the settings of EAVC.

We compare TIVC with two state-of-the-art local search algorithms, FastVC [26] and EAVC [19], for MVC. Both the two algorithms are designed to solve large instances for MVC. FastVC combines the two-stage exchange framework and the BMS heuristic to balance the algorithm’s accuracy and efficiency, which achieves well performance on large graphs. EAVC is based on the two-stage framework, and combines WalkBMS and EABMS to provide a good guidance for improving the quality of solutions (and also increasing the diversity of solutions) in the vertex and edge selection phase.

Table 1 shows the details of these three algorithms. The construction procedures of these three algorithms are based on EdgeGreedyVC. For vertex selection, FastVC, EAVC, and TIVC utilize BMS, WalkBMS, and BMS+Random strategies, respectively. Regarding edge selection, FastVC, EAVC, and TIVC use Random, EABMS, and EABMS+Random strategies, respectively. In addition, FastVC and EAVC are both based on 2-improvements, while TIVC is based on 3-improvements. The codes of FastVC2 and EAVC3 were open online.

For each instance, all algorithms are executed 10 times with seeds 1, 2, 3, …, 10. The cutoff time for each run is set at 1,000 seconds. For each instance, we present the best (i.e., smallest) solution as $Min$, the average solution as $Avg$, and the average running time (over the 10 runs) as $t_{avg}$. Furthermore, we report the difference between the best solution found by TIVC and the solutions obtained by other algorithms as $\Delta$.

5.2. Experimental Result

Results on the Network Repository benchmark are reported in Table 2. TIVC shows superior performance in terms of accuracy on almost all instances, outperforming both the FastVC and EAVC algorithms. Specifically, TIVC obtains the best solution on 60 (out of 78) instances, while FastVC and EAVC obtain 28 and 39 best solutions, respectively. In particular, TIVC shows a remarkable ability to find strictly optimal solutions, in total 28 such solutions. In comparison, FastVC and EAVC can only find 5 and 7 strictly optimal solutions, respectively. Regarding average solution, TIVC also outperforms the other algorithms. FastVC, EAVC, and TIVC obtain the optimal average VC on 11, 15, and 26 instances, respectively. In addition, for large instances with ${10}^7$ vertices, TIVC performs remarkably well and finds much smaller VCs than other algorithms on many instances.

5.3. Discussion

The experimental results demonstrate the effectiveness of our TIVC algorithm for solving MVC on large graphs. We can observe that the $t\_avg$ values of all three algorithms are almost very close to 1,000 seconds on instances with ${10}^7$ vertices, which indicates that the algorithms are less likely to fall into a local optimum on instances of this scale. For instances of this scale, 3-improvement exhibits a clear advantage. This is because the 3-improvement search framework can sometimes directly find a new solution of size $k-2$ based on a k-sized solution, whereas 2-improvement cannot achieve this.

6. Conclusions

In this paper, we propose an efficient local search algorithm for the MVC problem called TIVC, which consists of a 3-improvements framework with tiny perturbation and an edge selection strategy. The experimental results show that TIVC significantly outperforms state-of-the-art algorithms for MVC on large graphs. In the future, we would like to study the ideas for solving other graph theory problems on large graphs.