Recycling Solutions for Vertex Coloring Heuristics

TL;DR

This paper introduces the recycle method, a simple initial solution generator for vertex coloring heuristics, which leverages (k+1)-colorings to improve the speed of finding legal k-colorings, supported by experimental evidence.

Contribution

The paper proposes the recycle method as a novel initial solution generator that enhances heuristic algorithms for vertex coloring by using existing (k+1)-colorings.

Findings

Recycle method improves heuristic speed in vertex coloring.

Experimental results show faster convergence with the recycle method.

Recommended as standard initial solution generator for various algorithms.

Abstract

The vertex coloring problem is a well-known NP-hard problem and has many applications in operations research and in scheduling. A conventional approach to the problem solves the k-colorability problem iteratively, decreasing k one by one. Whether a heuristic algorithm finds a legal k-coloring quickly or not is largely affected by an initial solution. We highlight a simple initial solution generator, which we call the recycle method, which makes use of the legal (k+1)-coloring that has been found. An initial solution generated by the method is expected to guide a heuristic algorithm to find a legal k-coloring more quickly than conventional methods, as demonstrated by experimental studies. The results suggest that the recycle method should be used as the standard initial solution generator for both local search algorithms and modern hybrid methods.

Tables

Table 1. Table 1: The distribution of color class sizes in a legal 146-coloring for the C2000.5 instance  [ 38 ] ; the current best known bound is 145  [ 14 ]

	Size $b$										Total
	8	9	10	11	12	13	14	15	16
Number of color
classes with size $b$	2	4	15	10	16	14	14	18	53		146

Table 2. Table 2: Results of Dyn - Tabucol  for the selected 20 DIMACS instances

Instance	First	Rec	Grd	Rnd	Dsa	Rlf	Best	$\chi$
							[9, 30, 32]
DSJC1000.1	25 (1)	20 (6)	20 (4)	20 (6)	20 (11)	20 (5)	20	$\ge 10$
DSJC1000.5	113 (1)	88 (3)	88 (2)	88 (3)	89 (37)	88 (1)	82	$\ge 73$
DSJC1000.9	297 (1)	225 (6)	226 (32)	226 (31)	226 (19)	225 (1)	222	$\ge 216$
DSJC500.1	15 (11)	12 (50)	12 (50)	12 (50)	12 (50)	12 (50)	12	$\ge 5$
DSJC500.5	63 (3)	49 (13)	49 (8)	49 (3)	49 (7)	49 (9)	47	$\ge 43$
DSJC500.9	161 (3)	126 (2)	126 (1)	126 (3)	127 (50)	127 (50)	126	$\ge 123$
DSJR500.1c	87 (3)	86 (11)	87 (3)	87 (3)	86 (7)	85 (1)	85	84
DSJR500.5	129 (9)	124 (4)	127 (1)	128 (3)	125 (7)	126 (2)	122	122
R1000.1c	103 (3)	98 (33)	98 (11)	98 (12)	98 (23)	98 (24)	98	98
R1000.5	250 (50)	240 (4)	247 (1)	249 (9)	240 (2)	243 (2)	234	234
R250.1c	65 (34)	64 (26)	65 (34)	65 (34)	64 (28)	64 (12)	64	64
R250.5	66 (8)	66 (43)	66 (11)	66 (8)	66 (46)	66 (8)	65	65
flat1000_50_0	111 (1)	50 (50)	56 (2)	56 (1)	58 (1)	58 (1)	50	50
flat1000_60_0	112 (4)	60 (50)	73 (2)	74 (5)	75 (3)	75 (1)	60	60
flat1000_76_0	112 (1)	87 (1)	87 (2)	87 (1)	87 (1)	88 (47)	81	76
flat300_28_0	40 (1)	28 (4)	30 (1)	30 (1)	31 (49)	31 (50)	28	28
le450_15c	23 (12)	15 (2)	15 (3)	15 (1)	15 (2)	15 (1)	15	15
le450_15d	23 (2)	16 (50)	16 (49)	16 (50)	15 (1)	16 (50)	15	15
le450_25c	28 (4)	26 (50)	26 (50)	26 (50)	26 (49)	26 (50)	25	25
le450_25d	28 (19)	26 (50)	26 (50)	26 (50)	26 (50)	26 (50)	25	25
Averaged rank		1.40	2.85	2.90	2.80	2.95	-	-

Table 3. Table 3: Results of Foo - Partialcol  for the selected 20 DIMACS instances

Instance	First	Rec	Grd	Rnd	Dsa	Rlf	Best	$\chi$
							[9, 30, 32]
DSJC1000.1	25 (1)	20 (1)	21 (50)	21 (50)	21 (50)	21 (50)	20	$\ge 10$
DSJC1000.5	113 (1)	89 (20)	89 (13)	89 (18)	89 (12)	89 (14)	82	$\ge 73$
DSJC1000.9	297 (1)	227 (21)	229 (15)	229 (17)	229 (3)	230 (41)	222	$\ge 216$
DSJC500.1	15 (11)	12 (50)	12 (50)	12 (50)	12 (46)	12 (50)	12	$\ge 5$
DSJC500.5	63 (3)	49 (7)	49 (13)	49 (11)	49 (10)	49 (12)	47	$\ge 43$
DSJC500.9	161 (3)	127 (14)	127 (6)	127 (11)	127 (8)	127 (9)	126	$\ge 123$
DSJR500.1c	87 (3)	85 (11)	85 (7)	85 (12)	85 (7)	85 (17)	85	84
DSJR500.5	129 (9)	126 (15)	127 (3)	127 (3)	126 (13)	126 (11)	122	122
R1000.1c	103 (3)	98 (3)	99 (16)	99 (2)	99 (16)	99 (22)	98	98
R1000.5	250 (50)	243 (4)	250 (50)	250 (50)	244 (23)	246 (5)	234	234
R250.1c	65 (34)	64 (50)	64 (48)	64 (50)	64 (50)	64 (50)	64	64
R250.5	66 (8)	66 (26)	66 (10)	66 (9)	66 (24)	66 (12)	65	65
flat1000_50_0	111 (1)	50 (50)	78 (7)	78 (6)	79 (3)	78 (1)	50	50
flat1000_60_0	112 (4)	60 (50)	84 (1)	85 (26)	85 (7)	85 (4)	60	60
flat1000_76_0	112 (1)	88 (20)	88 (14)	88 (18)	88 (13)	88 (27)	81	76
flat300_28_0	40 (1)	28 (37)	28 (3)	29 (6)	28 (4)	28 (1)	28	28
le450_15c	23 (12)	15 (50)	15 (50)	15 (50)	15 (50)	15 (50)	15	15
le450_15d	23 (2)	15 (50)	15 (50)	15 (50)	15 (50)	15 (50)	15	15
le450_25c	28 (4)	26 (4)	26 (1)	26 (5)	26 (3)	26 (3)	25	25
le450_25d	28 (19)	26 (3)	26 (4)	26 (7)	26 (6)	26 (2)	25	25
Averaged rank		1.55	3.05	2.50	3.05	2.65	-	-

Table 4. Table 4: Results of Dyn - Tabucol  for the 13 timetabling instances

Instance	$n$	First	Rec	Grd	Rnd	Dsa	Rlf	[25]
hec-s-92	81	19 (50)	17 (49)	17 (37)	17 (37)	17 (48)	17 (43)	17
sta-f-83	139	13 (50)	13 (50)	13 (50)	13 (50)	13 (50)	13 (50)	13
yor-f-83	181	20 (50)	19 (38)	19 (22)	19 (22)	19 (37)	19 (27)	19
ute-s-92	184	10 (50)	10 (50)	10 (50)	10 (50)	10 (50)	10 (50)	10
ear-f-83	190	23 (50)	22 (48)	23 (50)	23 (50)	22 (47)	22 (45)	22
tre-s-92	261	23 (50)	20 (28)	20 (25)	20 (26)	20 (29)	20 (35)	20
lse-f-91	381	19 (50)	17 (50)	17 (1)	18 (18)	17 (50)	17 (9)	17
kfu-s-93	461	19 (50)	19 (50)	19 (50)	19 (50)	19 (50)	19 (50)	19
rye-s-93	486	22 (50)	21 (37)	21 (8)	21 (8)	21 (31)	21 (11)	21
car-f-92	543	30 (50)	28 (43)	30 (50)	30 (50)	28 (49)	28 (8)	27
uta-s-92	622	31 (50)	31 (50)	31 (50)	31 (50)	31 (50)	31 (50)	29
car-s-91	682	31 (50)	28 (14)	30 (4)	30 (1)	28 (9)	28 (12)	28
pur-s-93	2419	35 (50)	33 (44)	35 (50)	35 (50)	33 (47)	34 (18)	33
Averaged rank			1.31	3.15	3.23	1.54	2.15	-

Table 5. Table 5: Results of Head  for the selected 20 DIMACS instances

Instance	$k$		Rec$+$Rnd			Rnd$+$Rnd
			Solved	Avg$\pm$Stdev		Solved	Avg$\pm$Stdev
DSJC1000.1	22		50	0.033$\pm$0.006		50	0.036$\pm$0.006
	21		50	0.795$\pm$0.454		50	0.685$\pm$0.294
DSJC1000.5	85		50	39.10$\pm$19.45		50	46.32$\pm$14.30
	84		50	89.98$\pm$33.64		50	105.48$\pm$42.71
	83		22	216.68$\pm$67.42		16	207.41$\pm$47.31
DSJC1000.9	225		50	32.14$\pm$20.36		50	43.85$\pm$26.88
	224		46	85.81$\pm$64.98		45	99.49$\pm$51.88
	223		3	163.91$\pm$54.34		7	123.96$\pm$52.51
DSJC500.1	13		50	0.022$\pm$0.003		50	0.023$\pm$0.004
	12		50	36.33$\pm$26.41		50	49.12$\pm$39.17
DSJC500.5	50		50	1.05$\pm$0.519		50	1.40$\pm$0.715
	49		50	4.24$\pm$2.15		50	5.33$\pm$2.58
DSJC500.9	127		50	6.99$\pm$4.92		50	8.24$\pm$5.07
	126		22	77.46$\pm$69.62		19	84.67$\pm$70.08
DSJR500.1c	87		8	0.139$\pm$0.166		2	0.242$\pm$0.05
DSJR500.5	126		50	37.13$\pm$36.18		49	47.37$\pm$43.81
	125		40	118.88$\pm$86.99		42	144.36$\pm$79.31
	124		18	208.95$\pm$77.88		6	189.30$\pm$88.95
R1000.1c	99		15	3.01$\pm$7.95		2	2.37$\pm$2.23
	98		12	0.813$\pm$1.29		0	N/A
R1000.5	249		37	135.60$\pm$59.95		22	153.25$\pm$61.02
	248		19	195.21$\pm$66.52		8	209.24$\pm$62.59
	247		5	162.87$\pm$27.94		1	268.58$\pm$0.00
R250.1c	65		7	0.047$\pm$0.025		3	0.092$\pm$0.022
	64		5	0.043$\pm$0.048		0	N/A
R250.5	68		50	3.12$\pm$11.78		49	18.42$\pm$46.55
	67		43	26.85$\pm$45.28		42	47.83$\pm$67.37
	66		21	151.62$\pm$120.32		16	142.05$\pm$112.08
(To be continued)

(Continuation of Table 5)
Instance	$k$		Rec$+$Rnd			Rnd$+$Rnd
			Solved	Avg (s)		Solved	Avg (s)
flat1000_50_0	52		50	0.099$\pm$0.029		50	15.63$\pm$4.50
	51		50	0.113$\pm$0.038		49	19.02$\pm$6.33
	50		50	0.145$\pm$0.049		46	21.48$\pm$6.41
flat1000_60_0	62		50	0.243$\pm$0.075		50	28.80$\pm$7.05
	61		50	0.241$\pm$0.069		48	32.97$\pm$10.64
	60		50	0.324$\pm$0.120		49	35.40$\pm$10.22
flat1000_76_0	83		50	109.90$\pm$53.46		49	94.46$\pm$24.87
	82		20	209.85$\pm$37.09		15	236.64$\pm$60.47
flat300_28_0	30		3	164.94$\pm$118.42		1	315.38$\pm$0.0
	29		16	0.061$\pm$0.073		0	N/A
le450_15c	16		42	0.064$\pm$0.066		47	0.116$\pm$0.093
	15		1	0.061$\pm$0.0		0	N/A
le450_15d	17		50	0.021$\pm$0.005		50	0.060$\pm$0.014
	16		35	0.104$\pm$0.123		43	0.104$\pm$0.079
le450_25c	27		50	0.025$\pm$0.004		50	0.026$\pm$0.004
	26		50	0.345$\pm$0.250		50	0.376$\pm$0.254
le450_25d	27		50	0.024$\pm$0.003		50	0.025$\pm$0.003
	26		50	0.328$\pm$0.235		50	0.302$\pm$0.252

Equations

$$\mathcal{R}(c)\triangleq \{c^{\prime }\in {\mathcal{S}}_k:\forall i\in [k],V_{c^{\prime },i}\supseteq V_{c,i},V_{c^{\prime },i}\setminus V_{c,i}\subseteq V_{c,k+1}\}.$$

Full text

Keywords: Scheduling, vertex coloring problem, heuristics, initial solution, warm start

1 Introduction

For a positive integer $n$, let $[n]=\{1,\dots,n\}$. Assume that a graph $G=(V,E)$ is given. We abbreviate an edge $\{u,v\}\in E$ into $uv$ for simplicity. If $uv\in E$, we say that $u$ and $v$ are adjacent, or equivalently, that $u$ is a neighbor of $v$. A coloring is an assignment of colors to the vertices in $V$, and it is a $k$-coloring if it uses at most $k$ colors. Representing a color by an integer, we denote a $k$-coloring by a mapping $c:V\rightarrow[k]$. If $c(u)=c(v)$ holds for $uv\in E$, then we say that $uv$ is a conflicting edge, and that the extreme points $u$ and $v$ are conflicting vertices. A coloring $c$ is legal if there is no conflicting edge, and otherwise, it is illegal. For $i\in[k]$, let $V_{c,i}$ be the set of vertices that are given a color $i$, that is, $V_{c,i}=\{v\in V:~{}c(v)=i\}$. We call $V_{c,i}$ the color class $i$. By $c$, the vertex set $V$ is partitioned into $V=V_{c,1}\cup\dots\cup V_{c,k}$. Every color class is an independent set (i.e., no two vertices in the set are adjacent) iff $c$ is legal.

The $k$-colorability ($k$-Col) problem asks whether there exists a legal $k$-coloring for $G$. If the answer is yes, then we say that $G$ is $k$-colorable. The vertex coloring (VCol) problem asks for a legal $k$-coloring for the smallest $k$. The smallest $k$ that admits a legal $k$-coloring is called the chromatic number of $G$, which we denote by $\chi(G)$.

Due to their theoretical interest as well as possible applications, the $k$-Col problem and the VCol problem have attracted many researchers from various areas such as discrete mathematics [1, 2], optimization [20] and scheduling [22, 24]. The $k$-Col problem is NP-complete [12] and thus the VCol problem is NP-hard. For these problems, many exact algorithms and heuristics have been proposed so far. There are several booklets and surveys on algorithmic research on the VCol problem [9, 24, 30].

When it comes to heuristics, the VCol problem is often tackled by $k$-fixed strategies. In a $k$-fixed strategy, starting from an appropriate integer $k$, we search for a legal $k$-coloring, decreasing $k$ one by one, until a termination condition is satisfied. To make $k$ small quickly, it is demanded to solve the $k$-Col problem as fast as possible. Warm start should be effective for this purpose in practice [19], that is, a “good” initial solution should be fed to the algorithm. The quality of an initial solution is evaluated by a penalty function that estimates how far a $k$-coloring is from the legality (e.g., the number of conflicting edges).

In the present paper, we highlight a simple but effective method, which we call the recycle method, for generating an initial solution for the $k$-Col problem. The recycle method generates an initial solution by modifying the legal $(k+1)$-coloring that has been found. More precisely, it chooses some of the $k+1$ colors and then recolors all vertices that have the chosen colors so that one of the $k+1$ colors disappears from the graph. Consequently, we have a $k$-coloring, although it must be illegal in general. We use it as an initial solution of the algorithm for the $k$-Col problem.

The contribution of the paper is not to propose the recycle method but to show its empirical effectiveness. There are various initial solution generators for the $k$-Col problem, and the recycle method was already used in previous studies (e.g., [7, 15]). However, there is no study that makes an intensive comparison of them.

We present the background in Section 2, and then explain the motivation and the detail of the recycle method in Section 3. Interestingly, we can derive an upper bound on the penalty value of a $k$-coloring that is generated by the recycle method. In Section 4, we demonstrate the effectiveness of the recycle method by computational studies. We show how the performance of three heuristic algorithms is improved when the recycle method is employed as the initial solution generator, instead of conventional greedy/random methods, Dsatur [5] and Rlf [22]. The three heuristic algorithms that we use in our experiments are two well-known local search algorithms, Tabucol [17] and Partialcol [4], and a modern hybrid method, Head [32]. Specifically, with an initial solution generated by the recycle method, the heuristic algorithms tend to find a legal $k$-coloring more quickly especially when $k$ is not sufficiently small. On the other hand, when $k$ is small to some extent, the difference between initial solution generators becomes comparatively small. Hence, when we do not have much computation time and do not know a good upper bound on the chromatic number, it is a nice choice to use the recycle method as the initial solution generator. The benchmark instances are taken from DIMACS graphs111https://mat.gsia.cmu.edu/COLOR/instances.html and Carter et al.’s timetabling instances [6]. Finally we conclude the paper in Section 5.

2 Background

As the VCol problem is NP-hard, various heuristic algorithms have been proposed so far; e.g., tabu search [4, 17, 13], simulated annealing [33], variable neighborhood search [3], variable space search [18]. Hybrid methods include population-based methods [8, 10, 27, 29, 32], independent set extraction [14, 38], and quantum-inspired methods [35, 36]. More recently, data reduction techniques for massive (and possibly sparse) graphs have been studied intensively [15, 26, 37]. They aim at extracting a “hard” part of the graph by peeling out “easy” parts. The hard part still needs to be solved somehow, and thus it is a significant research issue to develop effective heuristic algorithms that find approximate solutions from instances with hundreds/thousands of vertices.

The search strategy of a heuristic algorithm is determined by the definitions of the search space and the penalty function to be minimized. There are two families of search strategies in the literature, $k$-fixed ones and $k$-nonfixed ones. In this study, we focus on the former, which is more popular. Refer to [11] for a detailed explanation of the two families of strategies.

In general, a $k$-fixed strategy searches for an approximate solution by solving the $k$-Col problem iteratively, as described in Algorithm 1.

Concerning the $k$-Col problem in line 1, let us denote by $\mathcal{S}$ the search space and by $\rho:\mathcal{S}\rightarrow\mathbb{R}_{+}\cup\{0\}$ the penalty function such that $\rho(c)=0$ holds iff $c$ is legal. Then the $k$-Col problem is reduced to the problem of minimizing the penalty function within $\mathcal{S}$. To reach to a legal $k$-coloring as soon as possible, if one exists, warm start should be effective [19]; that is, to start the search from an initial solution with a small penalty value.

To construct the “first” initial solution in line 1, we may apply various constructive algorithms in the literature such as a random method, a greedy method (called SEQ in [28]), Dsatur [5], Rlf [22], Danger [13], and GRASP [21]. On the other hand, less effort has been made for generation of an initial solution in line 1. A random method or a greedy method has mostly been applied for this task. The above-mentioned constructive algorithms can be applied, and what we call the recycle method has already been used in [7, 15]. Still, no intensive comparison has been made so far. In fact, Lewis et al. [25] stated that “the method of initial solution generation is not critical” in Tabucol’s performance, where Tabucol [17] is a well-known tabu search algorithm in the literature. In the rest of the paper, the term “initial solution” refers to one that is fed to a heuristic algorithm for the $k$-Col problem in line 1 unless no confusion arises.

Before closing this section, let us mention two concrete $k$-fixed strategies that are used in the literature.

$k$-fixed-penalty:

In this strategy, the solution space is the set of all possible $k$-colorings. We denote the set of all $k$-colorings by $\mathcal{S}_{k}$. A $k$-coloring $c\in\mathcal{S}_{k}$ is evaluated by the number of conflicting edges. Denoted by $\rho_{k}:\mathcal{S}_{k}\rightarrow\mathbb{R}_{+}\cup\{0\}$, it is defined to be $\rho_{k}(c)\triangleq|\{uv\in E:~{}c(u)=c(v)\}|$.

Tabucol [17] is a well-known local search algorithm that employs the search strategy. It explores the search space $\mathcal{S}_{k}$ by tabu search, using $\rho_{k}$ as the penalty function. Although it was born more than 30 years ago, the algorithm and its extension are still used as subroutines in modern metaheuristics [10, 11, 14, 27, 32, 38].

$k$-fixed-partial:

The search space is the set of what we call partial $k$-colorings. Let us denote by $\phi$ a dummy color. We define a partial $k$-coloring $c$ to be a function $c:V\rightarrow[k]\cup\{\phi\}$ such that, for every edge $uv\in E$, $c(u)\neq c(v)$ holds whenever $c(u),c(v)\in[k]$. In other words, a partial $k$-coloring admits uncolored vertices, which are represented by $\phi$, but does not admit conflicting edges. We denote the set of all partial $k$-colorings by $\hat{\mathcal{S}}_{k}$. A partial $k$-coloring is evaluated by how many vertices are assigned the dummy color. Denoted by $\hat{\rho}_{k}:\hat{\mathcal{S}}_{k}\rightarrow\mathbb{R}_{+}\cup\{0\}$, the penalty function is defined to be $\hat{\rho}_{k}(c)\triangleq|\{v\in V:~{}c(v)=\phi\}|$.

The search strategy was first introduced by Morgenstern [33]. Blöchliger and Zufferey [4] proposed a tabu search algorithm named Partialcol based on the search strategy.

3 Recycle Method

In this section, we present the recycle method, the spotlighted initial solution generator. Our aim is to develop a good initial solution generator for any heuristic algorithms under $k$-fixed strategies.

By the recycle method, we mean any method that constructs a $k$-coloring from a given legal $(k+1)$-coloring, say $c$, as an initial solution for the $k$-Col problem. In $k$-fixed strategies, a legal $(k+1)$-coloring is always available since the $(k+1)$-Col problem has been already solved. Some of previous methods construct initial solutions from scratch (e.g., the random/greedy method), whereas the recycle method constructs initial solutions by making use of the legal $(k+1)$-coloring.

We describe how to generate a $k$-coloring from a legal $(k+1)$-coloring, say $c$. Recall the two $k$-fixed search strategies that we mentioned in Section 2.

$k$-fixed-penalty:

We determine a nonempty subset $K\subseteq[k+1]$ and an element $\varepsilon\in K$. For every $i\in K$ and $v\in V_{c,i}$, we change the color of $v$ to a color in $[k+1]\setminus\{\varepsilon\}$. Because the color $\varepsilon$ disappears and there remain at most $k$ colors, we have a $k$-coloring by degenerating the region to $[k]$.

$k$-fixed-partial:

We determine a nonempty subset $K\subseteq[k+1]$. For every $i\in K$ and $v\in V_{c,i}$, we assign $\phi$ to $v$. Because there remain at most $k$ colors and a dummy color $\phi$ and no conflicting edge exists, we have a partial $k$-coloring by degenerating the region to $[k]\cup\{\phi\}$.

We have freedom of designing detailed configurations of the recycle method. In both strategies, the subset $K$ may be chosen randomly, or a set of colors whose color classes are the smallest. In the $k$-fixed-penalty, the color $\varepsilon$ to be removed is chosen at random or can be a color whose class is the smallest among $K$. We can change the color of a vertex in $V_{c,i}$ $(i\in K)$ into one in $[k+1]\setminus\{\varepsilon\}$ arbitrarily.

Let us describe the motivations of the recycle method. For the $k$-Col problem, it is known that easy-hard-easy phase transition exists with respect to $k$ [16, 31]. The peak of difficulty is said to lie around the chromatic number $k=\chi(G)$. In the $k$-fixed strategies, as $k$ gets smaller, the $k$-Col problem must be harder. A simple method like the random/greedy method must yield a poor initial solution for such $k$.

We claim that, when $k$ is small to some extent, a legal $(k+1)$-coloring should be precious in the sense that it cannot be obtained easily. We expect that a good $k$-coloring (in terms of the penalty function) could be obtained by a slight modification of the legal $(k+1)$-coloring. The expectation is supported by Table 1. The table shows the distribution of color class sizes in a legal 146-coloring for the C2000.5 instance that is found by Wu and Hao [38]. Most of the color classes are large. In particular, more than $1/3$ of the 146 color classes are largest independent sets that consist of 16 vertices. We also see that only few color classes are small. Even though we recolor some small color classes arbitrarily so that there remain at most $k$ colors, we could obtain a $k$-coloring that has few conflicting edges.

The last motivation is theoretical. Various configurations of the recycle method are possible, according to how to take $K$ (and $\varepsilon$ for the $k$-fixed-penalty) and how to change colors of the vertices in $\bigcup_{i\in K}V_{c,i}$. For some configurations, we can derive an upper bound on the penalty value of a generated solution, with respect to the graph size and $k$.

We denote a given legal $(k+1)$-coloring by $c$. Without loss of generality, we assume that $V_{c,k+1}$ is the smallest color class, that is, $|V_{c,k+1}|\leq|V_{c,i}|$ holds for any $i\in[k+1]$. We consider a configuration of the recycle method such that the smallest color class $V_{c,k+1}$ is recolored, that is, $K=\{k+1\}$.

$k$-fixed-penalty.

By $K=\{k+1\}$, the color $\varepsilon\in K$ to be removed is $k+1$. Let us define $\mathcal{R}(c)$ to be the set of all $k$-colorings that can be obtained by changing the colors of vertices in $V_{c,k+1}$ to ones in $[k]$, that is,

[TABLE]

For any $c^{\prime}\in\mathcal{R}(c)$, we can derive an upper bound on the penalty value $\rho_{k}(c^{\prime})$, as stated by the following proposition.

Proposition 1

For a graph $G=(V,E)$ with the maximum degree $\Delta$, let $c$ be a legal $(k+1)$-coloring such that $|V_{c,k+1}|\leq|V_{c,i}|$ holds for any $i\in[k+1]$. Any $c^{\prime}\in\mathcal{R}(c)$ satisfies $\rho_{k}(c^{\prime})\leq\displaystyle\frac{n\Delta}{k+1}$, where $n=|V|$.

Proof: Because $\{V_{c,1},\dots,V_{c,k+1}\}$ is a partition of $V$ and $V_{c,k+1}$ is the smallest set among them, we have $|V_{c,k+1}|\leq\frac{n}{k+1}$. For any $i\in[k+1]$, no edge should exist between any two vertices in $V_{c,i}$ because $V_{c,i}$ is independent. For any $i,j\in[k]$ with $i\neq j$, every edge between a vertex in $V_{c,i}$ and a vertex in $V_{c,j}$ is not conflicting in $c^{\prime}$. Then every conflicting edge in $c^{\prime}$ is incident to a vertex in $V_{c,k+1}$. Because the degree of a vertex is at most $\Delta$, the number of edges incident to vertices in $V_{c,k+1}$ is at most $\frac{n\Delta}{k+1}$.  $\Box$

Proposition 1 tells that, even though we assign arbitrary colors in $[k]$ to $V_{c,k+1}$, we have a $k$-coloring whose penalty value is at most $\frac{n\Delta}{k+1}$.

Suppose that we generate a $k$-coloring $c^{\prime}$ by assigning a color $i\in[k]$ to each $v\in V_{c,k+1}$, where the color $i$ is chosen at random. The expected value of $\rho_{k}(c^{\prime})$ is bounded as follows.

Proposition 2

For a graph $G=(V,E)$ with the maximum degree $\Delta$, suppose that we are given a legal $(k+1)$-coloring $c$ such that $|V_{c,k+1}|\leq|V_{c,i}|$ holds for any $i\in[k+1]$. Let $c^{\prime}\in\mathcal{R}(c)$ denote a $k$-coloring that is obtained by assigning a color $i\in[k]$ to each $v\in V_{c,k+1}$, where the color $i$ is chosen from $[k]$ at random. The expected value of $\rho_{k}(c^{\prime})$ is at most $\displaystyle\frac{n\Delta}{k(k+1)}$, where $n=|V|$.

Proof: For a vertex $v\in V_{c,k+1}$ and a color $i\in[k]$, let $f_{i}$ denote the number of conflicting edges incident to $v$ that appear when $v$ is assigned the color $i$. The expected number of conflicting edges incident to $v$ is $f_{1}/k+\dots+f_{k}/k\leq\Delta/k$. By $|V_{c,k+1}|\leq n/(k+1)$, the expected number of all conflicting edges is at most $\frac{n\Delta}{k(k+1)}$.  $\Box$

Let us compare the penalty values of a $k$-coloring $c^{\prime}$ that is obtained in the manner of Proposition 2 and a completely random $k$-coloring $r$. By a completely random $k$-coloring, we mean that every vertex is assigned a color $i\in[k]$ with probability $\frac{1}{k}$. Let $m=|E|$. Because each edge is conflicting with probability $\frac{1}{k}$, the expectation of $\rho_{k}(r)$ is $\frac{m}{k}$ from its linearity. On the other hand, the expectation of $\rho_{k}(c^{\prime})$ is at most $\frac{n\Delta}{k(k+1)}$. When $k$ is large to some extent, it is highly likely that $\rho_{k}(c^{\prime})<\rho_{k}(r)$ holds.

The following proposition provides derandomization of Proposition 2.

Proposition 3

For a graph $G=(V,E)$ with the maximum degree $\Delta$, suppose that we are given a legal $(k+1)$-coloring $c$ such that $|V_{c,k+1}|\leq|V_{c,i}|$ holds for any $i\in[k+1]$. We can generate a $k$-coloring $c^{\prime}\in\mathcal{R}(c)$ such that $\rho_{k}(c^{\prime})\leq\displaystyle\frac{n\Delta}{k(k+1)}$ in $O(n\Delta)$ time, where $n=|V|$.

Proof: Because $c$ is a legal $(k+1)$-coloring, any neighbor of a vertex $v\in V_{c,k+1}$ is assigned a color in $[k]$. There is a color $i$ in $[k]$ that appears at most $\frac{\Delta}{k}$ times among the $v$’s neighborhood. To recolor $v$, we let $c^{\prime}(v)\leftarrow i$, which counts at most $\frac{\Delta}{k}$ conflicting edges. Since $|V_{c,k+1}|\leq\frac{n}{k+1}$, we have $\rho_{k}(c^{\prime})\leq\frac{n\Delta}{k(k+1)}$. The time complexity is obvious.  $\Box$

$k$-fixed-partial.

By $K=\{k+1\}$, we generate a partial $k$-coloring $c^{\prime}$ from a legal $(k+1)$-coloring $c$ by assigning the dummy color $\phi$ to the smallest color class $V_{c,k+1}$, whereas the other color classes remain the same. We can derive an upper bound on the penalty value of the generated $k$-coloring.

Proposition 4

For a graph $G=(V,E)$ with the maximum degree $\Delta$, let $c$ be a legal $(k+1)$-coloring such that $|V_{c,k+1}|\leq|V_{c,i}|$ holds for any $i\in[k+1]$ and $c^{\prime}$ be a partial $k$-coloring such that $c^{\prime}(v)=c(v)$ for all $v\in V\setminus V_{c,k+1}$ and $c^{\prime}(v)=\phi$ for all $v\in V_{c,k+1}$. It holds that $\hat{\rho}_{k}(c^{\prime})\leq\displaystyle\frac{n}{k+1}$, where $n=|V|$.

Proof: The bound is due to $|V_{c,k+1}|\leq\frac{n}{k+1}$.  $\Box$

Let us give a remark on the penalty value of a random partial $k$-coloring, say $r^{\prime}$, which is constructed as follows; we first assign a random color from $[k]$ to every vertex in $V$. Then, while there is a conflicting edge, we repeat removing the color of a conflicting vertex (i.e., $\phi$ is assigned to the vertex). Because the expected number of conflicting edges is $\frac{m}{k}$, the expected penalty value $\hat{\rho}_{k}(r^{\prime})$ is at most $\frac{m}{k}$. We regard that the partial $k$-coloring $c^{\prime}$ of Proposition 4 has a better upper bound since $\hat{\rho}_{k}(c^{\prime})\leq\frac{n}{k+1}$ always holds and $\frac{n}{k+1}\leq\frac{m}{k}$ if $n\leq m$, which holds when $G$ is connected and not a tree.

4 Computational Studies

In this section, we present computational results to show how the recycle method is effective, in comparison with conventional initial solution generators. We observe how the performance of three $k$-fixed strategic heuristics changes with respect to initial solution generators. The heuristics include two local search algorithms, Tabucol [17] and Partialcol [4], and a modern hybrid method, Head [32].

We mention the experimental setup in Section 4.1. In Sections 4.2 and 4.3, we present the results on the local search algorithms and the hybrid method, respectively.

Our purpose in the experiment is not to update the best-known upper bounds of $\chi(G)$ for benchmark instances but is to show how the recycle method is effective in comparison with conventional initial solution generators. The best known bounds could be updated if we run heuristic algorithms for tens/hundreds of hours, as in [4, 32], with carefully determined parameter values. However, it is not our interest here. We would like to show that, with an initial solution generated by the recycle method, a $k$-fixed strategic heuristic algorithm finds a legal $k$-coloring more quickly especially when $k$ is not sufficiently small. This indicates that the recycle method enables us to share more time to work on the $k$-Col problem for smaller $k$.

4.1 Experimental settings

All the experiments are conducted on a workstation that carries an Intel Core i7-4770 Processor (up to 3.90GHz by means of Turbo Boost Technology) and 8GB main memory. The installed OS is Ubuntu 16.04.

For benchmark instances, we take up two types of instances: DIMACS instances and Carter et al.’s timetabling instances [6]. We let each heuristic algorithm solve an instance 50 times with different random seeds.

Suppose that we have found a legal $(k+1)$-coloring $c$ for some integer $k$. The next step of the $k$-fixed strategy is to solve the $k$-Col problem. We would like to generate an initial solution for heuristic algorithms. We summarize the five initial solution generators as follows.

• •

Recycle method (Rec): We use the recycle method in the configuration of Proposition 2. Let $i^{\ast}\in[k+1]$ denote a color such that $V_{c,i^{\ast}}$ is the smallest color class among $V_{c,1},\dots,V_{c,k+1}$. We set $K=\{i^{\ast}\}$. In the $k$-fixed-penalty strategy, $\varepsilon$ is automatically set to $i^{\ast}$. Vertices in $V_{c,i^{\ast}}$ are recolored to ones in $[k+1]\setminus\{\varepsilon\}$ randomly ($k$-fixed-penalty) or to $\phi$ ($k$-fixed-partial).

• •

Greedy method (Grd): We visit the vertices in a random order. For a visited vertex $v$, if there is a color $i\in[k]$ such that assigning $i$ to $v$ does not produce a conflicting edge, then we assign the smallest $i$ to $v$. Otherwise, we assign a random color in $[k]$ to $v$ ($k$-fixed-penalty) or leave $v$ uncolored ($k$-fixed-partial).

• •

Random method (Rnd): In the $k$-fixed-penalty strategy, we assign a random color in $[k]$ to each vertex $v\in V$. In the $k$-fixed-partial strategy, we visit vertices in a random order. Then for each $v\in V$, let us denote by $K_{v}$ the set of colors that appear in the neighborhood of $v$. If $K_{v}\subsetneq[k]$, then we assign a random color in $[k]\setminus K_{v}$ to $v$. Otherwise (i.e., no color is available), we assign the dummy color $\phi$ to $v$.

• •

Dsatur [5] (Dsa): It is a constructive algorithm that repeats picking up a vertex with the largest chromatic degree (i.e., the number of colors that appear in the adjacent vertices), and then assigning the smallest color to the vertex so that no conflicting edge arises, until all vertices are assigned colors. Suppose that we have obtained a $k^{\prime}$-coloring $(k^{\prime}>k)$ by Dsa. To make it a $k$-coloring, we turn the color of any vertex that is assigned a color in $\{k+1,\dots,k^{\prime}\}$ into one in $[k]$ randomly ($k$-fixed-penalty) or into the dummy color $\phi$ ($k$-fixed-partial).

• •

Rlf [22]: It repeats extracting a maximal independent set as a color class until all vertices are chosen. Suppose that $k$ independent sets have been extracted as color classes by Rlf. To obtain a $k$-coloring based on them, we assign random colors in $[k]$ ($k$-fixed-penalty) or the dummy color $\phi$ ($k$-fixed-partial) to the remaining vertices.

4.2 Recycle method on local search algorithms

Overview of the algorithms.

Tabucol [17] and Partialcol [4] are local search algorithms that exploit the $k$-fixed-penalty and $k$-fixed-partial strategies, respectively.

We downloaded the source codes of Tabucol and Partialcol (written in C) from R. Lewis’s website.222http://rhydlewis.eu/resources/gCol.zip In the program, Grd is implemented as the initial solution generator for the $k$-Col problem (line 4 in Algorithm 1). We appended implementation of the other four generators in the source codes, utilizing functions and data structures in the original source code as possible.

For the iterative scheme (Algorithm 1), we construct the first initial solution in line 1 by Dsatur [5]. For the termination condition in the while-loop, we set the upper limit of computation time to 600 seconds. In our preliminary studies, we observed that computation time of the initial solution generators is negligible in comparison with the tabu search. We also observed that 600 seconds are enough to draw our conclusion that the recycle method is effective especially when $k$ is not sufficiently small. Some of other papers in the literature use a much longer time limit (e.g., ten hours in [4]). Their experimental purpose is to update the best-known upper bound of a chromatic number, which is different from our experiments.

Both Tabucol and Partialcol are tabu search algorithms. The tabu tenure is determined by either the dynamic scheme (Dyn) or the reactive scheme (Foo).

• •

Dyn: The tabu tenure is set to $\alpha n_{c}+\gamma$, where $\alpha=0.6$, $n_{c}$ is the number of conflicting vertices, and $\gamma$ is an integer that is picked up from $\{0,\dots,9\}$ at random. This setting of the tabu tenure is recommended in the literature [4, 10, 25].

• •

Foo: Proposed in [4], the scheme provides a reactive tabu tenure based on the fluctuation of the objective (Foo) function. Roughly, if the penalty value does not change during a long period, the tenure is set to a large value in order to escape from search stagnation. It is then decreased slowly along the search process. We use random parameter values, following the R. Lewis’s original implementation.

We represent Tabucol whose tabu tenure is set by the Dyn scheme as Dyn-Tabucol. It is analogous with Foo-Tabucol, Dyn-Partialcol, and Foo-Partialcol. We will present the results of only Dyn-Tabucol and Foo-Partialcol in the paper. The other two algorithms achieve the similar results.

DIMACS instances.

We solve 20 DIMACS instances that are treated in [4]. We present the results of Dyn-Tabucol and Foo-Partialcol in Tables 2 and 3, respectively. For each instance, the number after the first alphabets represents the number of vertices. For example, the DSJC1000.5 instance consists of 1000 vertices and is a random graph of the Erdös-Rényi model with edge density 0.5. See [4] for a description of the instances.

In the column “First” (resp., “Rec” to “Rlf”), the integer without parentheses in the entry indicates the smallest number of colors attained by the first initial solution generator (resp., by Dyn-Tabucol or Foo-Partialcol with Rec to Rlf) over 50 trials, and the integer in parentheses indicates how many trials the smallest number of colors is achieved. In the rightmost two columns, we show the best-known upper bounds (“Best”) and the chromatic numbers or their lower bounds (“$\chi$”) that are reported in recent papers [9, 30, 32]. They are shown just for readers’ information. Recall that our interest here is not in improving the bounds but in the performance difference derived from initial solution generators.

We compare the five initial solution generators in the smallest number of colors achieved and its frequency over 50 trials. For each instance, we regard that an initial solution generator $g$ is more effective than another generator $g^{\prime}$ if

• •

$g$ achieves a strictly smaller number of colors than $g^{\prime}$; or

• •

$g$ and $g^{\prime}$ achieve the same number of colors, but $g$ does it more frequently.

In Tables 2 and 3, we indicate the only best generator (i.e., no tie with or lost to other generator) for each instance by boldface if one exists. We see that Rec, Grd, Rnd, Dsa and Rlf are the only best generators in 8, 2, 1, 3 and 1 instances in Table 2, and in 10, 1, 2, 0, 2 instances in Table 3, respectively. We see that, for both local search algorithms, Rec is the best initial solution generator in most instances. We also show the averaged rank of each initial solution generator over the instances in the last row of the tables. We see that Rec is much better than the others while the others are more competitive.

The results tell that, with Rec, we are more likely to obtain a legal $k$-coloring with a smaller $k$. We consider that it is thanks to better initial solutions generated by the recycle method, by which Dyn-Tabucol or Foo-Partialcol solves the $k$-Col problem more quickly.

Timetabling instances.

Next, we solve 13 timetabling instances posed by Carter et al. [6]. The instances ask to assign time slots (colors) to exams (vertices) so that no two exams are assigned the same time slot if there is a student who takes both exams (i.e., the two exams are joined by an edge). We are required to use as few time slots as possible. According to [25], the timetabling instances are different from random graphs in degree coefficients of variation (CV). The degree CV is defined as the ratio of the standard deviation over the averaged vertex degree. In a random graph, it is shown that the degree CV does not exceed $28\%$, while it is from $36.3\%$ to $129.5\%$ in the timetabling instances. This means that the vertex degree is more scattering in the timetabling instances and that the timetabling instances has different graph structures from DIMACS instances, most of which are generated as random graphs.

We show the results of Dyn-Tabucol in Table 4. We see the superiority of the recycle method again. We see that Rec, Grd, Rnd, Dsa and Rlf are the only best generators in 5, 0, 0, 2 and 1 instances, respectively. The averaged rank in the last row shows that Rec is the best, followed by Dsa and Rlf, which are comparatively better than Grd and Rnd.

In the rightmost column, we show the best results in [25] for readers’ information, where Tabucol, Partialcol, HEA [10], ant-colony method [8], hill-climbing method [23] and backtracking Dsatur algorithm [5] are compared.

Discussion.

We have seen that the recycle method is more effective than other initial solution generators for many instances.

The merit of using the recycle method is that we can start the search from a good initial solution that has a small penalty value, where the penalty value has a theoretical upper bound. The remarkable success of the recycle method in such DIMACS instances as flat1000_50_0 and flat1000_60_0 must be due to the merit.

The recycle method is not necessarily effective for all $k$. The smaller $k$, the more difficult the $k$-Col problem would be. The search space must have a large number of valleys of locally optimal solutions. Then the local search that starts from a good initial solution (i.e., one generated by the recycle method) may fall into such valleys. We consider that, for such $k$, the recycle method is not effective any more. In DIMACS instances DSJC500.1, DSJC500.5 and DSJC500.9 and timetabling instances sta-f-83 and tre-s-92, the local search succeeds in improving $k$ to a sufficiently small value (e.g., the best-known value or a value close to it) within the time limit, regardless of the initial solution generator. For such $k$, the recycle method does not outperform others significantly.

Detailed comparison of initial solution generators.

Here we compare the five initial solution generators in the following aspects:

(I)

How small is a penalty value of the initial solution?

(II)

How fast does Dyn-Tabucol decrease $k$?

(I) We show that the recycle method generates a good initial solution in terms of the penalty value.

See Fig. 1. We show how penalty values (average over 50 trials, vertical axis) of initial solutions change with respect to the number $k$ of colors (horizontal axis). The figure is taken from the experiment on the DSJC1000.5 instance. The five curves correspond to the five initial solution generators.

The figure shows the general tendency that is observed in many instances; when $k$ gets smaller, the penalty values achieved by Grd, Rnd, Dsa and Rlf are increasing more and more, whereas the penalty values achieved by Rec do not make a remarkable increase, as depicted in Fig. 1. In general, Rec yields the smallest penalty value, followed by Rlf, Dsa, Grd and Rnd, where Dsa is better than Rlf in some instances.

This tendency is not observed for all instances. Let $k_{0}$ denote the number of colors in the first initial solution that is produced by Dsatur (i.e., line 1 in Algorithm 1). When $k$ is about $k_{0}-1$ to $k_{0}-5$, Rlf and Dsa often yield a smaller penalty value than Rec. This must be because the $k$-Col problem for such $k$ is so easy that Rlf and Dsa can produce good initial solutions. For instances such that the difference between $k_{0}$ and the achieved number of colors is small (i.e., DSJC500.1, R250.1c and R250.5), we have not observed the tendency that is shown in Fig. 1.

Recall the analysis on a penalty value in Section 3. We see that, in Fig. 1, the penalty values achieved by Rnd are close to the expectation $m/k$; The instance has approximately $m=2.5\times 10^{5}$ edges, and when $k=10^{2}$, for example, the penalty value is close to $m/k=2.5\times 10^{3}$. On the other hand, the expectation of a penalty value achieved by Rec is bounded by $\frac{n\Delta}{k(k+1)}$ (Proposition 2); The instance has $n=10^{3}$ vertices and thus the maximum degree $\Delta$ is at most $n=10^{3}$. For any $k$ that is shown in the figure, we see that the averaged penalty value of Rec is surely lower than the upper bound $\frac{n\Delta}{k(k+1)}$.

(II) Here we show that, with the recycle method, the tabu search algorithms decrease the number $k$ of colors faster than other generators in many instances.

In Fig. 2, we show how the number $k$ of colors (vertical axis) is improved by Dyn-Tabucol along with computation time (average over 50 trials, horizontal axis). We mentioned that, when Dyn-Tabucol is employed, the recycle method is the best generator in 8 out of 20 DIMACS instances (Table 2). In these instances, we observe that Dyn-Tabucol with Rec decreases $k$ faster than other generators. We show in Fig. 2 DSJC1000.9, R1000.5 and flat1000_50_0 as examples. We see that improvement of Rec  is made faster than other generators. On the other hand, we do not observe this tendency for instances such that the recycle method is less effective, as shown in the case of the DSJC1000.5 instance in Fig. 2.

The smaller $k$, the harder the $k$-Col problem is likely to be. When $k$ is “sufficiently small,” where the extent of being “sufficiently small” is different from instance to instance, it is not necessarily effective to start local search from an initial solution that has a smaller penalty value since such a solution must be among deep valleys of locally optimal solutions. To overcome this issue, we should improve the heuristic algorithm itself rather than the initial solution generator. On the other hand, when $k$ is not so small, there is a merit in using the recycle method as the initial solution generator since it would decrease $k$ faster than other generators.

4.3 Recycle method on a hybrid method

Overview of the algorithm.

The hybrid method that we take up here is Head (Hybrid Evolutionary Algorithm in Duet) [32], which is based on Hea (Hybrid Evolutionary Algorithm) [10]. Head is regarded as a memetic algorithm [34], that is, a genetic algorithm such that each individual is improved by local search. The characteristic of Head is that it maintains only two solutions in the population.

We summarize Head in Algorithm 2. It is a heuristic algorithm for the $k$-Col problem that exploits the $k$-fixed-penalty strategy, and thus can be used within the iterative scheme in Algorithm 1. We explain roles of important steps as follows.

Line 1:

The algorithm maintains five solutions during the execution. The $p_{1}$ and $p_{2}$ are solutions in the population, while $e_{1}$ and $e_{2}$ are elite solutions in recent “cycles,” where a cycle represents successive $\tau_{C}$ generations. The parameter $\tau_{C}$ determines the length of a cycle, and we set it to the default value (10). The best solution in the current cycle is stored as $e_{1}$, whereas $e_{2}$ stores the best solution in the last cycle. The $b$ is used to store the best solution among those searched.

Lines 4 and 5:

GPX (Greedy Partition Crossover) is a crossover operator [10]. Given two parent solutions $p_{1}$ and $p_{2}$, GPX$(p_{1},p_{2})$ constructs a child solution $c$ by choosing the largest color class from $p_{1}$ and $p_{2}$ alternatively as a color class of $c$. To be more precise, the largest subset among $V_{p_{1},1},\dots,V_{p_{1},k}$ is chosen as $V_{c,1}$, the largest subset among $V_{p_{2},1}\setminus V_{c,1},\dots,V_{p_{2},k}\setminus V_{c,1}$ is chosen as $V_{c,2}$, and so forth. After $k$ subsets are chosen, the remaining vertices are colored by 1 to $k$ randomly. Note that GPX$(c_{1},c_{2})$ and GPX$(c_{2},c_{1})$ can deliver different solutions.

Lines 6 and 7:

Tabucol$(c,\tau_{T})$ denotes an execution of Tabucol such that $c$ is used as the initial solution, $\tau_{T}$ is the number of iterations (where we use the default value ($3\times 10^{4}$)), and the tabu tenure is determined by an original mechanism. The obtained solutions are used as parents in the next generation.

Lines 10 to 13:

The variable $t$ plays the role of the generation counter. When $t$ is a multiple of $\tau_{C}$, what we call a cycle finishes. In this case, a parent $p_{1}$ in the next generation is replaced by $e_{2}$, the best solution in the last cycle (line 11), $e_{2}$ is replaced by $e_{1}$, the best solution in the current cycle (line 12), and $e_{1}$ is replaced by a random $k$-coloring (line 13). We may say that $e_{1}$ and $e_{2}$ are used to diversify the search.

Comparison of initial population generators.

Here we show that it is promising to use the recycle method in generation of the initial population. More specifically, when the recycle method is used, Head (Algorithm 2) tends to solve the $k$-Col problem more quickly, compared with the case when the default generator is used.

In the original implementation of Head, two $k$-colorings $p_{1}$ and $p_{2}$ in the initial population are generated by Rnd. We call this default generation scheme by Rnd+Rnd. We compare it with Rec+Rnd, that is, $p_{1}$ is generated by the recycle method whereas $p_{2}$ is still generated by Rnd.

We downloaded the source code of Head333https://github.com/graphcoloring/HEAD that is written in C++. We added implementation of Rec+Rnd to the source code. We solved the $k$-Col problem 50 times for each of the 20 DIMACS instances. We set the time limit to 300 seconds, that is, we break the do-while-loop (i.e., lines 3 to 15 in Algorithm 2) when the computation time exceeds 300 seconds.

Head is an algorithm for the $k$-Col problem. We observe how fast and how often it solves the problem within the time limit, whereas we concentrated on how fast local search algorithms improve $k$ in the last experiment.

We summarize results in Table 5. A column “Solved” shows how many trials Head finds a legal $k$-coloring over the 50 trials, and a column “Avg+Stdev” shows the averaged computation time and the standard deviation, which are taken over the trials where a legal $k$-coloring is found. The table shows the results for $k$ such that at least one legal $k$-coloring is found over all trials. This means that, for example, a legal 20-coloring is not found for DSJC1000.1 for any trial in the experiment.

We claim that (Head with) Rec+Rnd should be at least as good as Rnd+Rnd, or even better than Rnd+Rnd in some cases. Comparing the columns “Solved”, we see that Rec+Rnd solves the $k$-Col problem in more trials (resp., in the same number of trials and in less trials) than Rnd+Rnd in 25 (resp., 17 and 4) out of the 46 rows in the table. Observe bold numbers. They represent cases such that Rec+Rnd should be especially better than Rnd+Rnd in the following sense;

• •

The number of trials that Rec+Rnd solves the problem is emphasized in four rows, that is, 12 for R1000.1c $(k=98)$, 5 for R250.1c $(k=64)$, 16 for flat300_28_0 $(k=29)$ and 1 for le450_15c $(k=15)$. In these four cases, Rnd+Rnd does not solve the problem in any trial.

• •

The computation time of Rec+Rnd is emphasized in 16 out of the 46 rows. In these cases, it is judged by a statistical test that the averaged computation time is different from (i.e., smaller than) that of Rnd+Rnd. For a statistical test, we conduct Student’s $t$-test if the variance is statistically different between two samples (decided by $F$-test) and Welch’s $t$-test otherwise, where the significance level is set to 0.05 in all tests.

On the other hand, no number in the columns for Rnd+Rnd is emphasized by boldface since Rnd+Rnd is not better than Rec+Rnd in the above sense.

There are many strategies possible to generate an initial population. We may use other constructive algorithms such as Grd, Dsa and Rlf that are mentioned in Section 4.1. Some solutions in the population can be generated so that they are “distant” from other solutions for diversification of the search.

Still, we regard Rec+Rnd as a reasonable initial population generator for Head. We have observed that Rec produces a good initial solution in the sense of the penalty value, compared with other constructive algorithms. The initial population generator Rec+Rnd constructs $p_{1}$ by Rec and $p_{2}$ by Rnd, where $p_{2}$ is expected to be “distant” from $p_{1}$ to some extent. Our experiments illustrates that, for hybrid methods, there should be merit in including a solution that is generated by the recycle method into an initial population.

5 Concluding Remark

In the present paper, we highlighted the recycle method, an initial solution generator of a general heuristic algorithm that employs the $k$-fixed search strategies. We provided our motivation that includes analyses of upper bounds on the penalty value. Experimental results showed that the recycle method can make Tabucol and Partialcol, representative tabu search algorithms, achieve a fewer number of colors than the conventional methods, that is, Grd, Rnd, Dsa, and Rlf. Moreover, the recycle method accelerates improvement of the number of colors in early iterations of the iterative scheme, in comparison with these methods. We also demonstrated that the hybrid method Head with Rec+Rnd tends to find a legal $k$-coloring more quickly than Head with the default generator Rnd+Rnd.

The recycle method is universal in the sense that it can be applied for any $k$-fixed strategic heuristic algorithm somehow. Our experiments deal with three algorithms in the literature, Tabucol, Partialcol and Head, which are just illustrative examples. The recycle method is so simple that it has already been used in previous studies (e.g., [7, 15]). However, the present paper is the first one that investigates its effectiveness from theoretical as well as experimental viewpoints.

The recycle method is efficient. Let $c$ be a legal $(k+1)$-coloring. For the configuration of Rec, it takes $O(n)$ time to determine the smallest color class and to recolor the vertices in the class, whereas the running times of Dsatur and Rlf are bounded by $O(n^{2})$ and $O(n^{3})$, respectively [24]. It is also worthwhile to mention that the recycle method is easy to implement.

We hope that the recycle method becomes a standard initial solution generator for the $k$-Col problem.

Acknowledgments

We gratefully acknowledge very careful and detailed comments given by anonymous reviewers.