New algorithms for the Minimum Coloring Cut Problem

TL;DR

This paper introduces two Variable Neighborhood Search algorithms to solve the Minimum Coloring Cut Problem, effectively finding all known optimal solutions and advancing solution methods for this graph problem.

Contribution

The paper presents novel VNS-based algorithms that successfully identify all optimal solutions for the Minimum Coloring Cut Problem, improving solution techniques.

Findings

Algorithms find all known optimal solutions.

VNS approaches outperform previous methods.

Effective in solving complex graph instances.

Abstract

The Minimum Coloring Cut Problem is defined as follows: given a connected graph G with colored edges, find an edge cut E' of G (a minimal set of edges whose removal renders the graph disconnected) such that the number of colors used by the edges in E' is minimum. In this work, we present two approaches based on Variable Neighborhood Search to solve this problem. Our algorithms are able to find all the optimum solutions described in the literature.

Tables

Table 1. Table 1: Stop condition according to instance sizes.

number of nodes	max running time (s)
50	1
100	20
200	30
400	80
500	200
1000	2800

Table 2. Table 2: Computational results for instances with 50 nodes

Parameters		Silva et al. (2016)		VNS-Greedy		VNS-Probabilistic
colors	density	value	time (s)	value	time (s)	value	time (s)
12	0.8	9.8	0.001	9.8	0.001	9.8	0.0004
	0.5	7.4	0.001	7.4	0.007	7.4	0.0004
	0.2	2.5	0.006	2.5	0.003	2.5	0.0003
25	0.8	15.5	0.05	15.5	0.004	15.5	0.001
	0.5	9.9	0.04	9.9	0.009	9.9	0.001
	0.2	2.7	0.009	2.7	0.008	2.7	0.0008
50	0.8	21.3	1.48	21.3	0.01	21.3	0.006
	0.5	11.6	0.82	11.6	0.01	11.6	0.007
	0.2	2.8	0.04	2.8	0.01	2.8	0.003
62	0.8	22.7	1.8	22.7	0.02	22.7	0.007
	0.5	12.1	1.1	12.1	0.01	12.1	0.006
	0.2	2.8	0.05	2.8	0.01	2.8	0.004

Table 3. Table 3: Computational results for instances with 100 nodes

Parameters		Silva et al. (2016)		VNS-Greedy		VNS-Probabilistic
colors	density	value	time (s)	value	time (s)	value	time (s)
25	0.8	21	0.1	21	0.004	21	0.003
	0.5	16.5	0.09	16.5	0.01	16.5	0.006
	0.2	6.2	0.06	6.2	0.02	6.2	0.002
50	0.8	33.1	4.8	33.1	0.02	33.1	0.03
	0.5	22.2	5.7	22.2	0.05	22.2	0.02
	0.2	6.8	0.4	6.8	0.01	6.8	0.01
100	0.8	45.2	22.4	45.2	0.1	45.2	0.09
	0.5	26.5	9.3	26.5	0.1	26.5	0.09
	0.2	7.2	2.1	7.2	0.06	7.2	0.06
125	0.8	$⟨\mathrm{\hspace{0.17em}45.2}⟩$	$⟨\mathrm{\hspace{0.17em}22.4}⟩$	48.6	0.1	48.6	0.1
	0.5	27.1	36.1	27.1	0.1	27.1	0.1
	0.2	7.2	3.1	7.2	0.07	7.2	0.08
Obs.: Values between brackets are probably typing errors - they repeat the information given three rows above.

Table 4. Table 4: Computational results for instances with 200 nodes

Parameters		Silva et al. (2016)		VNS-Greedy		VNS-Probabilistic
colors	density	value	time (s)	value	time (s)	value	time (s)
50	0.8	43.3	2.5	43.3	0.05	43.3	0.05
	0.5	32.7	9.4	32.7	0.1	32.7	0.09
	0.2	13.2	5.7	13.2	0.08	13.2	0.07
100	0.8	68.8	238.9	68.8	0.3	68.8	0.3
	0.5	45.4	699.5	45.4	0.3	45.4	0.3
	0.2	15	188.3	15	0.2	15	0.2
200	0.8	93.8	2051.9	93.8	1.2	93.8	1.2
	0.5	54.1	2066.0	54.1	1.0	54.1	1.1
	0.2	15.9	614.4	15.9	1.0	15.9	1.2
250	0.8	$⟨\mathrm{\hspace{0.17em}93.8}⟩$	$⟨\mathrm{\hspace{0.17em}2051.9}⟩$	99.4	1.7	99.4	1.9
	0.5	56.5	2990.2	56.5	1.7	56.5	1.7
	0.2	16.1	691.6	16.1	1.3	16.1	1.1
Obs.: Values between brackets are probably typing errors - they repeat the information given three rows above.

Table 5. Table 5: Computational results for instances with 400 nodes

Parameters		Silva et al. (2016)		VNS-Greedy		VNS-Probabilistic
colors	density	value	time (s)	value	time (s)	value	time (s)
100	0.8	-	-	88.7	0.5	88.7	0.5
	0.5	-	-	71.9	0.9	71.9	0.9
	0.2	-	-	30.7	1.1	30.7	1.1
200	0.8	-	-	144.3	3.4	144.3	5.5
	0.5	-	-	99.5	4.3	99.5	4.2
	0.2	-	-	35	4.7	35	4.7
400	0.8	-	-	195.7	15.7	195.7	17.6
	0.5	-	-	120.3	22.6	120.3	20.3
	0.2	-	-	37.4	11.5	37.4	14.5
500	0.8	-	-	210.2	26.7	210.2	27.5
	0.5	-	-	124.9	26.6	124.9	33.0
	0.2	-	-	38.2	19.2	38.2	20.4

Table 6. Table 6: Computational results for instances with 500 nodes

Parameters		Silva et al. (2016)		VNS-Greedy		VNS-Probabilistic
colors	density	value	time (s)	value	time (s)	value	time (s)
125	0.8	-	-	111.4	1.3	111.4	1.6
	0.5	-	-	89.2	1.4	89.2	2.5
	0.2	-	-	37.1	2.6	37.1	2.5
250	0.8	-	-	178.3	9.5	178.3	9.9
	0.5	-	-	123.8	10.3	123.8	11.7
	0.2	-	-	41.4	12.1	41.4	8.6
500	0.8	-	-	240.4	44.8	240.4	36.5
	0.5	-	-	146.8	63.5	146.8	36.4
	0.2	-	-	45	28.5	45	27.7
625	0.8	-	-	256.9	51.7	256.9	54.8
	0.5	-	-	155.2	55.4	155.2	72.6
	0.2	-	-	45.3	43.2	45.3	51.8

Table 7. Table 7: Computational results for instances with 1000 nodes

Parameters		Silva et al. (2016)		VNS-Greedy		VNS-Probabilistic
colors	density	value	time (s)	value	time (s)	value	time (s)
250	0.8	-	-	228.8	20.6	228.8	18.3
	0.5	-	-	197.2	49.5	197.2	36.1
	0.2	-	-	113.8	71.8	113.8	67.2
500	0.8	-	-	375.4	176.1	375.4	134.7
	0.5	-	-	284.3	156.2	284.3	277.5
	0.2	-	-	133.4	223.6	133.4	188.9
1000	0.8	-	-	514.7	559.7	514.7	645.7
	0.5	-	-	353.6	736.1	353.6	820.0
	0.2	-	-	145.8	525.4	145.8	580.8
1250	0.8	-	-	552.6	1109.8	552.6	1189.2
	0.5	-	-	369.7	1230.6	369.7	1061.8
	0.2	-	-	147	789.1	147	885.2

Full text

New algorithms for the Minimum Coloring Cut Problem

Augusto Bordini1,2  and  Fábio Protti1∗

*Corresponding author

1Fluminense Federal University

Niterói, RJ - Brazil

2PETROBRAS

Rio de Janeiro, RJ - Brazil

E-mails: gutocnet@ic.uff.br / fabio@ic.uff.br

**ABSTRACT. The Minimum Coloring Cut Problem is defined as follows: given a connected graph $G$ with colored edges, find an edge cut $E^{\prime}$ of $G$ (a minimal set of edges whose removal renders the graph disconnected) such that the number of colors used by the edges in $E^{\prime}$ is minimum. In this work, we present two approaches based on Variable Neighborhood Search to solve this problem. Our algorithms are able to find all the optimum solutions described in the literature. **

Keywords: Minimum Coloring Cut Problem, Combinatorial Optimization, Graph Theory, Variable Neighborhood Search, Label Cut Problem.

1 Introduction

The Minimum Coloring Cut Problem (MCCP) has as input a connected (undirected) graph $G=(V,E)$, with colored (or labeled) edges. Each color is assigned to one or more edges, but each edge $e$ has a unique color $c(e)$. The aim of the MCCP is to find an edge cut $E^{\prime}$ of $G$ (a minimal set $E^{\prime}$ of edges such that $G^{\prime}=(V,E\backslash E^{\prime})$ is disconnected) with the following property: the set of colors used by the edges in $E^{\prime}$ has minimum size. Formally:

**Minimum Coloring Cut Problem (MCCP)

**Input: a connected (undirected) graph $G=(V,E,C)$ such that $V$ is the set of nodes of $G$, $E$ is the set of edges of $G$, and $C=\{c(e)\mid e\in E\}$ is the set of colors (or edge labels).

Goal: Find a subset $E^{\prime}\subseteq E$ such that $G^{\prime}=(V,E\backslash E^{\prime})$ is disconnected and the set of colors $C^{\prime}=\{c(e)\mid e\in E^{\prime}\}$ is minimized. Figure 1 shows a simple example.

Note that if all the edge colors are distinct then the MCCP amounts to finding a usual minimum cut, a task that can be easily performed in polynomial time using max-flow algorithms. However, the complexity of the MCCP still remains as a theoretical open question. Intuitively, the MCCP is unlikely to be solvable in polynomial-time, because the related problem of finding an $s$-$t$ cut with the minimum number of colors is NP-hard (Coudert et al., 2007). This fully justifies the design of heuristic algorithms to solve the MCCP.

Colored cut problems are related to the vulnerability of multilayer networks since they provide tight lower bounds on the number of failures that can disconnect totally or partially a network (Coudert et al., 2016).

The Minimum Color $s$-$t$ Cut Problem (MCstCP for short) is closely related to the MCCP. The input of the MCstCP consists of a connected edge-colored graph $G=(V,E)$ and two nodes $s,t\in V$, and its objective is to find the minimum number of colors whose removal separates $s$ and $t$ in the remaining graph (where ‘removing a color’ means removing all the edges with that color). Coudert et al. (2007) considered the MCstCP for the first time; they prove its NP-hardness and present approximation hardness results. However, five years before, Jha et al. (2002) had already observed that the MCstCP is NP-hard via a simple reduction from the Minimum Hitting Set Problem.

The papers by Coudert et al. (2007) and Coudert et al. (2016) approach the MCCP and the MCstCP with the goal of measuring the network’s capability of remaining connected when sets of links share risks. For instance, in a WiFi network, an attacker could drop all links on a certain frequency by adding a strong noise signal to it. Other example happens when two links use the same physical environment.

Another potential application of the MCCP is in transportation planning systems, where nodes represent locations served by bus and edge colors represent bus companies. In this case, a solution of the MCCP gives the minimum number of companies that must stop working in order to create pairs of locations not reachable by bus from one another. Such application is more suitably modeled by allowing a multigraph as the input of the MCCP, since two locations can be connected by bus services offered by more than a single company.

Zhang (2014) shows that the MCCP can be solved in polynomial time when the input graph is planar, has bounded treewidth, or has a small value of fmax (the maximum number of edges a color is assigned).

In (Silva et al., 2016), exact methods to solve the MCCP are presented. The authors propose three different integer programming formulations over which branch-and-cut and branch-and-bound approaches are developed. To evaluate their algorithms, they use the instances generated by Cerulli et al. (2005).

In some sense, the MCCP is the dual of the Minimum Labelling Spanning Tree Problem (MLSTP), which aims at finding a minimum set $C^{\prime}$ of colors such that the edges with colors in $C^{\prime}$ form a connected, spanning subgraph $H$ of $G$. For information on the MLSTP, we refer the reader to (Krumke and Wirth, 1998) and (Consoli et al., 2015). Note that any spanning tree $T$ of $H$ contains $|C^{\prime}|$ colors, and thus is a spanning tree of $G$ using a minimum number of colors, i.e., a solution of the MLSTP with input $G$. An analogous argument can be applied to the MCCP: one can first find a disconnecting set $E^{\prime}$ of edges (not necessarily a cut) that uses a minimum number of colors, and then easily return a minimal disconnecting set $E^{\prime\prime}\subseteq E^{\prime}$ as the solution of the MCCP.

Another way of viewing the MCCP is: find a maximum set $C^{\prime}$ of colors such that $G^{\prime}=(V,E^{\prime})$ is disconnected, where $E^{\prime}=\{e\in E\mid c(e)\in C^{\prime}\}$, and then pick all the colors in the complementary set $C\backslash C^{\prime}$. Such strategy is employed by the two new algorithms proposed in this work. The algorithms try to include new colors to the set of current colors, so that adding the edges with those new colors to the current subgraph still keeps it disconnected. When no new color can be included in this way, the colors in $C\backslash C^{\prime}$ correspond to a solution of the MCCP. Our algorithms are based on the Variable Neighborhood Search (VNS) metaheuristic (Mladenović and Hansen, 1997). As we shall see, the former algorithm uses a greedy, deterministic approach to choose new colors to be included to the current set of colors, while the latter uses a probabilistic approach.

The remainder of this work is structured as follows. In Section 2 we describe in detail all the functions and procedures used in our algorithms. Section 3 presents the computational results, where we compare the quality of the solutions obtained by our algorithms with the ones produced by the exact methods described in (Silva et al., 2016). Section 4 contains our concluding remarks.

2 Description of the algorithms

In this section we first describe the general algorithm (Algorithm 1) which is the basic structure for both the greedy, deterministic approach (“VNS-Greedy”) and the probabilistic approach (“VNS-Probabilistic”). Next, we describe in detail each of its subroutines. Some subroutines ( Generate-Initial-Solution, New-Solution, and Local-Search) have a “greedy version” and a “probabilistic version”. Running Algorithm 1 using the greedy versions of such subroutines produces the VNS-Greedy algorithm, while running it using the probabilistic versions produces the VNS-Probabilistic algorithm. The remaining subroutines are common to both approaches.

The description of the general algorithm is as follows:

Along the execution of the algorithm, a solution is any subset $C^{\prime}\subseteq C$ of colors. Let $G^{\prime}=(V,E^{\prime})$ be the spanning subgraph of $G$ such that $E^{\prime}=\{e\in E\mid c(e)\in C^{\prime}\}$. As an abuse of terminology, we say that solution $C^{\prime}$ is disconnected (resp., connected) if $G^{\prime}$ is disconnected (resp., connected). Also, we may refer to the number of connected components of $C^{\prime}$ to mean the number of connected components of $G^{\prime}$. The value (number of colors) of solution $C^{\prime}$ is denoted by $\mathinner{\!\left\lvert C^{\prime}\right\rvert}$. As mentioned in the introduction, we follow the strategy of finding a maximum disconnected solution. To be consistent with this approach, $C^{\prime}$ is a feasible solution if and only if $G^{\prime}$ is disconnected. The complementary set of colors $C\backslash C^{\prime}$ is denoted by $\overline{C^{\prime}}$ and called complementary space of solution $C^{\prime}$.

Below we discuss the notation used in Algorithm 1:

• •

$\mathit{BestS}$ is the current best solution. In line 29, the returned value $\mathinner{\!\left\lvert C\right\rvert}-\mathinner{\!\left\lvert\mathit{BestS}\right\rvert}$ is the number of colors in the disconnecting set consisting of all the edges whose colors are in $\overline{\mathit{BestS}}$.

• •

$\mathit{MaxNeighborhood}$ is a variable that controls the neighborhoods (see line 11) in the core of the VNS strategy (lines 10 to 23).

• •

$S$ and $S^{\prime}$ are auxiliary solutions, explained later.

• •

Number-of-Components$(S^{\prime})$ (line 14) is a standard function that returns the number of connected components of solution $S^{\prime}$. It is implemented using the well-known disjoint-set (or union-find) data structure with weighted-union heuristic and path compression. Details can be found in (Cormen et al., 2009, chapter 21).

An initial solution $\mathit{BestS}$ is generated in line 1; next, $\mathit{MaxNeighborhood}$ is set as the number of colors not in $\mathit{BestS}$ (line 2). The main loop (lines 3 to 28) is executed until the stop condition is met. The stop condition (maximum running time) is defined empirically according to the instance size (number of nodes $|V|$). After some initial tests, we obtained the values shown in Table 1 below.

In lines 4 to 9, a new candidate solution $S$ is generated in the beginning of a new iteration. First, $S$ is generated using subroutine New-Solution. (line 4). If $S$ is better than $\mathit{BestS}$ then $\mathit{BestS}$ and $\mathit{MaxNeighborhood}$ are updated and another candidate solution $S$ is generated by New-Solution. The while loop (lines 5 to 9) ends when the number of colors of the candidate solution is not greater than the number of colors of the current best solution.

Lines 10 to 23 contain the core of the basic VNS strategy (Mladenović and Hansen, 1997). For each candidate solution $S$, $S^{\prime}$ is set to $S$ (line 12), and then the shaking and local search procedures are executed over $S^{\prime}$ for $k$ iterations, where $k$ controls the neighborhoods and ranges in $1\,.\,.\,\mathit{MaxNeighborhood}$. If shaking and local search are able to improve $S^{\prime}$ so that $\mathinner{\!\left\lvert S^{\prime}\right\rvert}>\mathinner{\!\left\lvert S\right\rvert}$ then $S$ is updated and $k$ is restarted to $1$, i.e., a new cycle of $k$ iterations begins.

When $k$ is equal to $\mathit{MaxNeighborhood}$, the current best solution $\mathit{BestS}$ is compared with $S$ and updated if necessary (lines 24 to 27). The execution stops if the maximum running time is reached (line 28); otherwise, it returns to the candidate solution generation step.

When the stop condition is true, the value $\mathinner{\!\left\lvert C\right\rvert}-\mathinner{\!\left\lvert\mathit{BestS}\right\rvert}$ is returned. The subset of edges $E^{\prime}=\{e\in E\mid c(e)\in\overline{\mathit{BestS}}\}$ is a disconnecting set using $\mathinner{\!\left\lvert C\right\rvert}-\mathinner{\!\left\lvert\mathit{BestS}\right\rvert}$ colors. If needed, a cut can be obtained by finding any minimal disconnecting set $E^{\prime\prime}\subseteq E^{\prime}$.

In the next subsections we describe in detail the subroutines used in Algorithm 1. When applicable, the greedy and probabilistic versions of a subroutine are presented.

2.1 Generate-Initial-Solution

This subroutine has a greedy version (Algorithm 2) and a probabilistic version (Algorithm 3). In the greedy version, the initial solution is constructed iteratively color by color. At each step, a color $c$ not appearing in the current solution is greedily chosen so that the number of connected components of $\mathit{BestS}\cup\{c\}$ is maximized. The subroutine stops when every color in the complementary set $\overline{\mathit{BestS}}$ turns the current solution connected when added to it.

Adding a color that maximizes the number of connected components (line 4 in Algorithm 2) usually guides the subroutine to locally optimal solutions. This strategy is precisely the deterministic approach used by Krumke and Wirth (1998) and other authors for the MLSTP.

To avoid local optima, we use an adapted Boltzmann function that allows a probabilistic color choice at each iteration. Such adapted Boltzmann function is inspired by the Simulated Annealing Cooling Schedule described in (Aarts et al., 2005), and is used not only in subroutine Generate-Initial-Solution, but also in subroutines New-Solution and Local-Search.

We remark that the probabilistic versions of subroutines Generate-Initial-Solution, New-Solution and Local-Search differ from the greedy ones precisely in the choice strategy of colors to be included in the current best solution.

The probability $P(c)$ of a color $c$ to be included in the current best solution $\mathit{BestS}$ is directly proportional to the number of connected components of $\mathit{BestS}\cup\{c\}$. Let $\gamma\in\overline{\mathit{BestS}}$ be the color that maximizes Number-of-Components$(\mathit{BestS}\cup\{\gamma\})$. The probabilities $P(c)$ are normalized by the Boltzmann function values $\exp(\Delta(c)/T)$, where:

$\bullet$ $\Delta(c)=$ Number-of-Components$(\mathit{BestS}\cup\{c\})$ $-$ Number-of-Components$(\mathit{BestS}\cup\{\gamma\})$

$\bullet$ $T$ is a parameter referred to as temperature that controls the function’s dynamic; in our experiments we use $T=1$.

2.2 New-Solution

New-solution is a subroutine used to generate a candidate solution $S$ at the beginning of a new iteration in the repeat loop (lines 3 to 28) of Algorithm 1. It is implemented as a local search (Mladenović and Hansen, 1997) on the colors in $\overline{\mathit{BestS}}$ as an attempt to raise the diversity factor, since the complementary space of $\mathit{BestS}$ is a completely different search zone with respect to the current best solution.

Algorithms 4 and 5 are, respectively, the greedy and probabilistic versions of subroutine New-Solution. Our tests revealed that both algorithms produce an immediate peak of diversification as the local search evolves.

In order to extract a feasible solution from $\overline{\mathit{BestS}}$ an iterative process of inclusion of new colors is performed as follows.

Solution $S$ is initialized as an empty set of edges (line 1 in both algorithms). Note that the number of connected components of $S$ at this moment is $|V|$ (corresponding to a spanning subgraph containing only isolated vertices).

The first while loop (lines 2 to 8 in Algorithm 4, and 2 to 13 in Algorithm 5) generates a partial solution $S$ color by color, and stops in two cases:

(a) the set $\overline{\mathit{BestS}}\backslash S$ of unused colors is empty;

(b) every remaining color in $\overline{\mathit{BestS}}\backslash S$ would generate an infeasible (connected) solution if added to current solution $S$.

The second while loop (lines 9 to 15 in Algorithm 4, and 14 to 25 in Algorithm 5) works in the same way, but try to add to current solution $S$ colors from $\mathit{BestS}$ instead. It stops when no color in $\mathit{BestS}\backslash S$ is able to produce a feasible solution when added to $S$.

2.3 Shake

This subroutine is common to both VNS-Greedy and VNS-Probabilistic. It consists of finding a new solution by adding/removing $k$ colors randomly from current solution $S^{\prime}$, in order to diversify the range of solutions and try to escape from a local optimum. The total number of operations (additions plus removals) depends on $k$ (parameter passed from the main algorithm), which is the size of the neighborhood. The value of $k$ ranges from $1$ to the maximum neighborhood size (variable $\mathit{MaxNeighborhood}$).

In line 2, $\delta$ is a random value in $[0,1]$. In line 3, it is necessary to check whether $\mathinner{\!\left\lvert S^{\prime}\right\rvert}>0$ before removing a color from $S^{\prime}$. At the end of Algorithm 6, the symmetric difference between solutions $S$ and $S^{\prime}$ contains exactly $k$ colors, i.e., $\mathinner{\!\left\lvert(S\backslash S^{\prime})\cup(S^{\prime}\backslash S)\right\rvert}=k$.

We remark that, after the shaking, the new solution $S^{\prime}$ may be infeasible (connected). The purpose of subroutine Fix (explained in the next subsection) is to deal with such event.

2.4 Fix

This subroutine is also common to VNS-Greedy and VNS-Probabilistic. If after the shaking procedure $S^{\prime}$ is infeasible (line 14 in Algorithm 1), subroutine Fix is invoked. It consists of iteratively removing colors at random from $S^{\prime}$ until it turns into a feasible solution.

2.5 Local-Search

The subroutine Local-Search has a greedy version (Algorithm 8) and a probabilistic version (Algorithm 9).

In the greedy version, after solution $S^{\prime}$ is submitted to subroutines Shake and Fix, new colors are greedily added to $S^{\prime}$ until no longer possible.

The probabilistic version is similar, but the choice of new colors follows the strategy already described in the probabilistic versions of subroutines Generate-Initial-Solution (Algorithm 3) and New-Solution (Algorithm 5).

3 Computational Results

The experiments were performed on an Intel Core I7 4GHz with 32Gb RAM, running Linux Ubuntu x64 14.04 operating system. Algorithms were implemented in C++ and compiled using optimization flag -O3.

Our experiments were performed using the $720$ problem instances created by Cerulli et al. (2005), divided in $72$ datasets containing $10$ randomly generated instances each. All the $10$ instances in a single dataset have the same number of nodes $|V|$, number of colors $|C|$, and edge density $d$; that is, each dataset is characterized by a prescribed triple $(|V|,|C|,d)$. The expected number of edges $|E|$ of an instance is $d\,|V|\,(|V|-1)/2$; thus, in a same dataset, instances may have slightly different values of $|E|$. The value of $|V|$ ranges in the set $\{50,100,200,400,500,1000\}$, while the value of $d$ in $\{0.2,\,0.5,\,0.8\}$ (corresponding, respectively, to a low, medium, or high density). The value of $|C|$ varies according to the instance size. For example, if $|V|=50$ then $|C|\in\{12,25,50,62\}$. Tables 2 to 7 show all the combinations $(|V|,|C|,d)$ used in our tests. Each row in a table corresponds to the $10$ instances of a single dataset. For each dataset, solution quality is evaluated as the average solution value (number of colors in the solution) calculated over the $10$ problem instances.

Maximum allowed CPU times were chosen as stop conditions for the algorithms, determined according to instance sizes (see Table 1 in Section 2.1).

In Tables 2 to 7, our results are compared with the results obtained by the three exact methods proposed in (Silva et al., 2016). In all the tables, the first and second columns show, respectively, the number of colors and the density; in the third column, each entry shows the average solution value obtained by the exact methods over the $10$ instances of the corresponding row (a symbol ‘-’ means that the methods were unable to find the optima); in the fourth column, each entry shows the average computational time of the exact method that best deals with the $10$ instances of the corresponding row (a symbol ‘-’ means that the runs were aborted after reaching a time limit); columns 5 and 6 (resp., 7 and 8) have the same meaning as columns 3 and 4, but refer to our VNS greedy (resp., VNS probabilistic) approach.

For instances with the same number of nodes, the tests show, as expected, that low density instances converge faster than medium/high density instances, because the latter have larger search spaces.

The exact methods proposed in Silva et al. (2016) are able to find optimum solutions only for $|V|\leq 200$. In this scenario (see Tables 2 to 4), both the VNS greedy and VNS probabilistic approaches reach all the optimum solutions, in lower computational times.

For $|V|\in\{400,500,1000\}$ (see Tables 5 to 7), the VNS greedy and VNS probabilistic approaches found exactly the same average solution value for all datasets. The VNS probabilistic approach is faster for $50$-node instances (see Table 2). For other values of $|V|$ (see Tables 3 to 7), no algorithm clearly outperforms the other in terms of computational times.

4 Conclusions

In this paper we described new VNS-based algorithms for the MCCP. Previously to this work, no other results for the MCCP besides the ones obtained by Silva et al. (2016) were known for instances up to $200$ nodes (to the best of the authors’ knowledge). Our algorithms reach all the known optimal solutions in lower computational times. For instances with unknown optima, our algorithms provide the same solutions, in reasonable computational times.

Computational experiments were performed using two different approaches, greedy and probabilistic, in order to evaluate how the algorithms are influenced by the color choice strategy. Computational results showed that the two approaches exhibit the same behavior in terms of solution quality, and no significant difference in terms of computational times.