Q-MeaMetaVC: An MVC Solver of a Large-Scale Graph Based on Membrane Evolutionary Algorithms

Abstract

In recent years, the rapid development of the internet and the advancement of information technology have produced a large amount of large-scale data, some of which are presented in the form of large-scale graphs, such as social networks and sensor networks. Minimum vertex cover (MVC) is an important problem in large-scale graph research. This paper proposes a solver Q-MeaMetaVC based on the MVC framework PEAF and the membrane evolution algorithm framework MEAF. First, the graph is reduced and divided into two types of connected components (bipartite graph and non-bipartite graph) to reduce the scale of the problem. Second, different membrane structures are designed for different types of connected components to better represent the connected component features and facilitate solutions. Third, a membrane evolution algorithm (MEA), which includes fusion, division, cytolysis, and selection operators, is designed to solve the connected components. Then, Q-MeaMetaVC is compared with the best MVC solver in recent years on the test set, and good experimental results that are obtained verify the feasibility and effectiveness of Q-MeaMetaVC in solving the MVC of large-scale graphs.

1. Introduction

The rapid development of the internet and the advancement of information technology have produced a large amount of large-scale graph data, such as complex and large-scale social networks [1], sensor networks [2], etc. In the real world, the MVC algorithm is widely used—for example, to solve the sensor placement problem in sensor networks. In a logistics park, monitoring each road vehicle is achieved by arranging the fewest number of sensors. Each road intersection is represented by a vertex in the graph, and each road is represented by an edge in the graph. In this way, the sensor placement problem is transformed into the problem of finding the MVC in the abstract formed graph. Another example is key individual issues in social networks. In a group, collaboration between individuals (such as co-publishing papers) is a common occurrence. We hope to find the fewest number of individuals in the group, through which we can obtain collaborative relationships between all individuals. Each individual is represented with a vertex in the graph. When there is a collaboration between individuals a and b, an edge is added between their corresponding vertices. This way, the key individual problem is transformed into the MVC in the graph. Therefore, finding the MVC on these large graphs has attracted the attention of many researchers. With the efforts of researchers, there are already many MVC solutions that show good performance in terms of operating efficiency and the accuracy of the obtained solutions.

In the research of vertex cover solvers for large-scale graphs, local search algorithms have received more and more attention [3,4,5,6,7]. The authors of [3] proposed a simple and fast edge-weighting method called Edge Age-Based Best from Multiple Selections (EABMS), which selects edges by using edge-weighting heuristics in the local search field and its time complexity O(|E|). Based on EABMS, a large-scale graph-oriented MVC solving framework EAVC was proposed. Comparing the results of the EAVC solver with existing solvers shows that EABMS is effective. The authors of [4] proposed a method based on the combination of the rough set theory and random local search algorithm, using the reduction method to simplify and reduce the complexity quickly. The (p, q)-reverse incremental verification mechanism is also used, applying incremental positive region update techniques to verify whether the desired attribute pair can be found quickly; the primary purpose of these rules is to avoid double calculations and jumping out of local optima. The authors of [5] studied the random search heuristic behavior of the MVC in sparse random graphs based on the G(n, c/n) model in order to strictly prove that the improved Karp–Sipser algorithm, called KS-VC, can be used to solve the optimality problem of c < e. At the same time, an iterative local search algorithm called Iterated Local Search (ILS) was defined. It combines randomized local search in neighborhoods of size 2 with a greedy local search algorithm. For c < 1, it reproduces the decision of KS-VC with good probability in polynomial time. The authors of [6] proposed a new method to extend the local search algorithm for large graphs. The approach builds on the theoretical assumption that large graphs consist of distinct substructures that are relatively easy to optimize. It is based on parallel kernelization and reduces the given graph by making μ parallel randomized runs of the given local search and fixing components that have been chosen in all μ runs. Additional runs of the local search method process the resulting instances. Experiments show that the proposed parallel kernelization technique can reduce standard benchmarks and large real-world graphs to 10–20% of their initial size. FastWVC [7] is designed to solve the minimum weight vertex cover (MWVC) problem in a massive graph, and a construction process is proposed to generate high-quality initial vertex cover in a short time.

The FastVC2 proposed in the article [8] combines the graph reduction strategy with the local search algorithm and performs well in solving the MVC of large-scale instances. FastVC2 outperforms FastVC [8] in 26 instances. FastVC2 combines EdgeGreedyVC with MatchVC+ and GreedyVC+ to obtain a higher-quality initial solution, using the Best from Multiple Selections (BMS) heuristic so that it can better strike a balance between time complexity and solution quality. The authors of [9] proposed a dynamic thresholding search for an MVC (DTS_MVC) algorithm, which uses a vertex-based fast search strategy and the operation-prohibiting mechanism in the threshold search stage to expand the search space without falling into local optimum. Experimental evaluation of 86 large real-world graphs shows that DTS_MVC performs very well. Based on warning propagation (WP), the authors of [10] have developed a new linear space-time algorithm called MVC-WP to solve the MVCP (Minimum Vertex Cover Problem) on large graphs. The authors of [11] proposed a dynamic feature selection algorithm based on the MVC of a large graph, which requires only a small amount of calculation. Based on MetaVC, MetaVC2 [12] introduces a neural network-based method to enhance automatic construction. During the automatic construction process, the neural network model identifies and terminates the target algorithm with unsatisfactory operation results. Intuitively, this saves a lot of time and explores many constructs within a given budget, outperforming the REAL-WORLD benchmark. The authors of [13] proposed an MVC algorithm framework PEAF (PEAF refers to the MVCP solution framework consisting of preprocessing, exact algorithm, and approximation algorithm) based on problem reduction and divide-and-conquer ideas, and designed a large sparse graph MVC solver PEAVC based on PEAF. PEAVC has slightly adjusted the execution order of the solution phase, first solving the connected components with a special structure and then solving the remaining connected components. It uses the PreP algorithm in the preprocessing stage. For bipartite graph-connected components, it uses the exact algorithm BGVC to solve. For the remaining connected components, the approximate algorithm FastVC2 is used to solve the running time according to the proportion of its vertices to the remaining vertices. The inverse processing stage uses the inverse processor Inv_PreP. It compares the reduction capabilities of multiple preprocessors, demonstrating the different strategy’s effectiveness and the superiority of PEAVC on large-scale sparse graphs.

Inspired by membrane computing, Nishida combined the membrane nested structure with other evolutionary algorithms in 2004 and proposed the membrane algorithm framework [14]. Since then, researchers have used various algorithms based on this framework to solve different problems. For example, the authors of [15] proposed a membrane clustering algorithm predicated on membrane algorithm (MA)-based automatic clustering, which can easily find the number of clusters under the control of an evolutionary communication mechanism. Combining particle swarm optimization (PSO) and MA, the authors of [16] proposed a modified membrane-inspired algorithm based on particle swarm optimization (mMPSO) to solve the path-planning problem of multi-objective robots in dynamic obstacles and dangerous environments. Furthermore, the authors of [17] proposed a new MA for numerical optimization, and the authors of [18] combined MA with Quantum Evolutionary Algorithm (QEA).

ME [19] proposed in 2019 is an evolutionary algorithm framework inspired by the behavioral characteristics of biological cells. Currently, MEA has been used to solve various combinatorial optimization problems, such as the traveling salesman problem (TSP) [20], maximum clique problem (MCP) [21], bi-objective critical node detection problem (CNDP) [22] and minimum vertex cover problem (MVCP). In [19], the MEA for solving the MVCP, called MEAMVC, is introduced. Each membrane splits some vertices into the secondary membrane during the splitting stage, and the optimal secondary membrane is selected for fusion during the fusion stage, which accelerates the search process. Experimental results show that MEAMVC performs well.

Improving search efficiency and capabilities for large sparse graphs are the two main aspects of a better MVC solver. FastVC2 has improved the search capabilities of the local search algorithm, and PEAVC has improved search efficiency. The MEA has the characteristics of solid flexibility and high search efficiency and is suitable for parallel computing. It can better prevent the search process from falling into local optimal. This article focuses on combining the PEAF framework with the membrane evolution algorithm. The main contributions include the following:

• In combination with PEAF and MEAF, we designed an MVC solver called Q-MeaMetaVC aimed at large and sparse graphs.
• We designed different membrane structures based on the characteristics of connected components in bipartite and non-bipartite graphs, in order to facilitate the solution.
• We designed MEA operators suitable for MVC, including the BMS strategy used during the division, fast add operator to speed up the recovery speed after division, as well as selection and cytolysis operators.
• We conducted parameter experiments and algorithm comparison experiments on Q-MeaMetaVC. In six of the test set instances, Q-MeaMetaVC obtained the optimal solutions that had not been reported before. The experimental results validate the feasibility and effectiveness of the membrane evolution algorithm in solving the MVCP of large-scale sparse graphs.

The rest of this article is as follows. Section 2 introduces basic knowledge, including the operators and framework of MEA and, also, briefly introduces some algorithms of MVC to the relevant definitions and solving of the MVCP. Section 3 presents in detail the membrane structure of Q-MeaMetaVC, the algorithm framework, and the algorithm design for the bipartite and non-bipartite graphs. In Section 4, a sample shows how Q-MeaMetaVC searches for higher-quality solutions. Section 5 describes comparative experiments conducted on the parameters of Q-MeaMetaVC in recent years and the test set with the best MVC solvers. The experimental results are analyzed, verifying the feasibility of Q-MeaMetaVC. Finally, the conclusion and future research are presented in Section 6.

2. Related Research

2.1. Introduction to Membrane Evolution Algorithms

Inspiration from the characteristics of biological individuals and population is the basis for biological computing models. For example, the cross, variation, and selection of the three operators in genetic algorithms [23] are abstracted from the characteristics of genes. MEA is an evolutionary algorithm inspired by the behavior of biological cells, which includes four evolutionary operators: fusion, division, cytolysis, and selection. The following is a brief introduction to these four operators and the MEAF that uses them.

2.1.1. Evolution Operators

① Fusion Operator

In the biological system, cells will merge, and this behavior is called cell fusion [24]. Inspired by this behavior, the computational process of merging two membranes into a new membrane is called the fusion operator. As shown in Figure 1, the result of the fusion operator is that the new membrane contains all the objects of the original membranes, and the original membranes disappear.

② Division Operator

In biological systems, dividing a cell into two is called cell division. Inspired by this behavior, the calculation process of dividing a membrane into two new membranes is called the division operator. As shown in Figure 2, the division operator follows a certain strategy to place the objects from the original membrane into new, different membranes, and the original membrane disappears.

③ Cytolysis Operator

In biological systems, when the cell membrane loses function, the cells are dissolved and intracellular substances are released outside the cell. This behavior is called cell lysis. Inspired by this behavior, after the cytolysis operator is executed, the current membrane is dissolved, and the objects inside the membrane are released outside the membrane.

④ Selection Operator

In biological systems, natural selection is used to select cells that can better adapt to the environment so that they enter the subsequent evolution process. Inspired by this behavior, the selection operator selects and preserves the objects with better features within the membrane for the next generation to evolve, thereby improving the quality of the population.

2.1.2. Membrane Evolution Algorithm Framework

The membrane evolution algorithm framework (MEAF) is shown in Algorithm 1. The MEAF first uses the initialization algorithm to initialize the membrane structure and the initial population (line 1), and then it performs population parallel evolution (searching for optimization solutions) (lines 2–9). In each evolution, evolutionary operators are used sequentially for the population: fusion (line 3), division (line 4), cytolysis (line 5), and selection (line 6). Line 7 presents the corresponding algorithm for population repair to maintain the stability and diversity of the population, and line 8 presents the corresponding algorithm for individual repair to meet the solving goal requirements. When the evolutionary process meets the termination condition, MEAF outputs the optimal solution.

Algorithm 1: MEAF

Input: Problem description, requirements for the solution, end the condition;

Output: Optimal solution;

//(1) Initialization 1  Create a membrane structure and initial population;

2  Repeat

//(2) Evolving each membrane in parallel

3    Fusion Operator: random or selecting the membrane for fusion according to the correlation between the membranes;

4    Division Operator: random or selecting the membrane for division according to the adaptability of the membrane;

5    Cytolysis Operator: random or selecting the membrane for cytolysis according to the adaptability of the membrane;

6    Selection Operator: expanding the membrane with high adaptation;

//(3) Repairing population

7    Repair the population to maintain its stability and diversity;

8    Repair the individual (membrane) to meet the solving objectives;

9  Until meeting the end conditions;

10 Return optimal solution.

Figure 3 shows an example of MEAF initialization with a population size of n. The initial population is composed of membranes M₁ to M_n, denoted as P = {M₁, M₂, ..., M_n}. For any M_i (1 ≤ i ≤ n), its set of objects may be a solution to the problem. The ‘best’ is a special membrane whose object set is the optimal solution obtained by the population evolution to the current stage, which serves as the output membrane of the algorithm to output the solution results.

MEAF only provides a framework for membrane evolution algorithms, where evolution operators, repair methods, and algorithm completion conditions are all related to the specific problem to be solved. This paper is based on the MEAF to study the MEA for solving the MVC of large-scale sparse graphs.

2.2. Some Algorithms for Solving MVC

This section will first introduce the relevant definition of the study of the MVCP in Section 2.2.1. After that, a brief introduction to some MVC solvers in Section 2.2.2.

2.2.1. MVCP

The MVCP can be described as follows: for an undirected graph G(V, E) (where V is the vertex set of G and E is the edge set of G), find a vertex set V₀ ⊆ V with the least number of vertices so that for any edge e ∈ E, e has at least one endpoint that belongs to V₀. In this paper, we will use the following terms and symbols [13]:

① graph: G = (E, V) indicates an undirected graph. V(G) is the set of all vertices in graph G, and E(G) is a set of all edges in graph G.

② neighbors of vertices: For v ∈ V(G), the neighborhood of v is denoted by N(v) = {u|u ∈ v(G) & < u, v > ∈ E(G)}, and the closed neighborhood of v is denoted by N[v] = {v} ∪ N(v).

③ degree: The number of elements in set A is recorded as |A|. The degree of vertex v is denoted by d(v) = |N(v)|.

④ vertex cover and minimum vertex cover: VC(G) is a vertex cover of G, if ∀ e ∈ E(G), and at least one endpoint of e belongs to VC(G). The vertex cover of G with the smallest vertex number is called the minimum vertex cover of G, denoted as MVC(G).

⑤ induced subgraph: Assuming V’ ⊂ V(G), the induced subgraph of V’ is denoted by G’ = G(V’), where V(G’) = V’ and E(G’) = {<v, u>|u, v∈ V’&<v, u>∈ E(G)}.

⑥ the bipartite graph: If V (G) can be divided into two independent sets, X and Y, each edge of G connects one vertex in X to one vertex in Y [25].

⑦ anti-edge: An anti-edge is a pair of nonadjacent vertices in G [26]. The set of anti-edges in G is denoted as Ē(G).

⑧ maximum matching: M(G) ⊂ E(G) is called a match of G if any two edges in M(G) do not have a common endpoint. If |M(G)| is not less than the size of any matching of G, M(G) is called the maximum match of G and is denoted as MaxM(G).

2.2.2. Some MVC Solvers

The authors of [13] proposed an MVC solution framework called PEAF, which is divided into three stages: preprocessing, solving, and reverse processing. To reduce the size of the graph, it is usually necessary to simplify the graph [27,28].

In the preprocessing stage, the preprocessing algorithm (Prep) simplifies the graph G to G’ and records the reduction information in Info. In the solving stage, the exact algorithm or approximation algorithm is used for different types of connected components of G’ to obtain the MVC set C’. In the reverse processing stage, the MVC of the original graph G is obtained based on C’ and Info.

FastVC2 [8] is improved based on FastVC. The initial solution is not constructed with the EdgegreedyVC. Still, the best solution for the three solutions generated by EdgeGreedyVC, GreedyVC+, and MatchVC+, three constructors, is used as the initial local search solution. In the same way, the NumVC2 algorithm is improved based on NumVC, and its improvement method is the same as the FastVC2.

FastVC2+P and NumVC2+P are designed to integrate the preprocessor D1 + D2 + DOM into the FastVC2 and NumVC2 algorithms. The preprocessor simplifies the input graph into a smaller graph and then solves it through a local search algorithm. Finally, the fixed vertices in the preprocessing process and the vertex cover returned by the local search algorithm of the simplified graph form the vertex cover of the original graph. The experimental results show that NumVC2+P and FastVC2+P have further improved the performance of large-scale graphs.

Meta vertex cover (MetaVC) [12] is a meta-interpreter providing top-level design. Each essential function is abstract and can be instantiated with specific functions. The top-level design of MetaVC includes three primary stages: preprocessing, construction, and search. In preprocessing, the given graph is simplified. In construction, the initial vertex cover is an excellent start to get the subsequent local search process. MetaVC executes local search to iterate the optimization vertex cover in the search phase. MetaVC achieves performance comparable to FastVC2+P in large instances. However, during the automatic configuration, MetaVC will waste a lot of time evaluating the bad configuration of the given target algorithm.

MetaVC2 is MetaVC, which can be obtained from the enhanced automatic configuration method. MetaVC2 uses a neural network-based approach to identify and terminate the target algorithm that is not optimistic during configuration. In most instances of REAL-WORLD-HARD, MetaVC2 is significantly better than MetaVC.

Overall, NuMVC2+p, FastVC2+p, and MetaVC2 have been the most competitive solvers for MVC in recent years. The three solvers can obtain solutions of the same quality in a majority of instances from REAL-WORLD-HARD. As for the average running time of the same instance, FastVC2+p is faster than NuMVC2+p and MetaVC2. MetaVC2 is able to improve the best-known solutions for 16 large MVC instances.

3. A MVC Solver Based on MEA—Q-MeaMetaVC

This section discusses the Q-MeaMetaVC solver proposed in this paper in detail. It includes membrane structures, evolutionary algorithms, and evolutionary operators.

3.1. Membrane Structure

We found that multiple instances contained many bipartite connected components during the experiment. Therefore, we designed different membrane structures for bipartite and non-bipartite graphs.

Q-MeaMetaVC is a cell-like membrane system, and its membrane structure is shown in Figure 4.

The following types of membranes are included in Q-MeaMetaVC:

① E membrane: Environmental membrane.

② P membrane: The interior of the P membrane includes graph G (G is the original graph to be solved), C_i membrane, CB_j membrane, and an Answer membrane. The P membrane is responsible for reducing graph G using PreP, constructing the C_i and CB_j, and obtaining the solution of the original problem using Inv_PreP after all C_i membranes and CB_j membranes are solved.

③ C_i membrane: A membrane that solves the vertex cover of the non-bipartite graph-connected component.

④ CB_j membrane: A membrane that solves the vertex cover of the connected component of the bipartite graph.

⑤ Answer membrane: The output membrane of the final result, whose object set consists of a vertex set and an information set.

3.1.1. C_i-membrane Structure Definition of Non-Bipartite Graph

The membrane structure of non-bipartite graph-connected component C_i is shown in Figure 5. Its object set includes M membrane (M₁—M_N), M’ membrane (M_1′—M_N’), good membrane (good₁—good_N), and one best membrane, where the number of M is 3*N, and M’ and good membranes are the same as M. N is a positive integer, taking values 1, 2, 3....

① M_j membrane: The M_j in C_i is responsible for searching the vertex cover of G(V_i). The object set of each M_j is a vertex set. When this set is a vertex cover, it is said that this M_j membrane has found a vertex cover.

② good_j membrane: A good_j is a copy of the optimal solution of its corresponding M_j (for example, C₁.good₁ is a copy of the optimal vertex cover that C₁.M₁ has searched).

③ M_j’ membrane: The M_j’ stores the vertices of its corresponding M_j last divided. Since there is only one element, the name of the M_j’ indicates the vertices stored in it.

④ best membrane: Each C_i has a best membrane, which is a copy of the optimal vertex coverage found by all M_j in it.

In Q-MeaMetaVC, there are also several groups of populations composed of membranes (a collection of membranes), which are as follows:

① CP: A population composed of C_i membranes in the P membrane.

② CBP: A population composed of CB_j membranes in the P membrane.

③ MP: A population composed of M_j membranes in each C_i membrane.

④ MP’: A population composed of M_j’ membranes in each C_i membrane.

⑤ GOODP: A population composed of good_j membranes in each C_i membrane.

Special instructions:

Group: This paper uses the concept of group evolution, and each group consists of three membranes (M₁–M₃ constitutes Group₁, M₄–M₆ constitutes Group₂, and so on). The size of groups is N in each C_i.

3.1.2. Definition of CB_j Membrane Structure of the Bipartite Graph

The CB_j membrane structure for processing the bipartite graph-connected component is shown in Figure 6. Its object set includes the X, Y, X’, Y’, MaxM, and best membrane.

① X and Y membranes: Their object sets are two independent sets of bipartite graphs.

② X’, Y’ membrane: The inner object set is the unmatched vertex set in X and Y, respectively.

③ MaxM membrane: It is the maximum matching membrane, which stores the maximum matching vertices of the bipartite graph.

④ best membrane: Its objects are included in the minimum vertex cover.

3.1.3. Intramembrane Objects and Operations

Objects in Q-MeaMetaVC include membranes, vertices of the graph, and information storage class objects. In particular, V_i is used to represent the vertex set formed by the vertices of the connected component in the graph.

We define operations on membrane objects to include the following:

① A − B: If both A and B are membranes, it means removing all objects in B from A; if A is a membrane, it means removing object B from A.

② A + B: If B is a membrane object, it means adding all objects in B to A. Otherwise, it means adding B objects to A.

③ A = B: If B ≠ ⌀, it means that A becomes a copy of B, A membrane is cleared, and the object set of B membrane is completely copied into the A membrane. Otherwise, it means that the A membrane and all objects inside the A membrane are deleted.

④ A: Unless otherwise specified, it means all element sets inside the A membrane.

⑤ A.B: If B is an object, it means the B object in the A membrane; if it is a population, it means the B population in A; otherwise, it means the entire element set of the B membrane in the A membrane. All occurrences of “E.P.” are omitted in this paper.

⑥ $S\stackrel{O}{\to }D$: transfer o (object or object set) from $S$ membrane to D membrane.

⑦ N(A): If A is a membrane, it means the neighborhood of objects in the A membrane.

In addition, we use age to represent the period during which the state of an object has not changed (its maintenance is not reflected in the algorithm) and part to define a subset of the element set of a membrane. For example, M.bestPart represents the elements with the highest fitness in the M membrane.

Formula (1) gives the edge set of the connected component to be searched that is not covered by the vertex set of the membrane C_i.M:

UCE(C_i.M) = E(G(V_i)) − E(G(C_i.M))

(1)

Formula (2) gives the fitness of the object o in the C_i.M membrane, which means that changing the state of o in C_i.M leads to a change in the number of edges that the C_i.M membrane cannot cover.

$$fit(o,M)=\left\{\begin{array}{l}\left|\left|\mathrm{UCE}\left(\mathrm{M}\right)\right|-\left|\mathrm{UCE}\left(\mathrm{M}+\mathrm{o}\right)\right|\right|,\mathrm{o}\notin \mathrm{M}\\ \left|\left|\mathrm{UCE}\left(\mathrm{M}\right)\right|-\left|\mathrm{UCE}\left(\mathrm{M}-\mathrm{o}\right)\right|\right|,\mathrm{o}\in \mathrm{M}\end{array}\right.$$

(2)

Formula (3) is used to calculate the adaptability of the M membrane to the environment.

Fit(M) = −|UCE(M)|

(3)

Section 3.4.3 uses Formula (2) to select the vertices that are divided or fused. This operator pays more attention to the fitness of the object in the membrane, and the object with poor fitness will be eliminated. In the cytolysis and selection operators, Formula (3) is used to evaluate the quality of the membrane to formulate an evolutionary strategy.

3.2. Algorithm Description

Based on the membrane structure in Section 3.1 and referring to the PEAVC algorithm [13], Algorithm 2 uses the Q-MeaMetaVC proposed in this paper to solve the MVCP. The processing of Q-MeaMetaVC is divided into four stages: preprocessing stage, bipartite graph solution stage, non-bipartite graph solution stage, and inverse processing stage.

(1)

Preprocessing stage. The P membrane first executes the PreP algorithm to reduce the graph G to obtain the reduced graph G’ and the reduced information set Info (line 1), and then transfers the Info to the Answer membrane (line 3). Populations CBP and CP are constructed to solve bipartite connected components and non-bipartite connected components by ConstructMembrane1 (Algorithm 3) and ConstructMembrane2, respectively (lines 4–6).

(2)

Bipartite graph solution stage. Each CB membrane runs in parallel (line 7), solves its vertex cover with the bipartite graph solver Bipartite_graph (Algorithm 4), and passes the obtained solution into its best membrane (line 8). Subsequently, the Answer membrane adds the set of objects in the CB_j.best membrane (line 9); afterward, the CB_j membrane dissolves (line 10).

Algorithm 2: Q-MeaMetaVC//Membrane evolution algorithm for solving the MVCP

Input: graph G = (V, E), number of groups N, longest running time MRT, number of divisions and fusions in a single iteration iterCount, the number of side extractions bms_e, the number of vertex extractions bms_v, the maximum cytolysis maxReCoustruct;

Output: a coverage of graph G;

(1) Preprocessing: Simplify the scale of the graph

1  <G’ = (V’, E’), Info> = PreP(G);//Refer to the PreP algorithm in [13]

2  Create an empty Answer membrane in the P membrane;

3  $P\stackrel{Info}{\to }Answer$;

//Initialize the membrane structure

4  if G’ is a connected component of a bipartite graph, then

5   CBP = ConstructMembrane1; // Constructing the initial membrane structure of bipartite graphs. Refer to Algorithm 3

6  else CP = ConstructMembrane2; // Constructing the initial membrane structure of the non-bipartite graph. Refer to Algorithm 5

(2) Bipartite graph solution stage

7  for CBj in CBP do://Can be parallelized; the actual implementation is serial processing

8    CBj.best = Bipartite_graph(G(Vj));//Refer to Algorithm 4

9    Answer+ CBj.best;

10    Cytolysis (CBj)

(3) Non-bipartite graph solution stage

//Organize the information

11   if (Ci membrane exists) then

12    vNumLetf = the sum of the number of objects of the Ci membrane;

//Q-Meta search process

13    for Ci in CP do  //can be parallelized; the actual implementation is serial processing

14     MRTi = MRT/vNumLetf * |Vi|;

15     Ci = ConstructMetaPopulations(i, 3*N);  //refer to Algorithm 6

16     repairPopulation(Ci, MP);  //refer to Algorithm 7

17     Repeat

(a) Division and fusion  //parallel

18       Division_and_Fusion(Ci.MP, iterCount, bms_k, bms_e);

(b) Synchronous information retrieval end condition  //serial

19       bestMem = the membrane with the smallest number of elements in Ci.best (when the number of elements is the same, choose the membrane with the shortest time and the fewest search steps);

20        if(|bestMem| < |Ci.best|) Ci.best = bestMem;

//determine whether to terminate

21          if(running time> = MRTi) then:

22           Answer + Ci.best;

23           Cytolysis(Ci);

24           break;

25        repairPopulation(Ci.MP);  //refer to Algorithm 7

(c) selection and Cytolysis  //parallel

26        CytolysisAndSelection(Ci.MP, maxReCoustruct);

27     until false;

(4) Inverse processing stage

28   Inv_PreP(Answer);  //refer to the Inv_PreP algorithm in [13]

29   return Answer.  //output result

(3)

Non-bipartite graph solution stage. It mainly includes information organization and the Q-Meta process.

① Organize information. If C_i membranes exist, count the total number of objects in the C (lines 11–12), and solve the vertex cover it is responsible for in the Q-Meta stage; otherwise, enter the inverse processing stage.

② Q-Meta process. Each C_i membrane will solve the vertex cover of the corresponding connected component. Q-MeaMetaVC allocates the running time of each C_i proportional to the number of vertices of the connected component (line 14). Before searching, use the ConstructMetaPopulation algorithm (Algorithm 6) for C_i to construct MP, GOODP and initialize its best membrane (line 15). After that, Q-MeaMetaVC will use the repair operator (line 16, Section 3.4.2), division and fusion operator (line 18, Section 3.4.3), and the selection and cytolysis operator (line 26, Section 3.4.4) to try to find better vertex cover of G(V_i) until reaching the end condition. The Answer membrane will fuse with the C_i.best membrane (line 22), and then the C_i will lyse itself (line 23). When all C_i is dissolved, it will enter the reverse processing stage.

(4)

Reverse processing stage: The Answer membrane modifies the vertex set according to the information set through the Inv_PreP algorithm so that the vertex set of Answer becomes a vertex cover of the original image (line 28) and finally outputs the result (line 29).

Compared with the PEAVC algorithm [13], Q-MeaMetaVC and PEAVC are both used to solve large-scale sparse graphs, but due to the limitation of FastVC2’s search ability, PEAVC can easily fall into the local optimization. The Q-MeaMetaVC is based on the membrane evolution algorithm, which has the advantages of good flexibility, high search efficiency, and the ability to effectively avoid local optimum effectivel.

Q-MeaMetaVC adopts the BMS strategy of adding vertices in the search stage of MetaVC and the heuristic method of selecting and removing vertices in the Q-Meta stage. For example, when selecting a vertex to join, randomly select an uncovered edge and select a vertex with lower fitness. If the fitness of the two vertices is equal, choose an older endpoint to join. At the same time, selecting a vertex to remove also selects the vertex with the lowest fitness in the candidate subset. If they are equal, select the vertex with older age. The difference between them is that Q-MeaMetaVC mainly has four stages, while MetaVC has only three stages: preprocessing, construction, and search. Q-MeaMetaVC specifically treats bipartite and non-bipartite graphs differently.

3.3. Bipartite Graph Solving Algorithm

This section mainly explains the solution of the bipartite graph, including the creation of the membrane structure, the design of the MVC algorithm for solving the bipartite graph, and the verification of the algorithm’s feasibility through an example analysis.

3.3.1. Create a Membrane Structure

The bipartite graph creates a membrane structure, as shown in Algorithm 3. First, create an empty CB₁ membrane in the P membrane, then construct the X, Y, best, and MaxM membranes in the CB₁ membrane. If there are s connected components of the bipartite graph, copy s-1 CB₁ membranes, and finally return to the CBP membrane.

Algorithm 3: ConstructMembrane1 //Create the membrane structure using the bipartite graph

Input: s

Output: CBP membrane;

1  Create an empty CB1 membrane in the P membrane;

2   Create an X membrane in the CB1 membrane;

3   Create a Y membrane in the CB1 membrane;

4   Create the best membrane in the CB1 membrane;

5   Create a MaxM membrane in the CB1 membrane;

//If there are s bipartite graph-connected components

6  k←2;

7  while k ≤ s do

8   CBP = CB1 U CopyCBtoCB(CB1, CBk);   //copy s-1 CB1

9    k++;

10  end while

11  return CBP membrane;

3.3.2. Algorithm Design

The Bipartite_graph algorithm solves the MVC for each bipartite graph-connected component, as shown in Algorithm 4. First, divide V_j into two independent sets, X and Y, and put them into the corresponding CB_j.X and CB_j.Y membranes, respectively (lines 1–3). Then, use the Hungarian algorithm [29] to find a maximum matching of G(V_j), put the matching vertices into the membrane MaxM (line 4), and record the maximum matching number max (line 5). At the same time, the CB_j.X’ and CB_j.Y’ membranes are initialized with unmatched vertices (lines 6–7). If the CB_j.X’ and CB_j.Y’ membranes are both empty, dissolve the CB_j.X’ and CB_j.Y’ membranes and transfer the objects of the CB_j.X or CB_j.Y membranes to the CB_j.best membrane (lines 8–11). If only one of the CB_j.X’ and CB_j.Y’ membranes is empty, dissolve only one (lines 13–16). Transfer the unmatched neighboring vertices to the CB_j.best membrane. If |CB_j.best| equals max and an MVC has been found, end the process. Otherwise, all vertex neighborhoods from the previous step are considered unmatched vertexes, in which case update the X’ and Y’ membranes (Lines 17–25). Finally, return the CB_j.best membrane, which is the MVC of the bipartite graph.

Algorithm 4: Bipartite_graph(G(Vj)) //Bipartite graph solves MVC

Input: G(Vj);   //Each connected bipartite diagram

Output: CBj.best;

1  Put G(Vj) into the CBj membrane;

//Divide Vj into two independent sets, X and Y, and put them into the corresponding X and Y membrane, respectively.

2  CBj.X←an independent set of Vj in CBj;

3  CBj.Y←all vertex objects in CBj;

4  MaxM←Hungarian(G(Vj));

5  max = |MaxM|/2;

6  CBj.X’←CBj.X-MaxM;

7  CBj.Y’←CBj.Y-MaxM;

8  if (CBj.X’ is empty &&CBj.Y’ is empty) then

9     Cytolysis(CBj.X’);

10   Cytolysis(CBj.Y’);

11   CBj.best+CBj.X;

12  else

13   if(CBj.X’ is empty) then

14    Cytolysis(CBj.X’);

15   if(CBj.Y’ is empty) then

16    Cytolysis(CBj.Y’);

17  n←0;

18  for n < max do

19    CBj.best←N(CBj.X’) U N(CBj.Y’);

20    if(|CBj.best| == max) break;

21    else

22     CBj.X’←N(N(CBj.X’));

23     CBj.Y’←N(N(CBj.Y’));

24    n++;

25  end for

26  return CBj.best membrane;

3.3.3. Example Analysis

This section will use Figure 7 as an example to explain the solution process of the Bipartite_graph algorithm. This graph only has one connected component, so j = 1. First, construct the X, Y, MaxM, and best membranes in the CB₁ membrane, as shown in Figure 8a. Then, place the two independent sets {V₁, V₂, V₃} and {V₄, V₅, V₆, V₇} into the CB₁.X and CB₁.Y membranes, respectively. At the same time, use the Hungarian algorithm to find a maximum matching {(V₁, V₄), (V₂, V₅), (V₃, V₇)} in Figure 7, and put its vertex set into the MaxM membrane. The number of vertices in MaxM is 6, so the value of max is equal to 3. Separate the unmatched vertex V₆ from the CB₁.Y membrane and put it into the CB₁.Y’ membrane. While CB₁.X’ is empty, lyse it, as shown in Figure 8b. Separate the neighborhood V₁ of V₆ from the CB₁.X membrane and put it into the CB₁.best membrane; the vertex must be included in the MVC set. At the same time, take the neighbors V₄ and V₆ of V1 as unmatched vertices, separate them from CB₁.Y, and update CB₁.Y’, as shown in Figure 8c. In the same manner, separate their neighbors V₁ and V₂ from the CB₁.X membrane and put them into the CB₁.best membrane, as shown in Figure 8c. Figure 8d is the final result. The MVC set of the bipartite graph is {V₁, V₂, V₃}.

3.4. Non-Bipartite Graph Solution Algorithm

This section mainly explains the solution of non-bipartite graphs, including the design of the initialization algorithm, repair operator, division and fusion operator, selection, and cytolysis operator.

3.4.1. Initialization Algorithm

The initialization algorithm’s quality significantly impacts the quality of the solution to the MVCP, especially when solving larger instances. Before initialization, the membrane structure needs to be created first, which is performed by the non-bipartite graph, as shown in Algorithm 5.

Algorithm 5: ConstructMembrane2//Non-bipartite graph creates membrane structure

Input: w;  //The number of connected components of the non-bipartite graph

Output: CP membrane;

1  Create an empty C1 membrane in the P membrane;

2   Create an empty best membrane in the C1 membrane;

3   Create an empty M1 membrane in the C1 membrane;

4   Create an empty good1 membrane in the C1 membrane;

5  CP = C1;

6  k←2;

7  for k ≤ w do

8   CK= C1; //copy w-1 C1

9   CP = CP∪Ck;

10   k++;

11  end for

12  return CP membrane;

The literature [8] combines three initialization algorithms—MatchVC+, EdgeGreedyVC, and GreedyVC+—and takes the optimal initial solution, among which the initial solution obtained by GreedyVC+ is the best in most cases and has a certain degree of randomness. Therefore, we use GreedyVC+ to construct M population MP.

ConstructMetaPopulations(Algorithm 6) is responsible for constructing MP populations and GOODP populations for each C membrane (such as C_i membrane) and initializing. Firstly, copy N-1 M₁ membrane and N-1 good₁ membrane (lines 1–2) into the C membrane. Then, for each M_x, use GreedyVC+ to construct a vertex cover of G(V_i) as the element set of M_x to initialize M_x (line 5), and make the good_x membrane save a copy of M_x membrane (line 6). Finally, the best membrane saves a copy of the optimal M membrane (line 8).

Algorithm 6: ConstructMetaPopulations  //Population initialization algorithm

Input: i, population size NP;

Output: Ci membrane;

1  Ci.MP = {M1,M2,..,MNP};

2  Ci.GOODP = {good1,good2,...,goodNP};

3  x←1;

4  for x≤ NP do

5   Mx = GreedyVC+(G(Vi));

6   goodx = Mx;

7  end for

8  Ci.best = the optimal M membrane in MP;

9  return Ci membrane;

3.4.2. Repair Operator Implementation

The significance of the repair operator is to ensure that the membranes in the population maintain certain characteristics. Q-MeaMetaVC ensures that the number of elements per membrane is one less than the size of the smallest vertex cover currently found to ensure convergence. For each iteration of the C membrane, Q-MeaMetaVC will use the optimal search results to update the optimal population solution C.best membrane (Algorithm 2, lines 19–20) and then repair the entire population (Algorithm 2, line 25) so that the number of elements in all M membranes is |C.best|-1 (Algorithm 7, lines 1–2), and the same is actual in the process of cytolysis and selection (Algorithm 13, Line 7).

Algorithm 7: repairPopulation//Population repair algorithm

Input: Population C.MP;

Output: population;

1  for ∀ C.Mi in C.MP do

2   repairIndividual(C.Mi,|C.best|-1);

3  return C.MP;

Algorithm 8 is the process of repairing a single membrane. Because of the greedy strategy adopted, the complexity is high, so after updating the optimal solution (Algorithm 9, line 4) and selecting the solution (Algorithm 13, line 7). Every time add the highest fitness vertex(lines 6–7) or remove the lowest fitness vertex (lines 2–3) so that the number of elements in the M membrane reaches the target value. To avoid circular searching, elements with an age of 0 (whose state has just changed during the current iteration) will not be selected.

Algorithm 8: repairIndividual//Individual repair algorithm

Input: M membrane, Ci.Mj membrane, target size targetSize;

Output: M membrane;

1  while |Ci.Mj| > targetSize do

2   v = age > 0 in Ci.Mj and the vertex with the smallest fitness, when the fitness is the same, select the element with older age;

3   Ci.Mj-v;

4  end while

5  while |Ci.Mj| < targetSize do

6   v = age > 0 in Vi-Ci.Mj and the vertex with the largest fitness, select the element with older age when the fitness is the same;

7   Ci.M+v;

8  end while

9  return Ci.Mj membrane;

3.4.3. Implementation of Division and Fusion Operator

The division operator refers to dividing a membrane to form a new one. The fusion operator refers to the combination of two membranes into a new membrane, and the object set of the new one is the union of the object sets of the two membranes. If the utilization of the membrane is improved, the fusion operator will not destroy the fused membrane. Referring to local search, the M membrane of Q-MeaMetaVC will divide an element each time, and the divided element will be placed in the population MP’ and then try to fuse the membranes in MP’. As shown in Algorithm 9, each M membrane is executed in parallel. If the M finds an MVC, back up the elements in the M (line 3) and adjust the number of elements (line 4). Afterwards, split an element (line 5) through the division operator (Algorithm 10). Then, add an element (line 6) through the fusion operator (Algorithm 11).

Algorithm 9: Division and Fusion

Input: population Ci.MP, number of iterations iterCount, edge extraction times bms_e, vertex extraction times bms_v;

Output: population Ci.MP;

//Each Ci.Mj membrane is executed in parallel

1  i = 1;

2  for i ≤ iterCount do

3   while(UCE(Ci.Mj) == 0) do:

4    Ci.bestj= Ci.Mj;

5    repairIndividial(Ci.Mj, |Ci.bestj|-1);

6   end while

7   Division(Ci.Mj, bms_e);

8   Fusion(Ci.Mj, bms_e);

9   i++;

10 end for

11 return population Ci.MP;

This paper adopts the BMS strategy to divide an element with low fitness in a short time overhead to improve efficiency. Refer to Algorithm 10 for the division operator: when the number of elements in the M membrane is less than bms_v, the candidate subset S is all the elements in the M membrane. Otherwise, it is a set composed of bms_v elements extracted from S (line 1); the M membrane will split out an element with the lowest fitness in S and select the older element when the fitness is the same (lines 2–3). The split element will be put into the membrane M’ (line 4).

Algorithm 10: Division

Input: M membrane Ci.Mj, vertex extraction times bms_v;

Output: M membrane;

1  S = |Ci.Mj|> k ? A set composed of randomly selected bms_v vertexes from Ci.Mj: Ci.Mj;

2  bestv = an element with the lowest fitness in S, select the element with the older age when the fitness is the same;

3  Ci.Mj-bestv;

4  Ci.Mj’ = bestv;

5  return Ci.Mj membrane;

The fusion operator is shown in Algorithm 11: first, select the membrane element with the highest fitness in the membrane population MP’ (if the fitness is the same, select the older one) (line 2); if its fitness is greater than the most recently split element, the M membrane will add this element (lines 3–4); otherwise, it will add an element through the quik_ AddOne operator (line 5, Algorithm 12).

Algorithm 11: Fusion//Membrane fusion operator

Input: M membrane Ci.Mj, edge extraction times bms_e;

Output: M membrane;

1  droppedv = element in Ci.Mj’;

2  bestv = Ci.MP’ is the element in the membrane with the highest fitness; when the fitness is the same, select the element with older age;

3  if fit(bestv, Ci.Mj)>fit(dropedv, Ci.Mj) then

4   Ci.Mj+bestv;

5  else quick_AddOne(Ci.Mj, bms_e);

6  return Ci.Mj membrane;

Considering that the research problem is to solve the vertex cover of a large-scale sparse graph, the division and fusion operator are called frequently to ensure that the M is characterized by the number of elements that is one less than the size of the currently found MVC during the division and fusion process. To improve the efficiency of the Q-MeaMetaVC algorithm, we specifically designed the quick_AddOne algorithm, as shown in Algorithm 12.

Algorithm 12: quick_AddOne

Input: M membrane, edge extraction times bms_e;

Output: M membrane;

1  S_e = |UCE(M)| > bms_e ? Randomly extract a set composed of bms_e times from UCE (M):UCE(M);

2  beste = the oldest edge in S_e;

3  v = beste is the endpoint with higher fitness, and the endpoint with the same fitness is the older endpoint;

4  M + v;

5  return M membrane;

When the number of elements in the M membrane is less than bms_e, the candidate edge set S_e is all the edges in UCE(M). Otherwise, it is a set composed of extracting bms_e edges from S_e (line 1). M membrane adds an endpoint with a higher adaptation of the oldest edge, and the older endpoint is selected when the adaptation is the same (lines 2–4).

3.4.4. Selection and Cytolysis Operator

The original definition of the cytolysis operator is to lyse the worst membranes in some populations, while the selection operator will amplify the best membranes in some populations. Q-MeaMetaVC optimizes this concept. The cytolysis operator of Q-MeaMetaVC will lyse part of the membrane to make it jump out of the local optimum. For other membranes, refer to one part of the reference object set in the best membrane to add part of the selection.

As shown in Algorithm 13 Q-MeaMetaVC divides MP into multiple groups, each composed of three M membranes. The CytolysisAndSelection algorithm will try to make the three membranes in each group search in three directions. The membrane with the highest fitness is good enough, so the cytolysis operator (Algorithm 14) is used to discard min(maxReCoustruct, min(|M|,|V_i|−|M|)/2) elements to destroy its structure (line 3). The membrane with the second highest fitness uses the selection operator (Algorithm 15) to expand the “good” information (line 5, bestPart represents the set of elements with the highest fitness in the bestMem membrane). The membrane with the lowest fitness will expand the “bad” information and try to search from the opposite direction (line 6, worstPart represents the set of elements with the lowest fitness in the bestMem membrane). Such a design will expand the search space of Q-MeaMetaVC and avoid excessive similarity between membranes to a certain extent.

Algorithm 13: Cytolysis and Selection

Input: Population Ci.MP, maximum dissolved amount maxReCoustruct;

Output: population;

# each group Groupi in Ci. MP executes concurrently

1  bestMem = the membrane with the highest fitness in Groupi;

# Each membrane Mx in Groupi executes in parallel

2   if Fit(Mx) is the largest in Groupi then

3    Cytolysis(Mx,min(maxReCoustruct,min(|Mx|−|Vi|−|Mx|)/2));

4   else if Fit(Mx) is the second largest then in Groupi:

5    Selection(Mx, bestMem, bestPart);

6   else Selection(Mx, bestMem, worstPart);

7   repairIndividial(Mx,|bestMem|);

8  return Ci.MP;

The cytolysis operator is shown in Algorithm 14; the M membrane will randomly discard dropCount elements.

Algorithm 14: Cytolysis operator

Input: M membrane, dissolved amount dropCount;

Output: M membrane;

1  i = 1;

2  for i ≤ dropCount do

3   v = a random element in M;

4   M−v;

5   i++;

6  return M membrane;

The selection operator is shown in Algorithm 15. The M membrane will refer to an element set part and add elements v (fitness(v, M)! = 0), which the M membrane does not have and which are not completely unable to adapt (lines 1–3).

Algorithm 15: Selection operator

Input: M membrane, membrane fragment part;

Output: M membrane;

1  for each object v in part do

2   if(v does not belong to M and fitness(v, M)! = 0);

3    M + v;

4 return M membrane;

4. Example Analysis

This section will take the undirected graph in Figure 9a as an example to explain the solution process of Q-MeaMetaVC (v_i is numbered i in the figure). Figure 10 and Figure 11 show how Q-MeaMetaVC operates in one cycle; the parameters are N = 1, bms_v = 720, bms_e = 50, and dropCount = 76.

The process of Q-MeaMetaVC execution is as follows:

① Initially, graph G is in the P membrane, as shown in Figure 10a.

② Preprocessing: First, use PreP for pretreatment in the P membrane; because N[v₂₈]⊆N[v₂₇], v₂₇ is the dominant vertex. After deleting v₂₇, v₂₉ is the dominant vertex, so continue to delete v₂₉. PreP can no longer reduce G, and the preprocessing stage is over. The result of graph G reduction is shown in Figure 9b, and the membrane structure at this time is shown in Figure 10b.

③ The simplified graph of CP and CBP structure is shown in Figure 9b. The vertices of different connected components belong to different C membranes; v₁~v₂₀ and v₂₁~v₂₆, respectively, belong to different connected components (G(V₁) and G(V₂) (V₁ = {v₁, v₂, v₃, v₄, v₅, v₆, v₇, v₈, v₉, v₁₀, v₁₁, v₁₂, v₁₃, v₁₄, v₁₅, v₁₆, v₁₇, v₁₈, v₁₉, v₂₀}, V₂ = {v₂₁, v₂₂, v₂₃, v₂₄, v₂₅, v₂₆ })), so two C membranes are generated, C₁ and CB₁, responsible for solving the MVC of G(V₁) and G(V₂), respectively. In addition, the Answer membrane is generated to store the solved vertex cover, and the Info is passed to Answer. The membrane structure constructed is shown in Figure 10c.

④ Bipartite graph solution stage: After preprocessing, different C membranes are responsible for solving different connected components so that all C membranes will be judged in parallel. In Figure 9b, G(V₂) is a bipartite graph, so using Bipartite_graph to obtain its MVC set is {v₂₁, v₂₂, v₂₃}, and it will be transferred to the Answer membrane. Then, the CB₁ membrane lyses itself. The membrane structure after this stage is shown in Figure 10d.

⑤ Sort out the information stage: After the bipartite graph branches are solved, the sum of the vertex of the remaining connected components is counted, and vNumLeft is 20.

⑥ Q-Meta search stage: First, the search time of each C_i membrane is allocated according to the number of vertices of connected components. The search time of C₁ MRT₁ = 3600s.

(6.1) Construct MP: Since the parameter N = 1, ConstructMetaPopulation will construct three M membranes (M₁, M₂, and M₃) in the C₁ membrane through the GreedyVC+ algorithm: three good membranes (good₁, good₂, good₃) and the best membrane, where the good_i membrane is a copy of the M_i, and the best membrane is a copy of the optimal good_i membrane. The result is shown in Figure 11a.

(6.2) Population repair: As shown in Figure 11b, before using the four evolution operators in parallel to search, the repairPopulation algorithm is used to control the number of the M membrane elements. Because |best| = 13, M₁ discards the v₁₈ with the worst fitness, M₂ discards v₈, and M₃ discards v₃ (all discarded vertices are marked in orange). Finally, the number of vertices for all M membranes is 12 (|best|−1).

(6.3) Division: Since the number of objects in the M membrane is less than the parameter bms_v (720), the M₁ membrane splits v₁₅, an element with the lowest fitness, into M₁’; similarly, M₂ transfers v₁₆ to M₂’, and M₃ splits v₁₅ to M₃’ (all splitted vertices are marked in blue), as shown in Figure 11c.

(6.4) Fusion: Since the element v₁₆ (green mark) in M₂’ has a higher fitness than the element v₁₅ just split from M₁ (fitness(v₁₆, M₁) = 2, fitness(v₁₅, M₁) = 1), M₁ will merge a copy of M₂’, while M₂ and M₃ cannot find such elements in MP’. The membrane structure is shown in Figure 11d.

(6.5) Fast addition: Since |M₂|<|best₂|-1, quickly add elements using the quick_AddOne algorithm. Ē(M₂) = {<v₂, v₈>, <v₁₅, v₁₆>}, |Ē(M₂)|<bms_e, so find the oldest edge <v₂, v₈>. Because the two endpoints have the same fitness (fitness(v₂, M₂) = 1, fitness(v₈, M₂) = 1), add an older endpoint v₂ (red mark) to M₂. Similarly, add v₄ to M₃. The membrane structure is shown in Figure 11e. At this time, |UCE(M₁)| = 0, |UCE(M₃)| = 0, M₁ and M₃ have found a better vertex cover. Then, back up this solution, control the number of elements, and start the next round of iterations (starting from stage 6.3) until the number of iterations reaches iterCount. Carry out the synchronization work of the global information. When the termination is reached, enter stage ⑦; otherwise, enter stage (6.6).

Assume that on a certain search path, the membrane structure changes as shown in Figure 12a. After jumping out of the division and fusion stage, the termination condition is not reached, and enters the selection and cytolysis stage (as shown in Figure 12).

(6.6) Selection and cytolysis: Since the number of membranes is 3, M₁, M₂, and M₃ form a unique group. Fit(M₁) = −1, Fit(M₂) = −2, Fit(M₃) = −4. Because M₁ has the highest fitness, it will break the local optimum through the cytolysis operator; M₂ has the second-best fitness, so it will refer to M₁.bestPart ({v₂₀}, the set of vertexes with the highest fitness) by selection operator to optimize itself. Similarly, the fitness of M₃ ranks third, so it will refer to M₁.worstPart ({v₁, v₃, v₄}, a set of vertexes with the lowest fitness) to optimize itself by selection operator. M₁ randomly discards four objects {v₁, v₇, v₉, v₁₅}; M₂ selects the objects ({v₂₀}) in M₁.bestPart that are not in M₂ and whose fitness is not 0 one by one, and copies them to the membrane; M₃ selects and copies the objects in M₁.worstPart that are not in M₃ and whose fitness is not 0 to the membrane (add v₃ first, then add v₁). The membrane structure at this time is shown in Figure 12b. The vertices that change during this process are marked in purple.

(6.7) Repair after selection and cytolysis: After the selection and cytolysis phase, each M membrane is repaired by a greedy strategy so that the number of membranes is |best|-1. M₁ adds v₁₆(fitness(v₁₆, M₁) = 2), v₈(fitness(v₈, M₁) = 2), v₁₀(fitness(v₁₀, M₁) = 1), v₁₂(fitness(v₁₂, M₁) = 2); M₂ removes v₁₉(fitness(v₁₉, M₂) = 0); M₃ removes v₁₂(fitness(v₁₂, M₃) = 0), v₁₀(fitness(v₁₀, M₃) = 0) in sequence. The membrane structure at this time is Figure 12c shows. The vertices that change during this process are marked in orange.

Then, the division and fusion stage is entered (stage 6.3). During the first round of division and fusion, M₁ splits v₁₃ (fitness(v₁₃, M₁) = 1); M₂ splits v₃ (fitness(v₃, M₂) = 0); M₃ splits v₃ (fitness(v₃, M₂) = 0), and the result is shown in Figure 12d (all splitted vertices are marked in blue). Subsequently, because the elements of each sub-membrane in MP’ have no value to M₁, M₂, M₃ (the elements just split or the existing elements), with the help of the quick repair operator, M₁ adds v₁₄; M₂ adds v₂; and M₃ adds v₂. The membrane structure at this time is shown in Figure 12e (quickly added vertices are marked in red), where |UCE(M₁)| = 0, |UCE(M₂)| = 0, |UCE(M₃)| = 0. So far, all three membranes have found better MVC.

⑦ End of iteration: After the iteration, the membrane structure is shown in Figure 13a, and C₁ will transfer the object set in its best membrane to the Answer membrane and dissolve itself, as shown in Figure 13b.

⑧ Reverse processing: When no C_i membrane survives, the reverse processing program starts, and the vertex set in the Answer membrane is modified according to the information in the Info set through the Inv_PreP algorithm. The Answer membrane obtains a vertex cover of the original instance as shown in Figure 13c, so the vertex cover in Figure 9a solved by Q-MeaMetaVC is {v₁, v₂, v₄, v₆, v₇, v₉, v₁₁, v₁₃, v₁₅, v₁₇, v₁₈, v₂₀, v₂₁, v₂₂, v₂₃, v₂₇, v₂₉}.

5. Analysis of Experimental Results

5.1. Experimental Environment

In this paper, PreP is used as the preprocessor in the experiment. The test consists of 35 instances in the REAL-WORLD benchmark with connected components of a non-bipartite graph after the PreP reduction (called the test set).

This paper compares Q-MeaMetaVC based on the membrane evolution algorithm framework with several excellent local search algorithms (FastVC2+p, NuMVC2+p, PEAVC, MetaVC, MetaVC2). The experimental results of FastVC2+p and NuMVC2+p in the literature [8], the experimental results of MetaVC and MetaVC2 in the literature [12], and the experimental results of PEAVC in the literature [13] are used. FastVC2+p and NuMVC2+p are implemented in C++, g++ (version 4.4.5) compiled with the ‘-O3’ option. The relevant experiments in [14] were carried out on a computer cluster. Each computer in the cluster was equipped with a 32-core Intel Xeon E5-2683 CPU and 94 GB memory, and the operating system was CentOS 7.6.1810. Both PEAVC and Q-MeaMetaVC are implemented in C++ language, compiled by g++ (6.3.0 version), with ‘-O3’ option, and executed on a server with a 6-core Intel Xeon (Cascade Lake) Platinum 8269CY 2.5GHz CPU under Ubuntu Linux (version 16.04).

All experiments were performed ten times in each instance (with random number seeds 1, 2, ..., 10, respectively) (MetaVC and MetaVC2 were performed 100 times). The local search time of MetaVC, MetaVC2, and PEAVC is limited to 3600 s, so the parameter MRT of Q-MeaMetaVC is set to 3600.

For each solver on each instance, three metrics are evaluated in this chapter:

“Minimum” means the smallest value for the vertex cover size found by the solver in multiple runs.

“Average” means the average value of the scale of the vertex cover obtained by the solver in multiple runs.

“Time” represents the average effective run time (the time, in seconds, to find the final solution in each execution) of multiple experiments.

The given tables show the best results for each instance in bold. The minimum run time for each instance is also in bold.

5.2. Experimental Results and Analysis

5.2.1. Q-MeaMetaVC Parameter Experiment

Since there are many parameters to be trained in MetaVC2, we trained MetaVC2 on a computer cluster for two days. Each computer in the group is equipped with a 32-core Intel Xeon E5-2683 CPU and 94 GB of memory. Considering that the research dataset is mainly REAL-WORLD-HARD, the relevant parameters of Q-MeaMetaVC follow the results of MetaVC2 (bms_v = 720, maxReConstruct = 76). When bms_e is 50, there is a 99.5% probability of selecting an edge with an age of 10%, so the parameter bms_e = 50. We only conduct experiments for the parameter N and the number of iterations iterCount.

In this section, experiments are carried out in cases where N is 1, 2. The detailed experimental results are shown in

Table 1. The experimental results of Q-MeaMetaVC under different “N”.

Instances	1	2
inf-roadNet-CA	999,513.7/999,509/1144.41	999,512.8/999,509/902.15
inf-roadNet-PA	554,210.3/554,205/882.88	554,207.8/554,205/1111.63
inf-road-usa	11,519,304.8/11,519,293/767.01	11,519,278.1/11,519,268/720.8
sc-nasasrb	51,239.6/51,238/1054.64	51,239/51,238/1015.19
sc-pkustk13	89,218.3/89,217/842.32	89,217.9/89,217/718.53
sc-pwtk	207,681.4/207,679/1427.4	207,680.8/207,679/1387.16
sc-shipsec1	117,020.3/117,002/2856.26	117,022.2/117,006/3213.08
sc-shipsec5	146,862/146,844/2961.84	146,862.6/146,851/2688.26
soc-delicious	85,298/85,298/0.6	85,298/85,298/1.07
soc-digg	103,234/103,234/1.05	103,234/103,234/1.05
socfb-Berkeley13	17,209.9/17,209/139.89	17,209.6/17,209/868.77
socfb-CMU	4986/4986/2.21	4986/4986/0.98
socfb-Duke14	7683/7683/2.76	7683/7683/2.18
socfb-Indiana	23,313.7/23,313/988.93	23,313.6/23,313/826.84
socfb-MIT	4657/4657/0.57	4657/4657/0.31
socfb-OR	36,547/36,547/15.17	36,547/36,547/8.75
socfb-Penn94	31,158.3/31,157/1608.51	31,158.2/31,157/1069.04
socfb-Stanford3	8517/8517/65.06	8517/8517/24.67
socfb-Texas84	28,164.4/28,164/1673.96	28,164.3/28,164/1398.75
socfb-UCLA	15,221.8/15,221/495.23	15,221.4/15,221/1038.04
socfb-UConn	13,230/13,230/215.43	13,229.8/13,229/180.76
socfb-UCSB37	11,261/11,261/22.04	11,261/11,261/11.69
socfb-UF	27,303.8/27,303/1061.81	27,303.5/27,303/1566.06
socfb-UIllinois	24,089.8/24,089/1705.03	24,089.9/24,089/1121.46
socfb-Wisconsin87	18,382.7/18,382/410.9	18,382.3/18,382/1132.81
soc-flickr	153,271/153,271/0.47	153,271/153,271/0.47
soc-gowalla	84,222/84,222/0.1	84,222/84,222/0.09
soc-livejournal	1,868,903/1,868,903/6.16	1,868,903/1,868,903/6.08
soc-orkut	2,170,999/2,170,901/4100	2,171,077.1/2,171,040/4111.31
soc-pokec	843,367.2/843,360/2637.71	843,366.2/843,361/2735.03
tech-as-skitter	525,027.8/525,026/7.27	525,027/525,026/6.75
tech-RL-caida	74,599.2/74,598/0.3	74,598.8/74,598/0.27
web-it-2004	414,507/414,507/0.57	414,507/414,507/0.57
web-sk-2005	58,173/58,173/0.8	58,173/58,173/0.59
web-wikipedia2009	648,294/648,294/3.04	648,294/648,294/1.95

Average/Minimum/Time. Bold represents the best result and the minimum run time for each instance.

(when N is 1, the sub-thread of a single program is 3, so four programs run at the same time; when N is 2, the number of sub-threads of a single program is 6, so two programs run at the same time).

When N = 1, Q-MeaMetaVC obtains a better minimum value of the quality of the solution in more instances. Although the average quality of solutions obtained by N = 2 in a large number of instances (17/35) is better, Table 1 shows that the average quality of solutions obtained by Q-MeaMetaVC at N = 2 is limited (with a difference of less than or equal to 1 point) in most of the instances (16/17). This article aims to find a solver that performs better in terms of the quality of the optimal solution, so N = 1 is chosen.

Figure 14 compares the minimum and average values of the solution quality obtained by Q-MeaMetaVC under different parameters N. Where the number indicates the number of instances, the black color block indicates the better quality of the solution when N = 1, and the light gray indicates that the quality of the solution obtained by N = 1 and N = 2 is the same, and dark gray indicates that solutions with N = 1 are of worse quality.

In this paper, experiments are carried out in the cases where the iterCount is 15,000, 30,000, 45,000, and 60,000. The detailed experimental results are shown in

Table 2. The experimental results of the Q-MeaMetaVC experimental results under different iterCoun.

Instances	15,000	30,000	45,000	60,000
inf-roadNet-CA	999,512.9(999,510)1050.04	999,513.7(999,509)1144.41	999,519.2(999,513)1131.58	999,519.6(999,511)1129.13
inf-roadNet-PA	554,207.9(554,205)901.93	554,210.3(554,205)882.88	554,211.4(554,208)1268.53	554,213.1(554,210)1035.96
inf-road-usa	11,519,281.2(11,519,273)692.58	11,519,304.8(11,519,293)767.01	11,519,315.1(11,519,303)822.2	11,519,334.6(11,519,324)851.13
sc-nasasrb	51,241.6(51,241)838.57	51,239.6(51,238)1054.64	51,238.8(51,238)935.8	51,238.7(51,238)1217.07
sc-pkustk13	89,220.2(89,220)1449.56	89,218.3(89,217)842.32	89,217.7(89,217)659.31	89,217.1(89,217)1389.19
sc-pwtk	207,682.3(207,681)1654.35	207,681.4(207,679)1427.4	207,681(207,679)1363.19	207,681.1(207,677)1660.61
sc-shipsec1	117,027.8(117,008)2799.44	117,020.3(117,002)2856.26	117,028.8(117,010)3193.93	117,038.2(117,020)2840.11
sc-shipsec5	146,863.1(146,837)2922.88	146,862(146,844)2961.84	146,870.9(146,844)2862.5	146,880.6(146,858)2717.67
soc-delicious	85,298(85,298)0.42	85,298(85,298)0.6	85,298(85,298)3.99	85,298(85,298)0.44
soc-digg	103,234(103,234)1.05	103,234(103,234)1.05	103,234(103,234)1.05	103,234(103,234)1.05
socfb-Berkeley13	17,209.8(17,209)465.36	17,209.9(17,209)139.89	17,209.5(17,209)1032.55	17,209.6(17,209)630.78
socfb-CMU	4986(4986)2.36	4986(4986)2.21	4986(4986)4.54	4986(4986)2.56
socfb-Duke14	7683(7683)3.73	7683(7683)2.76	7683(7683)5.65	7683(7683)5.87
socfb-Indiana	23,313.3(23,313)1151.95	23,313.7(23,313)988.93	23,313.7(23,313)651.67	23,313.5(23,313)1254.63
socfb-MIT	4657(4657)0.71	4657(4657)0.57	4657(4657)0.84	4657(4657)0.58
socfb-OR	36,547(36,547)21.8	36,547(36,547)15.17	36,547(36,547)23.11	36,547(36,547)16.53
socfb-Penn94	31,158.6(31,157)656.8	31,158.3(31,157)1608.51	31,158.4(31,157)1105.46	31,158.1(31,157)1816.72
socfb-Stanford3	8517(8517)133.1	8517(8517)65.06	8517(8517)91.62	8517(8517)162.43
socfb-Texas84	28,164.4(28,164)1194.58	28,164.4(28,164)1673.96	28,164.7(28,164)1796.51	28,164.5(28,164)2051.29
socfb-UCLA	15,222(15,222)384.15	15,221.8(15,221)495.23	15,221.4(15,221)1325.2	15,221.5(15,221)644.76
socfb-UConn	13,230(13,230)276.85	13,230(13,230)215.43	13,229.9(13,229)186.07	13,230(13,230)184.48
socfb-UCSB37	11,261(11,261)22.78	11,261(11,261)22.04	11,261(11,261)16.45	11,261(11,261)18.87
socfb-UF	27,303.8(27,303)1603.3	27,303.8(27,303)1061.8	27,304.2(27,303)1417.24	27,304.3(27,303)1173.8
socfb-UIllinois	24,090.1(24,089)1259.31	24,089.8(24,089)1705.03	24,090(24,089)978.68	24,090.1(24,089)889.65
socfb-Wisconsin87	18,383(18,383)189.03	18,382.7(18,382)410.9	18,382.5(18,382)799.02	18,382.9(18,382)379.94
soc-flickr	153,271(153,271)0.47	153,271(153,271)0.47	153,271(153,271)0.47	153,271(153,271)0.47
soc-gowalla	84,222(84,222)0.09	84,222(84,222)0.1	84,222(84,222)0.09	84,222(84,222)0.1
soc-livejournal	1,868,903(1,868,903)6.09	1,868,903(1,868,903)6.16	1,868,903(1,868,903)6.13	1,868,903(1,868,903)6.53
soc-orkut	2,171,014.7(2,170,927)4108.87	2,170,999(2,170,901)4100	2,171,002.7(2,170,915)4099.63	2,171,002(2,170,955)4100.39
soc-pokec	843,365.4(843,361)3140.92	843,367.2(843,360)2637.71	843,366.9(84,3362)2574.51	843,368.2(843,362)2906.09
tech-as-skitter	525,027.6(525,024)37.52	525,027.8(525,026)7.27	525,027.9(525,027)7.35	525,028(525,027)7.19
tech-RL-caida	74,599.2(74,598)0.31	74,599.2(74,598)0.3	74,598.9(74,598)109.43	74,599.2(74,598)0.3
web-it-2004	414,507(414,507)0.57	414,507(414,507)0.57	414,507(414,507)0.57	414,507(414,507)0.57
web-sk-2005	58,173(58,173)0.82	58,173(58,173)0.8	58,173(58,173)0.8	58,173(58,173)0.78
webwikipedia2009	648,294(648,294)2.06	648,294(648,294)3.04	648,294(648,294)2.83	648,294(648,294)4.48

Average (Minimum) Time. Bold represents the best result and the minimum run time for each instance.

. Figure 15 counts the instances where the optimal minimum and average values of the solution quality obtained by Q-MeaMetaVC at different iterations are optimal. The numbers represent the number of instances, the dotted line represents the average value of the solution quality, and the solid line represents the minimum value of the solution quality. For example, “30” in the figure means that when the iterCount is 30,000, and the minimum value of the solution quality of Q-MeaMetaVC in 30 instances can reach the optimum.

Q-MeaMetaVC has a better minimum value of the solution quality obtained in most instances when iterCount = 30,000 and can reach the optimal value in 85.71% (30/35) instances. The average value of the solution quality that can be obtained on 57.14% (20/35) of the instances is optimal, slightly lower than when iterCount is 15,000 (22/35). When iterCount is 60,000, the performance is close to the worst in terms of the minimum and average values of the solution quality, so iterCount = 30,000 is selected.

5.2.2. Comparison of Experimental Results between Q-MeaMetaVC and Other Solvers

To verify the performance of Q-MeaMetaVC, we list the experimental results of Q-MeaMetaVC on the test set and other excellent solvers, including MetaVC2, MetaVC, PEAVC, NuMVC2+p, and FastVC2+p in

Table 3. The experimental results of Q-MeaMetaVC, MetaVC2, MetaVC, PEAVC, NuMVC2+p and FastVC2+p on the testing set.

Instance	Known Optimal Solution	Q-MeaMetaVC	MetaVC2	MetaVC	PEAVC	NuMVC2+p	FastVC2+p
inf-roadNet-CA	999,651	999,513.7/999,509 */1,144.41	999,911.64/999,854/3380.57	1,000,500.03/1,000,347/3493	999,667.3/999,651/405.023	1,005,475.4/1,005,377/514.3	1,001,109.7/1,001,065/615.65
inf-roadNet-PA	554,291	554,210.3/554,205 */882.88	554,346.98/554,320/3207.33	554,582.2/554,530/3536	554,296/554,291/395.939	557,366.9/557,312/250.17	555,082.9/555,046/158.76
inf-road-usa	11,522,477	1,1519,304.8/11,519,293 */767.01	11,525,847.64/11,525,352/3496	11,527,749.68/11,527,313/3569	11,522,602.4/11,522,477/204.501	11,654,194.8/11,654,069/968.01	11,527,731.7/11,527,630/1000
sc-nasasrb	51,238	51,239.6/51,238/1054.64	51,240.06/51,238/1056.52	51,240.9/51,239/1188	51,240/51,240/198.698	51,249.9/51,248/330.27	51,239.2/51,239/275.69
sc-pkustk13	89,217	89,218.3/89,217/842.32	89,234.12/89,232/1195.98	89,224.66/89,223/1209	89,226/89,226/47.438	89,221.6/89,221/294.28	89,228.5/89,227/51.87
sc-pwtk	207,671	207,681.4/207,679/1427.4	207,676.66/207,674/1183.57	207,678.02/207,674/2096	207,678.2/207,677/974.495	207,695.9/207,684/449.29	207,681.9/207,673/796.31
sc-shipsec1	116,849	117,020.3/117,002/2856.26	116,871.15/116,849/3129.61	116,945.75/116,922/3472	117,275.6/117,275/957.182	117,326.1/117,282/997.78	117,292.4/117,276/893.55
sc-shipsec5	146,768	146,862/146,844/2961.84	146,787.57/146,768/3366.05	146,967.64/146,912/3495	147,054/147,054/603.901	147,152.1/147,131/995.17	147,055.2/147,043/545.29
soc-delicious	85,303	85,298/85,298 */0.6	85,372.75/85,358/2801.96	85,382.47/85,368/2894	85,303/85,303/799.805	85,391.6/85,383/550.74	85,342.7/85,341/537.59
soc-digg	103,234	103,234/103,234/1.05	103,234/103,234/3.6	103,234/103,234/3.42	103,234/103,234/<0.001	103,234/103,234/1.45	103,234/103,234/1.43
socfb-Berkeley13	17,209	17,209.9/17,209/139.89	17,209.91/17,209/774.61	17,212.98/17,210/1122	17,211/17,211/73.12	17,217.3/17,214/742.83	17,211.9/17,210/369.86
socfb-CMU	4986	4986/4986/2.21	4986/4986/8.64	4986.41/4986/688.2	4986/4986/701.602	4986/4986/130.82	4986.6/4986/104.63
socfb-Duke14	7683	7683/7683/2.76	7683/7683/7.76	7683/7683/655	7683/7683/30.733	7683.3/7683/241.79	7683/7683/201.17
socfb-Indiana	23,313	23,313.7/23,313/988.93	23,313.97/23,313/926.32	23,317.3/23,314/1686	23,315/23,315/35.576	23,327/23,320/645.3	23,317.1/23,315/524.84
socfb-MIT	4657	4657/4657/0.57	4657/4657/2.33	4657/4657/103.2	4657/4657/0.432	4657/4657/3.25	4657/4657/4.53
socfb-OR	36,547	36,547/36,547/15.17	36,547/36,547/340.18	36,550.08/36,549/1227	36,548/36,548/726.104	36,553.1/36,551/571.88	36,548.4/36,548/74.84
socfb-Penn94	31,158	31,158.3/31,157 */1608.51	31,159.82/31,158/1201.9	31,164.72/31,161/1515	31,164/31,164/59.008	31,183.7/31,181/606.92	31,164/31,161/414.21
socfb-Stanford3	8517	8517/8517/65.06	8517/8517/443.73	8518/8518/10.33	8518/8518/2.721	8518/8518/6.35	8518/8518/1.69
socfb-Texas84	28,164	28,164.4/28,164/1673.96	28,165.6/28,164/908.47	28,170.83/28,166/1751	28,172/28,172/329.481	28,182.9/28,177/570.79	28,170.8/28,166/481.56
socfb-UCLA	15,221	15,221.8/15,221/495.23	15,222.41/15,221/983.15	15,223.6/15,222/1067	15,224/15,224/86.807	15,226.4/15,225/466.85	15,224.1/15,223/242.24
socfb-UConn	13,230	13,230/13,230/215.43	13,230.03/13,230/751.81	13,231.67/13,230/1189	13,231/13,231/686.44	13,233.7/13,233/442.06	13,231.7/13,230/188.83
socfb-UCSB37	11,261	11,261/11,261/22.04	11,261/11,261/52.98	11,262.08/11,261/422.4	11,262/11,262/168.472	11,262.1/11,261/327.93	11,262.1/11,261/395.18
socfb-UF	27,303	27,303.8/27,303/1061.81	27,303.9/27,303/1046.48	27,308.52/27,305/1855	27,305/27,305/703.577	27,323.1/27,320/544.18	27,308.4/27,306/370.66
socfb-UIllinois	24,089	24,089.8/24,089/1705.03	24,090.48/24,089/1228.43	24,094/24,092/1628	24,093/24,093/374.105	24,105.9/24,104/529.5	24,093.6/24,092/350.65
socfb-Wisconsin87	18,382	18,382.7/18,382/410.9	18,382.93/18,382/352.19	18,384.89/18,383/1564	18,384/18,384/728.197	18,391.1/18,389/541.04	18,384.6/18,383/408.83
soc-flickr	153,271	153,271/153,271/0.47	153,271/153,271/4.52	153,271/153,271/2.01	153,271/153,271/0.679	153,271/153,271/0.91	153,271/153,271/0.59
soc-gowalla	84,222	84,222/84,222/0.1	84,222/84,222/0.4	84,222/84,222/0.46	84,222/84,222/0.093	84,222/84,222/0.12	84,222/84,222/1.17
soc-livejournal	1,868,903	1,868,903/1,868,903/6.16	1,868,910.32/1,868,905/1330.85	1,868,910.69/1,868,907/2163	1,868,904/1,868,904/0.01	1,868,903.2/1,868,903/619.11	1,868,918.4/1,868,917/5.25
soc-orkut	2,170,773	2,170,999/2,170,901/4100	2,170,854.66/2,170,773/3350.66	2,171,951.4/2,171,860/3563	2,171,362.7/2,171,327/1494.217	2,190,777.1/2,190,339/999.8	2,171,236.4/2,171,200/996.03
soc-pokec	843,348	843,367.2/843,360/2637.71	843,355.56/843,348/3223.25	843,374.87/843,364/3289	843,374/843,374/590.446	844,306.2/844,272/204.47	843,380.4/843,377/574.95
tech-as-skitter	525,027	525,027.8/525,026 */7.27	525,196.02/525,183/2737.99	525,200.99/525,186/3323	525,027.8/525,027/0.707	525,187.4/525,163/963.41	525,277.9/525,269/596.61
tech-RL-caida	74,593	74,599.2/74,598/0.3	74,630.29/74,621/2758.99	74,629.39/74,621/2968	74,598/74,598/7.493	74,597/74,593/832.06	74,654/74,651/862.06
web-it-2004	414,507	414,507/414,507/0.57	414,516.06/414,515/1024.03	414,515.95/414,515/1261	414,507/414,507/<0.001	414,510.2/414,507/19.71	414,528/414,528/281.47
web-sk-2005	58,173	58,173/58,173/0.8	58,173/58,173/50.75	58,173/58,173/61.99	58,173/58,173/<0.001	58,173.4/58,173/86.29	58,173/58,173/1.41
web-wikipedia2009	648,294	648,294/648,294/3.04	648,294/648,294/228.54	648,296.36/648,294/1681	648,294/648,294/88.279	648,294/648,294/112.3	648,314.9/648,305/1.76

Average/Minimum/Tim. Bold represents the best result and the minimum run time for each instance. * represents the updated optimal solution.

. Figure 16 shows the number of instances of the best solution obtained by each solver.

The following can be observed from the experimental results:

(1) Q-MeaMetaVC only performs averagely in “sc-pwtk”, “sc-shipsec1”, “sc-shipsec5”, “soc-orkut”, and “soc-pokec”; however, it performs well in other instances.

(2) The optimal solution obtained by Q-MeaMetaVC in 82.9% (29/35) instances has the best quality—more than 65.7%, 28.6%, 25.7%, 31.4%, and 28.6% of MetaVC2, MetaVC, PEAVC, NuMVC2+p, and FastVC2+p. The average quality of the solution obtained by Q-MeaMetaVC in 80% (28/35) of the instances is the best, far exceeding 42.9%, 17.1%, 28.6%, 20%, and 20%.of MetaVC2, MetaVC, PEAVC, NuMVC2+p, and FastVC2+p.

(3) Figure 17 shows an example distribution of the difference between the quality of the solutions of MetaVC2, MetaVC, PEAVC, NuMVC2+p, and FastVC2+p and the quality of the solutions of Q-MeaMetaVC. Among them, Iasd(x) and Iosd(x) are calculated according to Formulas (4) and (5), respectively.

Iasd(x) = average quality of solution of algorithm x − average quality of solution of algorithm Q-MeaMetaVC

(4)

Iosd(x) = optimal quality of solution of algorithm x − the optimal quality of solution of algorithm Q-MeaMetaVC...

(5)

According to Figure 17a, it can be concluded that the optimal quality of the Q-MeaMetaVC solution is better than that of MetaVC2 in ten instances. In comparison, MetaVC2 performs better in five instances. Overall, Iosd (MetaVC2) is less than −10 in four instances and not less than −1000 in all instances, while the difference is greater than 10 in seven instances and greater than 1000 in one instance. In nineteen instances, the optimal quality of the Q-MeaMetaVC solution is better than that of MetaVC2, while MetaVC2 performs better in five instances. Overall, Iasd(MetaVC2) is less than −10 in four instances and not less than −1000 in all instances, while the difference is greater than 10 in seven instances and greater than 1000 in one instance.

Observing Figure 17b–e, it can be concluded that Q-MeaMetaVC performs better in almost all instances regarding the average and optimal quality of the solution. The average value of Iasd(MetaVC2) for each test set instance is 200.13, and the average value of Iosd(MetaVC2) is 183.17; the average of Iasd(MetaVC) is 318.43, and the average of Iosd(MetaVC) is 297.69; the average of Iasd(PEAVC) is 125.49, and the average of Iosd(PEAVC) is 125.29; the average value of Iasd(NuMVC2+p) is 4735.13, and the average value of Iosd(NuMVC2+p) is 4714.4; the average value of Iasd(FastVC2+p) is 344.7, and the average value of Iosd(FastVC2+p) is 340.94.

(4) We summarized the known optimal solutions given in the literature and the results of the literature [13] as known optimal solutions (column 2 of Table 3). Q-MeaMetaVC reached the known optimal solution in 23 instances and updated the optimal solution in six instances (the data marked with “*” in Table 3). However, MetaVC2, MetaVC, PEAVC, NuMVC2+p, and FastVC2+p reached the known optimal solutions in 23, 10, 9, 11, and 10 instances, respectively.

(5) Based on the MEAF, this paper adopts different strategies to solve the MVC of large-scale graphs, which can theoretically reduce the time to find the final solution. However, due to the serial method used in this experiment, the effect is not significant and has certain limitations.

6. Conclusions

The MVC problem is a mathematical problem generated by abstracting the application problems in the real world. Its research has tremendous significance for solving related practical engineering problems. This study has been conducted from the perspective of membrane evolutionary algorithm and aims to design the algorithm called Q-MeaMetaVC to solve the MVC problem, combining the MEAF and PEAF frameworks. First, the membrane structure of Q-MeaMetaVC was designed based on the characteristics of connected components in bipartite and non-bipartite graphs. In addition, several operators of the membrane evolutionary algorithm were designed and optimized, including the use of the BMS strategy in the splitting process and the fast-add operator to speed up the recovery speed after division. According to the fitness situation, the three membranes in a group searched in different directions, expanding the search space and improving the ability of the solver. To verify the effectiveness of Q-MeaMetaVC, we designed experiments on 35 instances where PEAVC failed to obtain accurate solutions. The results showed that known optimal solutions were obtained in 29 instances, and new optimal solutions were obtained in 6 instances. Therefore, compared with the best minimum vertex cover in recent years, Q-MeaMetaVC has better performance.

In future work and research, more experiments can be conducted on parameter settings to improve algorithm performance. We would like to design more efficient membrane evolutionary algorithms for MVC as well as other graph problems on massive graphs so that we can better verify the universality of the membrane evolutionary algorithm.