Distributed graph coloring: an approach based on the calling behavior of Japanese tree frogs
- 509 Downloads
- 10 Citations
Abstract
Graph coloring—also known as vertex coloring—considers the problem of assigning colors to the nodes of a graph such that adjacent nodes do not share the same color. The optimization version of the problem concerns the minimization of the number of colors used. In this paper we deal with the problem of finding valid graphs colorings in a distributed way, that is, by means of an algorithm that only uses local information for deciding the color of the nodes. The algorithm proposed in this paper is inspired by the calling behavior of Japanese tree frogs. Male frogs use their calls to attract females. Interestingly, groups of males that are located near each other desynchronize their calls. This is because female frogs are only able to correctly localize male frogs when their calls are not too close in time. The proposed algorithm makes use of this desynchronization behavior for the assignment of different colors to neighboring nodes. We experimentally show that our algorithm is very competitive with the current state of the art, using different sets of problem instances and comparing to one of the most competitive algorithms from the literature.
Keywords
Distributed graph coloring Calling behavior of Japanese tree frogs1 Introduction
Given an undirected graph G=(V,E), where V is the node set and E is the edge set, and a number k>0 of colors, a valid k-coloring of the graph is the assignment of exactly one color to each node such that adjacent nodes (that is, nodes that are connected by an edge) do not share the same color. Formally, we say that a k-coloring of an undirected graph G=(V,E) is a function c:V→{1,2,…,k} such that c(u)≠c(v) for each edge (u,v)∈E. The optimization version of the graph coloring problem (GCP), which is NP-hard (Karp 1972), consists of finding the minimum number k^{∗} of colors such that a valid k^{∗}-coloring can be found. This number is called the chromatic number of graph G and is denoted by χ(G). The GCP is quite generic. Practical applications originate especially from problems that can be modeled by networks and graphs; for example, communication networks. Several tasks in modern wireless ad-hoc networks, such as sensor networks, are related to graph coloring. Examples include TDMA slot assignment (Herman and Tixeuil 2004), detection of mobile objects and reduction of signaling actuators (Zhang et al. 2005), distributed MAC layer management (Guo et al. 2001), energy-efficient coverage (Cardei et al. 2002), delay efficient sleep scheduling (Lu et al. 2005) or wakeup scheduling (Keshavarzian et al. 2006). Due to the distributed nature of these networks, algorithms for solving problems related to graph coloring are generally also required to be distributed (Lynch 2009). Such algorithms make an exclusive use of local information for deciding the color of the nodes, that is, they are characterized by the absence of any central control mechanism. The goal of this paper is to devise an algorithm for generating valid colorings in a distributed manner.
1.1 Our contribution
In this paper we propose a distributed algorithm for graph coloring inspired by the calling behavior exhibited by male Japanese tree frogs for the attraction of females. Several researchers have observed that male Japanese tree frogs decouple their calls (Wells 1977). This property has evolved because females can only localize the males when their calling is not too close in time. Aihara et al. (2008) proposed a theoretical model for simulating the behavior of these frogs. The authors describe an oscillator system, where each oscillator has a phase θ∈[0,2π] that changes over time with frequency ω (where 2π is the time interval between two calls of the same frog). When the phase reaches 2π, the oscillator fires and returns to the baseline phase (θ=0). The proposed system works such that oscillators try to maximize the distance between their phases. This model works nicely for the desynchronization of two oscillators. However, when more than two oscillators are involved, the model does not accurately reflect the real behavior of the frogs. A subsequent work (Aihara 2009) mentions some potential applications of this model in artificial life and robotics. In both works the author(s) mention the limitations of the systems when operating with groups of more than two coupled oscillators. In fact, already with three oscillators the final solution (and its stability) strongly depends on the initial variable settings.
The desynchronization of the frogs’ calls is achieved in a self-organized way. Therefore, the proposed algorithm, which is inspired by this self-desynchronization mechanism, can be regarded as a swarm intelligence approach (Bonabeau et al. 1999; Dorigo and Birattari 2007; Blum and Merkle 2008). Apart from some minor modifications, it makes use of a model of frogs’ desynchronization introduced by Aihara et al. (2008). Moreover, for the purpose of detecting convergence and for storing the best solution found, the proposed algorithm makes use of an overlay tree structure rooted in a so-called master node. Such a mechanism is common, for example, in the context of distributed local search algorithms (Zivan 2008). The algorithm can be easily implemented, for example, in sensor networks. In addition to competitive results it comes with several advantages, such as, for example, low energy consumption or the potential to adapt to changing network topology. However, as mentioned before, the main goal of the algorithm is to obtain valid colorings that use as few colors as possible, while attempting to minimize the number of iterations needed to achieve these results. An extensive experimental evaluation shows that the results of the algorithm are comparable or better than state-of-the-art algorithms in terms of the number of colors used. In particular, the good performance of our algorithm for grid graphs of any size is remarkable. On the downside, the results also show that our algorithm may sometimes require a slightly higher number of communication rounds than the baseline algorithm chosen for comparison.
1.2 Prior work on graph coloring
Concerning prior work, a distinction must be made between centralized and distributed algorithms. Concerning centralized algorithms, the literature offers both exact approaches that guarantee to find an optimal solution in bounded time and approximate algorithms. A recent survey can be found in Malaguti and Toth (2010). An example of an exact algorithm is Malaguti et al. (2011), although—due to the intractable nature of the GCP—larger problem instances can only be tackled efficiently by heuristic approaches. Especially effective are the tabu search algorithm from Blöchliger and Zufferey (2008), the evolutionary algorithm from Malaguti et al. (2008), the hybrid approach combining tabu search and evolutionary algorithms from Lü and Hao (2010), and the variable space search technique (Hertz et al. 2008). These algorithms are currently the best centralized metaheuristics for solving the GCP. Earlier remarkable works are the hybrid evolutionary algorithm from Galinier and Hao (1999), the genetic local search algorithm from Dorne and Hao (1998) and the variable neighborhood search in Avanthay et al. (2003).
When considering distributed algorithms, it is very difficult (if not impossible) to narrow the state of the art down to a small set of algorithms. This is because distributed algorithms may be designed with very different goals. These goals may concern, for example, the performance for particular topologies, the minimization of execution time (or communication rounds), the generation of the best colorings possible, or the performance for dynamically changing topologies. In addition, a general problem is that most proposals are not evaluated on publicly available sets of benchmark instances. Moreover, results are generally not shown per instance, making it difficult to compare to the proposed algorithms. In the following we focus on algorithms that generate valid solutions and compare their simplicity, solution quality and time complexity.^{1} It must also be noted that many of the proposed distributed algorithms were developed for applications in networks of devices with scarce resources. For this reason authors often study the message load the algorithm implies and try to minimize the amount of calculation required by the algorithm. Typically, these algorithms are meant to work on a lower layer of the network in parallel with the applications or information flows that the user may require to send. Fraigniaud et al. (2009), study the effect of the amount of information shared between the nodes on the quality of the obtained colorings.
One of the most general works was presented by Finocchi et al. (2005). The authors introduced three versions of a distributed algorithm and studied its behavior under various conditions. The authors considered both the problem of obtaining O(Δ+1)-colorings in as few communication rounds as possible, as well as the problem of generating the best possible colorings without any limit on the number of communication rounds. Here, Δ refers to the maximum degree of a graph. The authors provide extensive experimental results for both cases. Most of their experimentation is based on random graphs, which are not publicly available. However, they also present results on a well-known set of publicly available instances from the DIMACS challenge (Center for Discrete Mathematics and Theoretical Computer Science 2006). As the algorithm proposed in Finocchi et al. (2005) was shown to outperform the state of the art, we chose this algorithm for comparison. Another remarkable work from the field of distributed algorithms for graph coloring is the distributed largest-first (DLF) algorithm introduced in Kubale and Kuszner (2002). DLF is an improvement over an algorithm from the literature consisting in randomly ordering the nodes and using this order to allow nodes to choose colors with the only rule that colors which are already assigned to neighbors cannot be used. DLF differs from the original algorithm version in the order of the nodes. In DLF, the higher the degree of a node the earlier the node will be able to choose a color. The random order is only used to break ties between nodes which have the same degree. DLF achieves better results than the original algorithm on random graphs.
Concerning distributed algorithms based on swarm intelligence principles, the literature offers, for example, a method inspired by the synchronous flashing of fireflies (see Lee 2008). This algorithm, which allows a simple implementation, reaches valid colorings fast, in a constant number of communication rounds, regardless of the size of the network. However, this work does not focus on minimizing the number of colors. The first intent to use the calling behavior of frogs for graph coloring was presented in Lee and Lister (2008). Valid colorings are obtained by assigning a color to each phase used by the nodes (that is, the oscillators). Therefore, if two nodes are synchronized to exactly the same phase, they will be sharing a common color (the authors consider a function f:[0,2π]→(R,G,B), where 2π is the time frame between two callings of the same frog). The main drawback of this approach is that nodes with very near phases will be colored with different colors. As such small deviations usually occur when the number of nodes in the system increases, the algorithm does not obtain competitive results. This work was further extended by adding a parameter for setting the number of allowed phases a priori (Lee 2010). Experimentation shows that the system is able to find optimal solutions for small topologies, given that the optimal number of colors is known. Note that in contrast to these works, the algorithm that we propose aims to minimize the number of colors used without any prior knowledge about the optimal solution.
The graph coloring problem has also been studied in the context of belief propagation methods (Pearl 1986) from the field of artificial intelligence. These methods, which belong to the family of message passing algorithms, define ways to adequately propagate and fuse information flows in networks. The goal of belief propagation is that each node—once a stable state is reached—should be able to provide a measure of belief about the satisfaction of a certain predicate. However, belief propagation techniques are generally applied to infer properties of large problem instances (for example, about the distribution of solutions in the search space) rather than to find actual solutions to specific problem instances. Some works about graph coloring from this perspective are those that study the decisional version of the Δ-coloring problem. In Braunstein et al. (2003), the authors provide a survey propagation (Maneva et al. 2007) method—one of the categories of belief propagation methods—for finding valid colorings and in Kroc et al. (2009) belief propagation is used for counting solution clusters in the search space.
The literature also offers many works that consider distributed graph coloring from a theoretical point of view. Most provide upper bounds for the coloring quality as well as the time complexity under different constraints. Hansen et al. (2004) studied the DLF algorithm, which runs in O(Δ^{2}logn) communication rounds for arbitrary graphs and that was proven to provide good upper bounds for specific topologies. This algorithm was based on the largest-first approach which consists of giving priority for choosing a color to the nodes with the highest degree (Δ). This work was further extended by Kosowski and Kuszner (2006) who reduced the time complexity to O(ΔlognlogΔ). These authors also proved that some other approaches, like smallest-last or dynamic-saturation, are not suitable for distributed environments. Later, Moscibroda and Wattenhofer (2008) introduced an algorithm for obtaining O(Δ)-colorings in O(Δlogn) time when considering random geometric graphs and other well-known models for wireless multi-hop networks (no results are given for other topologies). Other theoretical works of interest for the development of new algorithms are the game theoretic approach for efficient graph coloring from Panagopoulou and Spirakis (2008), the work by Kuhn and Wattenhofer (2006), which introduces a new lower bound on the number of colors used by algorithms that are restricted to one single communication round and a new lower bound on the time complexity of obtaining a O(Δ)-coloring of a graph, the article by Barenboim and Elkin (2010) which introduces the first polylogarithmic time algorithm able to color a graph with less than O(Δ^{2}) colors, and the work by Gavoille et al. (2009) proposing and studying the complexity of two new problems strongly related to the distributed GCP.
1.3 Organization of the paper
The rest of this paper is organized as follows. Section 2 describes the behavior of frogs in nature, which has inspired our algorithm. Moreover, existing models are outlined. In Sect. 3 the algorithm is introduced. An extensive experimental evaluation of the proposed algorithm is presented in Sect. 4. Finally, Sect. 5 is dedicated to conclusions and the outline of future work.
2 Modeling the calling behavior of Japanese tree frogs
Different studies (see, for example, Wells 1977) have shown that male Japanese tree frogs use their call to attract females. Apparently, females of this family of frogs can recognize the source of the call to determine the current location of the corresponding male. A problem arises when two males are too close in space and communicate at the same time. In this case, females are not able to detect where the calls came from, unless the males desynchronize their sounds in time. The way males manage to desynchronize is an example of self-organization in nature.
Mutazono et al. (2009) compared the results of their system to another mechanism for coupled oscillator desynchronization proposed in Degesys and Nagpal (2008). Note that the mechanism from Degesys and Nagpal (2008) is not based on the calling behavior of Japanese tree frogs. The main difference to frog-inspired systems is the fact that the phase change of a node is made on the basis of only two other nodes. The phase values allow to order all the nodes sequentially from small to large phase values. The nodes whose phase values are used to change the phase value of a node are determined as the predecessor and the successor in this (cyclic) sequence. As shown in Mutazono et al. (2009), both systems achieve similar results although no extensive experimentation is made on a broad-enough set of network topologies: mostly random geometric graphs and hand-made instances with at most eight nodes were used.
Another extension of the system by Aihara et al. (2008) was introduced in Lee and Lister (2008). The changes concern the use of different weights for the phase shift function and the introduction of a so-called frustration parameter which reduces the coupling between each pair of nodes. The authors show that their system is able to obtain better solutions than the original model for many different topologies as, for example, k-partite graphs, grids or platonic solids. Moreover, the authors observe that the difficulty of desynchronizing a given number of oscillators is mostly determined by the topology which is obtained by their positions and their connections. In comparison, the number of oscillators does not seem to have a high impact on the difficulty.
3 FrogSim: an algorithm for distributed graph coloring
Although the FrogSim algorithm will be described in the context of its application in static sensor networks, it can be applied with very few modifications in any other communication network. The operation of the algorithm requires an a priori organization of the sensor network in form of a rooted tree. The root node of this tree (henceforth also called the master node) will have some additional functionality in comparison to the rest of the sensor nodes. Once the tree is available, the master node runs a protocol to calculate the height of the tree, that is, the distance in hops (communication rounds) from the master node to the farthest node in the network. In order to produce a tree with a low height, the distributed method for generating spanning trees with minimum diameter as presented in Bui et al. (2004) may be used. Next, the master node triggers the start of the main algorithm (see below) by means of a broadcast message. In this message, the height of the tree is communicated to the rest of the sensor nodes as well. This overlay tree will serve two purposes: first, it will be used to communicate and store the best coloring found by the algorithm. Second, it will be used to communicate the state of the algorithm’s convergence to the master node.
The simulation of the FrogSim algorithm is composed of two distinct phases. The first phase (called phase I, see lines 2–4 of Algorithm 1) makes use of the model for the desynchronization of frog calling as introduced by Aihara et al. (2008), with only a few modifications. The main difference to other distributed graph coloring algorithms inspired by this model is as follows. The θ_{i}-values are used for determining the order in which the nodes are allowed to choose colors, whereas in previous algorithms these values were directly associated to specific colors. The second phase (called phase II, see lines 6–14 of Algorithm 1), which is initiated after phase I has finished, serves to improve the current coloring by means of a refinement technique, similar to distributed local search.
Phases I and II of FrogSim will be described in detail in Sects. 3.1 and 3.2. Moreover, the way in which the initially computed tree structure will be used to communicate and store the best coloring found by the algorithm and to detect convergence in phase I is presented in Sect. 3.3.
3.1 Phase I of FrogSim
3.2 Phase II of FrogSim
Phase II of FrogSim (which is initiated after phase I has been stopped) consists of the execution of lines 6–14 of Algorithm 1. As mentioned before, this phase is used for the distributed refinement of the current coloring, similar to a distributed local search. Note that in this phase the θ-values of the nodes are not changed anymore. Within the scope of phase II, each node i additionally maintains a so-called power parameter p_{i}. This parameter is initialized in the first communication round of phase II with a positive random integer for the nodes i with c_{i}=1, and 0 for the rest of the nodes. The values of these power parameters are used to resolve conflicts that may arise during the color changes executed in phase II. In particular, in case two neighboring nodes—that is, two nodes that can communicate—have chosen the same color, the one with the higher power value is allowed to keep it. Our distributed local search starts—at the same communication round—in all nodes with a power value which is higher than the one of their neighbors. In addition to (potentially) requiring neighbors to change color, nodes also pass their power value to their neighbors. This leads to the fact that, eventually, the node which initially had the highest power value imposes itself over all the other nodes of the network. The θ-values are again used to determine the moment in time at which a sensor node executes its sensor event. At the end of this section, a graphic example illustrates the working of phase II.
3.3 Use of the overlay tree structure
As mentioned before, the overlay tree structure which is produced before the start of the main algorithm is used for two different purposes. First, for the identification of the best coloring found by the algorithm, and second, to detect the convergence of the θ-values in phase I of the algorithm.
3.3.1 Identifying and storing the best coloring
Therefore, we found it convenient to provide the system with a mechanism—originally proposed by Zivan (2008)—to identify and store the best coloring that was found. The key characteristic of the initially produced overlay tree is its height, henceforth referred to by h. It determines the maximum number of communication rounds necessary for the root node to broadcast a message to all other nodes. The mechanism for storing the best coloring requires each node to store the color it uses in the best-found coloring in an additional variable. The main goal of the system is to efficiently alert the nodes about when and how to update this variable. The algorithm also requires each node to store the history of colors from the last 2h communication rounds. At each communication round, each node must communicate the maximum color used in a certain communication round by itself and its children (with respect to the tree) to its parent in the tree. Messages for this type of information passing only contain two integers: one for the maximum color used and another one to identify the corresponding communication round. In fact, these values can easily be added to the body of the coloring event messages used by FrogSim. In other words, no additional messages are required.
Note that, for example, in the first communication round only the leaves of the tree will report their colors to their parents. This is because the leaves are the only nodes without children. In the second communication round, the parents of the leaves will be able to use this information in addition to their own color information stored for the previous communication round and report the aggregated data to their respective parents. Given the height h of the tree, it takes h communication rounds until all the information regarding a specific communication round has reached the root node. Moreover, the number of colors used in a particular communication round is the maximum color identifier that reaches the root node via one of its children. In case this maximum color is lower than the number of colors used in the currently best-found coloring, the root node broadcasts a message with the corresponding communication round identifier in which this coloring was obtained. In order for this information to reach all the nodes of the network, another h communication rounds are necessary. This is why all nodes must store their colors from the last 2h communication rounds.
3.3.2 Detection of convergence in phase I
Concerning phase II, after tuning by hand we decided for a communication round limit of 20 for all experiments.
4 Experimental results
We coded our algorithm by means of discrete event simulation, implemented from scratch in C++. For the experimental evaluation we chose a large set of different graph topologies: random geometric graphs of different densities, grid graphs of different sizes, and the graphs used for the DIMACS challenge (Center for Discrete Mathematics and Theoretical Computer Science 2006).^{2} Note that an edge connecting two nodes indicates that both nodes are able to communicate directly with each other via their radio antennas.
For the purpose of comparison we re-implemented one of the currently best algorithms from the literature. This algorithm was presented by Finocchi et al. (2005). For simplicity, this algorithm will henceforth be referred to as Finocchi. Unfortunately, the description of this algorithm in the original article contains some ambiguities, which required us to make some decisions regarding certain aspects in the context of the re-implementation. Fortunately, our own implementation of the Finocchi algorithm provides generally better results than the ones reported in Finocchi et al. (2005). This can be verified by comparing the results of the original implementation with the results of our re-implementation for the graph topologies that are used both in Finocchi et al. (2005) and in the present paper.
In the following we present the results of three algorithms: (1) Finocchi (Finocchi et al. 2005), (2) FrogSim^{⊖}, which is the FrogSim algorithm without phase II, and (3) FrogSim, which is the complete FrogSim algorithm. The study of the results of FrogSim^{⊖} is worthwhile, because it reflects the power of the frog-based model without any additional improvements of the refinement phase. We apply each of these three stochastic algorithms 100 times to each graph topology and report the best coloring found in all 100 runs, as well as the average quality of the best colorings found per run and the number of rounds necessary to reach these solutions. However, it is important to note that algorithms such as Finocchi and FrogSim—when used in sensor networks—are generally applied continuously in a lower-level layer of the network. Therefore, the number of communication rounds necessary to reach the best solution is not very important. Instead our algorithm creates a valid coloring in the very first communication round and continually tries to improve the current solution.
As mentioned above, for each of the three studied algorithms we provide—for each problem instance—the average number of communication rounds used by the respective algorithm. This is standard in the context of distributed algorithms. In contrast, we do not provide the average computation times. However, the interested reader may note that the maximum computation time needed by our algorithm for any of the considered problem instances is 2.08 seconds (on a computer equipped with an AMD64X2 4400 processor and 4 Gigabyte of memory). Moreover, for most of the tackled problem instances the computation time required by FrogSim is only a fraction of a second.
4.1 Resource consumption
The time complexity of the FrogSim algorithm depends on the number of messages received at each node. Extremely large message queues can be avoided by a reasonable deployment of the network. This is usually done by topology control techniques (Santi 2005a, 2005b). Concerning single nodes, the sensor event of each node i requires O(|M_{i}|) time.
The FrogSim algorithm uses rather small messages of constant size. They are all composed of five data fields with a total size of O(log|V|), which is the number of bits necessary to represent the largest integer identifier of the |V| nodes in the network. Two of these data fields are needed by the main FrogSim algorithm. Two others are required for storing the best solution, and one final data field is needed for the detection of convergence in phase I. Nodes also store additional information such as the color used in the best coloring found so far, the node’s father and its children concerning the overlay tree structure, etc. Finally, the method for transmitting aggregate data to the master through the overlay tree is the primary memory consumer within the sensor nodes. The amount of memory required by this mechanism depends on the height of the overlay tree. More precisely, nodes must remember the color chosen during the last 2h rounds to be able to restore the color chosen at any given round after receiving a notification of the master (see Sect. 3.3). More formally, the mechanism requires O(h) space.
4.2 Results for random geometric graphs
Random geometric graphs are popular models for sensor networks. Therefore, they are frequently used for the evaluation of algorithms developed for such networks. They are generated by randomly distributing a set of n nodes in the unit square, [0,1]^{2}. Two vertices u and v are connected by an edge, if and only if d(u,v)≤r, where d(. ,.) is the Euclidean distance and r>0 is a threshold.^{3} More specifically, the three algorithms were applied to 40 random geometric graphs with n∈{20,50,100,200} and r=0.05.
Results for random geometric graphs. The first column indicates the instance number. The group of columns labeled “Properties” provides for each problem instance the number of nodes |V|, the maximum degree Δ, the chromatic number χ, and the quality of the coloring (column “cent.”) obtained with the centralized algorithm by Malaguti et al. (2008). For each of the three algorithms Finocchi, FrogSim^{⊖} and FrogSim three measures are provided: (1) the value of the best solution found (column “colors”), (2) the average solution quality (column “avg.”), and (3) the average number of communication rounds that were used (column “rounds”). In the case of FrogSim^{⊖} and FrogSim, the average number of communication rounds at which the algorithms converged is additionally provided (column “conv.”). The best algorithm for each instance is indicated in bold face. The best algorithm is hereby defined as the one that generates the best solution. Ties are broken by the average performance
Instance number | Properties | Finocchi | FrogSim^{⊖} | FrogSim | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|V| | Δ | χ | Cent. | Colors | Avg. | Rounds | Colors | Avg. | Rounds | Conv. | Colors | Avg. | Rounds | Conv. | |
1 | 20 | 2 | 3 | 3 | 3 | 3.00 | 3.00 | 3 | 3.00 | 5.00 | 8.57 | 3 | 3.00 | 5.00 | 32.57 |
2 | 20 | 2 | 3 | 3 | 3 | 3.00 | 3.00 | 3 | 3.00 | 5.00 | 8.49 | 3 | 3.00 | 5.00 | 32.49 |
3 | 20 | 2 | 2 | 2 | 2 | 2.25 | 2.25 | 2 | 2.01 | 5.67 | 7.71 | 2 | 2.00 | 5.77 | 31.71 |
4 | 20 | 3 | 3 | 3 | 3 | 3.00 | 3.00 | 3 | 3.00 | 5.00 | 9.01 | 3 | 3.00 | 5.00 | 33.01 |
5 | 20 | 3 | 3 | 3 | 3 | 3.00 | 3.00 | 3 | 3.00 | 7.00 | 13.74 | 3 | 3.00 | 7.00 | 39.74 |
6 | 20 | 1 | 2 | 2 | 2 | 2.00 | 2.00 | 2 | 2.00 | 5.00 | 6.30 | 2 | 2.00 | 5.00 | 30.30 |
7 | 20 | 2 | 3 | 3 | 3 | 3.00 | 3.00 | 3 | 3.00 | 5.00 | 8.90 | 3 | 3.00 | 5.00 | 32.90 |
8 | 20 | 2 | 3 | 3 | 3 | 3.00 | 3.00 | 3 | 3.00 | 5.00 | 8.57 | 3 | 3.00 | 5.00 | 32.57 |
9 | 20 | 2 | 2 | 2 | 2 | 2.00 | 2.00 | 2 | 2.00 | 5.00 | 6.30 | 2 | 2.00 | 5.00 | 30.30 |
10 | 20 | 1 | 2 | 2 | 2 | 2.00 | 2.00 | 2 | 2.00 | 5.00 | 6.00 | 2 | 2.00 | 5.00 | 30.00 |
11 | 50 | 6 | ≥4 | 6 | 6 | 6.00 | 6.00 | 6 | 6.00 | 5.00 | 10.24 | 6 | 6.00 | 5.00 | 34.24 |
12 | 50 | 3 | 3 | 3 | 3 | 3.13 | 3.13 | 3 | 3.00 | 7.41 | 13.19 | 3 | 3.00 | 7.41 | 39.19 |
13 | 50 | 4 | 4 | 4 | 4 | 4.00 | 4.00 | 4 | 4.00 | 7.00 | 12.15 | 4 | 4.00 | 7.00 | 38.15 |
14 | 50 | 4 | 3 | 3 | 3 | 3.43 | 3.43 | 3 | 3.12 | 5.88 | 11.29 | 3 | 3.03 | 6.89 | 35.29 |
15 | 50 | 4 | 3 | 3 | 3 | 3.46 | 3.46 | 3 | 3.09 | 5.69 | 10.18 | 3 | 3.04 | 6.28 | 34.18 |
16 | 50 | 4 | ≥3 | 4 | 4 | 4.00 | 4.00 | 4 | 4.00 | 5.00 | 10.26 | 4 | 4.00 | 5.00 | 34.26 |
17 | 50 | 6 | 4 | 4 | 4 | 4.63 | 4.63 | 4 | 4.28 | 7.95 | 13.87 | 4 | 4.02 | 11.99 | 39.87 |
18 | 50 | 4 | 3 | 3 | 3 | 3.37 | 3.37 | 3 | 3.07 | 5.89 | 9.61 | 3 | 3.00 | 6.67 | 33.61 |
19 | 50 | 3 | 3 | 3 | 3 | 3.00 | 3.00 | 3 | 3.00 | 5.00 | 9.01 | 3 | 3.00 | 5.00 | 33.01 |
20 | 50 | 6 | 5 | 5 | 5 | 5.14 | 5.14 | 5 | 5.05 | 5.31 | 14.06 | 5 | 5.02 | 5.75 | 38.06 |
21 | 100 | 8 | ≥4 | 5 | 5 | 5.74 | 5.74 | 5 | 5.47 | 10.01 | 26.39 | 5 | 5.28 | 15.27 | 54.39 |
22 | 100 | 7 | 4 | 4 | 4 | 4.74 | 4.74 | 4 | 4.52 | 10.41 | 29.15 | 4 | 4.29 | 17.21 | 57.15 |
23 | 100 | 7 | ≥5 | 6 | 6 | 6.00 | 6.00 | 6 | 6.00 | 13.00 | 27.95 | 6 | 6.00 | 13.00 | 59.95 |
24 | 100 | 9 | ≥4 | 5 | 5 | 5.73 | 5.73 | 5 | 5.59 | 26.06 | 56.26 | 5 | 5.37 | 38.61 | 100.26 |
25 | 100 | 7 | 4 | 4 | 4 | 4.92 | 4.92 | 4 | 4.73 | 6.29 | 24.09 | 4 | 4.33 | 17.08 | 48.09 |
26 | 100 | 6 | ≥5 | 6 | 6 | 6.00 | 6.00 | 6 | 6.00 | 35.00 | 62.90 | 6 | 6.00 | 35.00 | 116.90 |
27 | 100 | 6 | 4 | 4 | 4 | 4.81 | 4.81 | 4 | 4.53 | 12.15 | 30.66 | 4 | 4.10 | 26.51 | 60.66 |
28 | 100 | 6 | 4 | 4 | 4 | 4.64 | 4.64 | 4 | 4.17 | 10.46 | 22.78 | 4 | 4.00 | 14.69 | 50.78 |
29 | 100 | 7 | 6 | 6 | 6 | 6.12 | 6.12 | 6 | 6.00 | 21.19 | 44.14 | 6 | 6.00 | 21.19 | 84.14 |
30 | 100 | 8 | 5 | 5 | 5 | 5.75 | 5.75 | 5 | 5.50 | 5.87 | 24.42 | 5 | 5.38 | 9.25 | 48.42 |
31 | 200 | 13 | 8 | 8 | 8 | 8.75 | 7.79 | 8 | 8.62 | 35.49 | 63.74 | 8 | 8.56 | 39.64 | 115.74 |
32 | 200 | 12 | ≥6 | 8 | 8 | 8.27 | 7.30 | 8 | 8.01 | 21.98 | 55.11 | 8 | 8.01 | 21.98 | 95.11 |
33 | 200 | 12 | ≥6 | 7 | 7 | 8.03 | 7.30 | 7 | 7.69 | 35.95 | 74.30 | 7 | 7.52 | 47.89 | 126.30 |
34 | 200 | 12 | ≥7 | 8 | 8 | 8.59 | 7.75 | 8 | 8.22 | 32.64 | 64.59 | 8 | 8.10 | 40.84 | 114.59 |
35 | 200 | 17 | ≥7 | 8 | 9 | 9.55 | 8.55 | 8 | 9.12 | 32.84 | 65.27 | 8 | 8.94 | 43.63 | 115.27 |
36 | 200 | 12 | ≥7 | 8 | 8 | 8.21 | 7.33 | 8 | 8.00 | 31.61 | 72.99 | 8 | 8.00 | 31.61 | 122.99 |
37 | 200 | 12 | 6 | 6 | 6 | 7.25 | 6.67 | 6 | 7.04 | 33.06 | 71.96 | 6 | 6.95 | 40.40 | 121.96 |
38 | 200 | 11 | 7 | 7 | 7 | 7.91 | 7.13 | 7 | 7.81 | 32.59 | 67.05 | 7 | 7.70 | 41.40 | 117.05 |
39 | 200 | 11 | 7 | 7 | 7 | 7.81 | 7.32 | 7 | 7.38 | 29.15 | 66.15 | 7 | 7.21 | 41.00 | 112.15 |
40 | 200 | 13 | ≥6 | 8 | 8 | 8.25 | 7.44 | 8 | 8.02 | 32.16 | 67.89 | 8 | 8.01 | 32.92 | 117.89 |
Average | 4.73 | 5.09 | 4.89 | 4.70 | 4.93 | 14.52 | 30.38 | 4.70 | 4.84 | 17.72 | 63.13 | ||||
# times best | 0 | 0 | 21 | ||||||||||||
# times all equal | 15 | 15 | 15 | ||||||||||||
# times worst | 25 | 0 | 0 |
As expected, the results show that the smaller the size of the graph, the easier it is to find good colorings. The algorithms obtain equivalent results for 15 out of 40 instances. Although the best coloring found by Finocchi is worse than the best colorings found by the FrogSim algorithms just in one single case, it performs worse in terms of average solution quality in 25 cases. In addition, note that FrogSim^{⊖} does not obtain the worst result for any instance. FrogSim improves the results of Finocchi and FrogSim^{⊖} especially for what concerns the larger instances. It turns out to be the sole winner for 21 instances. It is interesting to note that in those cases where FrogSim is better than FrogSim^{⊖} this is due to the average solution quality. In this sense it can be said that in the context of random geometric graphs the use of phase II makes the FrogSim algorithm more robust. It is also important to note that the best colorings obtained are—for almost all instances—better than Δ+1 colors.
4.3 Results for DIMACS graphs
One of the most popular sets of instances in the context of graph coloring is the one introduced for the second DIMACS challenge (Center for Discrete Mathematics and Theoretical Computer Science 2006). This challenge had among its objectives to establish the state-of-the-art techniques for centralized graph coloring. These graphs are generally larger and more complex than, for example, random geometric graphs. The instances originate from very different contexts, ranging from industrial problems to hand-crafted cases that were created to show the ineffectiveness of certain algorithms. This set of instances is often used as a benchmark to study the quality of new algorithms, also in the context of distributed graph coloring (see, for example, Finocchi et al. 2005; Lee 2008; Malaguti and Toth 2010; Lü and Hao 2010).
Results for the first set of instances from the DIMACS challenge. The first column indicates the instance name. The group of columns labeled “Properties” provides for each problem instance the number of nodes |V|, the maximum degree Δ, the chromatic number χ, and the quality of the coloring (column “cent.”) obtained with the centralized algorithm by Malaguti et al. (2008). For each of the three algorithms Finocchi, FrogSim^{⊖} and FrogSim three measures are provided: (1) the value of the best solution found (column “colors”), (2) the average solution quality (column “avg.”), and (3) the average number of communication rounds that were used (column “rounds”). In the case of FrogSim^{⊖} and FrogSim, the average number of communication rounds at which the algorithms converged is additionally provided (column “conv.”). The best algorithm for each instance is indicated in bold face. The best algorithm is hereby defined as the one that generates the best solution. Ties are broken by the average performance
Instance | Properties | Finocchi | FrogSim^{⊖} | FrogSim | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|V| | Δ | χ | Cent. | Colors | Avg. | Rounds | Colors | Avg. | Rounds | Conv. | Colors | Avg. | Rounds | Conv. | |
DSJC1000.1.col | 1000 | 127 | ≥5 | 20 | 30 | 31.79 | 20.04 | 29 | 29.93 | 20.18 | 40.15 | 29 | 29.82 | 23.36 | 64.15 |
DSJC1000.5.col | 1000 | 551 | ≥13 | 83 | 125 | 128.55 | 75.22 | 118 | 120.52 | 45.75 | 69.74 | 118 | 120.50 | 46.16 | 93.74 |
DSJC1000.9.col | 1000 | 924 | ≥51 | 224 | 314 | 322.59 | 231.52 | 300 | 308.28 | 42.66 | 56.16 | 300 | 308.27 | 43.12 | 80.16 |
DSJC125.1.col | 125 | 23 | 5 | 5 | 7 | 8.12 | 6.80 | 7 | 7.77 | 8.02 | 17.33 | 7 | 7.64 | 10.14 | 43.33 |
DSJC125.5.col | 125 | 75 | 17 | 17 | 24 | 25.60 | 18.79 | 22 | 24.06 | 12.00 | 25.91 | 22 | 23.88 | 15.66 | 49.91 |
DSJC125.9.col | 125 | 120 | 44 | 44 | 53 | 56.11 | 45.02 | 51 | 53.88 | 12.63 | 23.57 | 51 | 53.67 | 15.64 | 47.57 |
DSJC250.1.col | 250 | 38 | ≥6 | 8 | 12 | 12.99 | 9.99 | 12 | 12.31 | 10.85 | 23.20 | 11 | 12.13 | 14.56 | 49.20 |
DSJC250.5.col | 250 | 147 | ≥20 | 28 | 41 | 42.85 | 29.27 | 37 | 40.29 | 19.68 | 37.63 | 37 | 40.13 | 23.46 | 61.63 |
DSJC250.9.col | 250 | 234 | ≥71 | 72 | 93 | 98.06 | 75.56 | 89 | 93.60 | 21.66 | 34.43 | 89 | 93.47 | 23.12 | 58.43 |
DSJC500.1.col | 500 | 68 | ≥5 | 12 | 18 | 19.86 | 13.87 | 18 | 18.65 | 14.87 | 30.96 | 18 | 18.46 | 19.96 | 56.96 |
DSJC500.5.col | 500 | 286 | ≥16 | 48 | 70 | 73.52 | 46.75 | 67 | 69.27 | 30.06 | 52.17 | 67 | 69.18 | 32.48 | 76.17 |
DSJC500.9.col | 500 | 471 | ≥123 | 126 | 173 | 178.28 | 132.64 | 165 | 169.73 | 31.11 | 47.74 | 165 | 169.68 | 32.03 | 71.74 |
DSJR500.1.col | 500 | 25 | 12 | 12 | 13 | 14.55 | 12.55 | 13 | 14.19 | 34.98 | 50.59 | 13 | 14.09 | 40.43 | 102.59 |
DSJR500.1c.col | 500 | 497 | 85 | 85 | 106 | 114.05 | 65.32 | 99 | 104.40 | 19.96 | 30.94 | 99 | 104.26 | 21.27 | 54.94 |
DSJR500.5.col | 500 | 388 | 122 | 122 | 145 | 149.42 | 112.32 | 141 | 146.37 | 5.00 | 89.33 | 141 | 146.35 | 6.63 | 113.33 |
flat1000-50-0.col | 1000 | 520 | 50 | 50 | 123 | 125.87 | 75.36 | 116 | 118.47 | 47.38 | 68.35 | 116 | 118.47 | 47.38 | 92.35 |
flat1000-60-0.col | 1000 | 524 | 60 | 60 | 123 | 126.13 | 75.07 | 116 | 118.75 | 47.05 | 68.93 | 116 | 118.75 | 47.05 | 92.93 |
flat1000-76-0.col | 1000 | 532 | 76 | 82 | 123 | 126.86 | 75.12 | 117 | 119.26 | 47.68 | 67.81 | 117 | 119.26 | 47.68 | 91.81 |
flat300-20-0.col | 300 | 160 | 20 | 20 | 45 | 46.70 | 31.64 | 42 | 43.88 | 22.20 | 40.14 | 42 | 43.79 | 24.09 | 64.14 |
flat300-26-0.col | 300 | 158 | 26 | 26 | 45 | 47.48 | 32.50 | 42 | 44.73 | 23.79 | 40.19 | 42 | 44.61 | 26.64 | 64.19 |
flat300-28-0.col | 300 | 162 | 28 | 28 | 45 | 47.26 | 32.11 | 43 | 44.55 | 22.37 | 39.64 | 43 | 44.50 | 23.59 | 63.64 |
fpsol2.i.1.col | 496 | 252 | 65 | 65 | 65 | 65.72 | 42.50 | 65 | 65.00 | 5.00 | 19.77 | 65 | 65.00 | 5.00 | 43.77 |
fpsol2.i.2.col | 451 | 346 | 30 | 30 | 35 | 38.30 | 7.16 | 30 | 30.31 | 6.68 | 17.59 | 30 | 30.16 | 9.27 | 41.59 |
fpsol2.i.3.col | 425 | 346 | 30 | 30 | 34 | 38.18 | 7.10 | 30 | 30.29 | 6.06 | 17.56 | 30 | 30.08 | 9.69 | 41.56 |
inithx.i.1.col | 864 | 502 | 54 | 54 | 54 | 60.00 | 16.45 | 54 | 54.00 | 5.12 | 22.80 | 54 | 54.00 | 5.12 | 46.80 |
inithx.i.2.col | 645 | 541 | 31 | 31 | 38 | 50.24 | 5.51 | 31 | 31.02 | 5.85 | 18.33 | 31 | 31.01 | 5.99 | 42.33 |
inithx.i.3.col | 621 | 542 | 31 | 31 | 39 | 50.25 | 5.50 | 31 | 31.00 | 5.34 | 18.89 | 31 | 31.00 | 5.34 | 42.89 |
le450-15a.col | 450 | 99 | 15 | 15 | 20 | 21.98 | 13.96 | 20 | 21.52 | 8.46 | 22.09 | 20 | 20.85 | 20.36 | 48.09 |
le450-15b.col | 450 | 94 | 15 | 15 | 21 | 21.91 | 14.33 | 20 | 21.36 | 8.22 | 22.23 | 19 | 20.78 | 17.90 | 48.23 |
le450-15c.col | 450 | 139 | 15 | 15 | 29 | 31.52 | 19.34 | 28 | 30.00 | 10.19 | 29.45 | 28 | 29.37 | 23.39 | 53.45 |
le450-15d.col | 450 | 138 | 15 | 15 | 30 | 31.52 | 19.47 | 29 | 30.18 | 9.99 | 28.69 | 28 | 29.58 | 21.63 | 52.69 |
le450-25a.col | 450 | 128 | 25 | 25 | 27 | 28.57 | 18.37 | 27 | 28.10 | 7.51 | 20.50 | 26 | 27.44 | 18.14 | 46.50 |
le450-25b.col | 450 | 111 | 25 | 25 | 26 | 28.04 | 18.57 | 26 | 27.82 | 7.72 | 20.54 | 26 | 27.07 | 18.62 | 46.54 |
le450-25c.col | 450 | 179 | 25 | 25 | 35 | 37.07 | 22.19 | 34 | 35.81 | 6.79 | 25.87 | 34 | 35.00 | 21.34 | 49.87 |
le450-25d.col | 450 | 157 | 25 | 25 | 35 | 37.11 | 23.11 | 34 | 35.92 | 6.82 | 26.00 | 33 | 34.84 | 24.36 | 50.00 |
le450-5a.col | 450 | 42 | 5 | 5 | 12 | 13.26 | 9.79 | 11 | 12.46 | 12.80 | 24.05 | 11 | 12.31 | 16.27 | 50.05 |
le450-5b.col | 450 | 42 | 5 | 5 | 12 | 13.29 | 9.73 | 12 | 12.42 | 11.56 | 23.78 | 12 | 12.26 | 15.43 | 49.78 |
le450-5c.col | 450 | 66 | 5 | 5 | 15 | 16.88 | 11.16 | 9 | 12.13 | 26.85 | 42.78 | 9 | 11.08 | 40.33 | 68.78 |
le450-5d.col | 450 | 68 | 5 | 5 | 15 | 16.82 | 11.34 | 9 | 11.86 | 29.76 | 45.29 | 8 | 10.86 | 41.82 | 71.29 |
Average | 58.21 | 61.47 | 38.28 | 54.97 | 57.03 | 18.48 | 35.93 | 54.82 | 56.76 | 23.19 | 61.21 | ||||
# times best | 0 | 0 | 33 | ||||||||||||
# times all equal | 0 | 0 | 0 | ||||||||||||
# times worst | 39 | 0 | 0 |
Results for the second set of instances from the DIMACS challenge. The first column indicates the instance name. The group of columns labeled “Properties” provides for each problem instance the number of nodes |V|, the maximum degree Δ, the chromatic number χ, and the quality of the coloring (column “cent.”) obtained with the centralized algorithm by Malaguti et al. (2008). For each of the three algorithms Finocchi, FrogSim^{⊖} and FrogSim three measures are provided: (1) the value of the best solution found (column “colors”), (2) the average solution quality (column “avg.”), and (3) the average number of communication rounds that were used (column “rounds”). In the case of FrogSim^{⊖} and FrogSim, the average number of communication rounds at which the algorithms converged is additionally provided (column “conv.”). The best algorithm for each instance is indicated in bold face. The best algorithm is hereby defined as the one that generates the best solution. Ties are broken by the average performance
Instance | Properties | Finocchi | FrogSim^{⊖} | FrogSim | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|V| | Δ | χ | Cent. | Colors | Avg. | Rounds | Colors | Avg. | Rounds | Conv. | Colors | Avg. | Rounds | Conv. | |
anna.col | 138 | 71 | 11 | 11 | 11 | 11.47 | 6.40 | 11 | 11.12 | 9.35 | 32.82 | 11 | 11.01 | 11.72 | 60.82 |
david.col | 87 | 82 | 11 | 11 | 11 | 12.25 | 6.84 | 11 | 11.57 | 9.62 | 35.91 | 11 | 11.18 | 23.08 | 59.91 |
games120.col | 120 | 13 | 9 | 9 | 9 | 9.03 | 8.03 | 9 | 9.00 | 11.24 | 24.42 | 9 | 9.00 | 11.24 | 54.42 |
homer.col | 561 | 99 | 13 | ? | 13 | 14.51 | 7.64 | 13 | 13.82 | 12.47 | 39.05 | 13 | 13.21 | 31.83 | 69.05 |
huck.col | 74 | 53 | 11 | 11 | 11 | 11.00 | 7.72 | 11 | 11.00 | 5.00 | 31.53 | 11 | 11.00 | 5.00 | 55.53 |
jean.col | 80 | 36 | 10 | 10 | 10 | 10.45 | 8.36 | 10 | 10.11 | 7.55 | 27.18 | 10 | 10.03 | 9.36 | 53.18 |
miles1000.col | 128 | 86 | 42 | 42 | 43 | 45.06 | 37.42 | 43 | 44.57 | 9.44 | 25.33 | 42 | 44.09 | 17.84 | 51.33 |
miles1500.col | 128 | 106 | 73 | 73 | 73 | 74.76 | 64.80 | 73 | 73.97 | 6.28 | 23.52 | 73 | 73.64 | 12.45 | 47.52 |
miles250.col | 128 | 16 | 8 | 8 | 8 | 9.44 | 8.44 | 8 | 8.94 | 24.46 | 46.12 | 8 | 8.74 | 34.46 | 88.12 |
miles500.col | 128 | 38 | 20 | 20 | 21 | 22.33 | 19.34 | 20 | 21.77 | 16.34 | 30.36 | 20 | 21.39 | 25.77 | 64.36 |
miles750.col | 128 | 64 | 31 | 31 | 32 | 34.05 | 28.63 | 32 | 33.54 | 11.83 | 27.10 | 31 | 33.16 | 20.41 | 57.10 |
mulsol.i.1.col | 197 | 121 | 49 | 49 | 49 | 49.48 | 38.79 | 49 | 49.00 | 5.00 | 27.57 | 49 | 49.00 | 5.00 | 51.57 |
mulsol.i.2.col | 188 | 156 | 31 | 31 | 31 | 32.45 | 19.19 | 31 | 31.01 | 6.27 | 22.36 | 31 | 31.00 | 6.49 | 46.36 |
mulsol.i.3.col | 184 | 157 | 31 | 31 | 31 | 32.52 | 19.24 | 31 | 31.00 | 5.91 | 21.75 | 31 | 31.00 | 5.91 | 45.75 |
mulsol.i.4.col | 185 | 158 | 31 | 31 | 31 | 32.61 | 19.29 | 31 | 31.00 | 5.90 | 20.53 | 31 | 31.00 | 5.90 | 44.53 |
mulsol.i.5.col | 186 | 159 | 31 | 31 | 31 | 32.38 | 19.21 | 31 | 31.00 | 5.05 | 22.04 | 31 | 31.00 | 5.05 | 46.04 |
myciel2.col | 5 | 2 | 3 | 3 | 3 | 3.00 | 3.00 | 3 | 3.00 | 5.00 | 9.48 | 3 | 3.00 | 5.00 | 33.48 |
myciel3.col | 11 | 5 | 4 | 4 | 4 | 4.03 | 4.03 | 4 | 4.00 | 5.04 | 10.22 | 4 | 4.00 | 5.04 | 34.22 |
myciel4.col | 23 | 11 | 5 | 5 | 5 | 5.09 | 4.32 | 5 | 5.00 | 5.13 | 12.18 | 5 | 5.00 | 5.13 | 36.18 |
myciel5.col | 47 | 23 | 6 | 6 | 6 | 6.28 | 4.71 | 6 | 6.00 | 5.30 | 13.67 | 6 | 6.00 | 5.30 | 37.67 |
myciel6.col | 95 | 47 | 7 | 7 | 7 | 8.01 | 4.48 | 7 | 7.05 | 5.70 | 17.42 | 7 | 7.01 | 6.41 | 41.42 |
myciel7.col | 191 | 95 | 8 | 8 | 10 | 11.60 | 4.08 | 8 | 8.08 | 7.20 | 22.54 | 8 | 8.01 | 8.66 | 46.54 |
queen10-10.col | 100 | 35 | 11 | 11 | 14 | 15.36 | 12.36 | 14 | 14.79 | 7.14 | 16.91 | 14 | 14.64 | 9.67 | 40.91 |
queen11-11.col | 121 | 40 | 11 | 12 | 15 | 16.73 | 13.61 | 15 | 16.08 | 8.82 | 17.16 | 15 | 16.00 | 9.97 | 41.16 |
queen12-12.col | 144 | 43 | 12 | 13 | 17 | 18.09 | 14.12 | 16 | 17.43 | 8.40 | 17.29 | 16 | 17.28 | 11.03 | 41.29 |
queen13-13.col | 169 | 48 | 13 | 14 | 18 | 19.43 | 15.43 | 18 | 18.78 | 8.51 | 17.65 | 18 | 18.70 | 9.72 | 41.65 |
queen14-14.col | 196 | 51 | 14 | 15 | 20 | 20.83 | 16.27 | 19 | 20.08 | 8.73 | 18.12 | 19 | 19.94 | 10.83 | 42.12 |
queen15-15.col | 225 | 56 | 15 | 16 | 21 | 21.96 | 16.96 | 20 | 21.45 | 8.48 | 18.53 | 20 | 21.23 | 12.30 | 42.53 |
queen16-16.col | 256 | 59 | 16 | 17 | 22 | 23.33 | 18.33 | 21 | 22.72 | 8.77 | 18.82 | 21 | 22.57 | 11.51 | 42.82 |
queen5-5.col | 25 | 16 | 5 | 5 | 6 | 7.69 | 6.69 | 5 | 6.82 | 6.65 | 12.54 | 5 | 6.62 | 8.37 | 36.54 |
queen6-6.col | 36 | 19 | 7 | 7 | 8 | 9.49 | 8.49 | 8 | 8.95 | 7.27 | 13.64 | 8 | 8.86 | 8.60 | 37.64 |
queen7-7.col | 49 | 24 | 7 | 7 | 10 | 11.10 | 9.10 | 9 | 10.40 | 7.37 | 14.70 | 9 | 10.18 | 10.21 | 38.70 |
queen8-12.col | 96 | 32 | 12 | 12 | 13 | 15.12 | 12.12 | 14 | 14.74 | 7.54 | 16.60 | 14 | 14.61 | 9.77 | 40.60 |
queen8-8.col | 64 | 27 | 9 | 9 | 11 | 12.49 | 10.49 | 11 | 11.92 | 7.51 | 15.73 | 11 | 11.87 | 8.38 | 39.73 |
queen9-9.col | 81 | 32 | 10 | 10 | 13 | 13.88 | 10.93 | 12 | 13.41 | 7.50 | 15.98 | 12 | 13.23 | 10.18 | 39.98 |
school1.col | 385 | 282 | 14 | 14 | 41 | 45.20 | 19.57 | 36 | 38.93 | 23.15 | 44.10 | 36 | 38.66 | 28.79 | 70.10 |
school1-nsh.col | 352 | 232 | 14 | 14 | 37 | 40.19 | 20.19 | 33 | 36.16 | 18.94 | 37.38 | 33 | 35.90 | 24.56 | 63.38 |
zeroin.i.1.col | 211 | 111 | 49 | 49 | 49 | 49.98 | 39.85 | 49 | 49.02 | 5.72 | 23.10 | 49 | 49.01 | 5.91 | 47.10 |
zeroin.i.2.col | 211 | 140 | 30 | 30 | 30 | 31.62 | 18.44 | 30 | 30.16 | 6.11 | 16.27 | 30 | 30.03 | 8.41 | 40.27 |
zeroin.i.3.col | 206 | 140 | 30 | 30 | 30 | 31.56 | 18.53 | 30 | 30.13 | 6.41 | 17.69 | 30 | 30.03 | 8.17 | 41.69 |
Average | 20.63 | 21.90 | 15.64 | 20.18 | 20.94 | 8.70 | 22.38 | 20.13 | 20.80 | 11.84 | 47.83 | ||||
# times best | 1 | 0 | 29 | ||||||||||||
# times all equal | 2 | 2 | 2 | ||||||||||||
# times worst | 37 | 0 | 0 |
First it should be emphasized that both versions of FrogSim achieve the best results for all instances except for instance queen8-12.col (see Table 3), where Finocchi finds a solution with one color less than the solution found by both versions of FrogSim. However, note that the average solution quality obtained by Finocchi is nevertheless worse than the one obtained by the FrogSim algorithms. Moreover, only in two further cases, Finocchi is able to match the results of the FrogSim algorithms. On the other side, for some instances the FrogSim algorithms improve remarkably over Finocchi. Consider, for example, instance DSJC1000.9.col (see Table 3) where the best colorings found by the FrogSim algorithms need 300 colors, while the best coloring found by Finocchi makes use of 314 colors. Other examples of remarkable improvements over Finocchi are the six flat∗ instances from Table 3. Concerning the comparison between FrogSim^{⊖} and FrogSim, we can state that the power of the algorithm can clearly be attributed to the first (frog-inspired) phase. As in the case of random geometric graphs, phase II of FrogSim basically helps to make the algorithm more robust. It should also be emphasized that, in all cases, the FrogSim colorings require a number of colors that is smaller than Δ+1. Finally, for most of the instances of type mulsol.X, myciel.X and zeroin.X, FrogSim generates optimal colorings in each run.
4.4 Results for grid topologies
Results for grid (respectively, torus) topologies. The first column indicates the instance name. The group of columns labeled “Properties” provides for each problem instance the number of nodes |V|, the maximum degree Δ, the chromatic number χ, and the quality of the coloring (column “cent.”) obtained with the centralized algorithm by Malaguti et al. (2008). For each of the three algorithms Finocchi, FrogSim^{⊖} and FrogSim three measures are provided: (1) the value of the best solution found (column “colors”), (2) the average solution quality (column “avg.”), and (3) the average number of communication rounds that were used (column “rounds”). In the case of FrogSim^{⊖} and FrogSim, the average number of communication rounds at which the algorithms converged is additionally provided (column “conv.”). The best algorithm for each instance is indicated in bold face. The best algorithm is hereby defined as the one that generates the best solution. Ties are broken by the average performance
Instance | Properties | Finocchi | FrogSim^{⊖} | FrogSim | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|V| | Δ | χ | Cent. | Colors | Avg. | Rounds | Colors | Avg. | Rounds | Conv. | Colors | Avg. | Rounds | Conv. | |
grid2×1 | 2 | 1 | 2 | 2 | 2 | 2.00 | 2.00 | 2 | 2.00 | 5.00 | 6.00 | 2 | 2.00 | 5.00 | 30.00 |
grid2×2 | 4 | 2 | 2 | 2 | 2 | 2.00 | 2.00 | 2 | 2.00 | 5.00 | 6.38 | 2 | 2.00 | 5.00 | 30.38 |
grid3×1 | 3 | 2 | 2 | 2 | 2 | 2.00 | 2.00 | 2 | 2.00 | 5.00 | 6.35 | 2 | 2.00 | 5.00 | 30.35 |
grid3×2 | 6 | 3 | 2 | 2 | 2 | 2.30 | 2.30 | 2 | 2.06 | 5.48 | 8.66 | 2 | 2.00 | 6.16 | 32.66 |
grid3×3 | 9 | 4 | 2 | 2 | 2 | 2.51 | 2.51 | 2 | 2.09 | 5.77 | 10.01 | 2 | 2.00 | 6.81 | 34.01 |
grid4×1 | 4 | 2 | 2 | 2 | 2 | 2.27 | 2.27 | 2 | 2.00 | 5.68 | 8.24 | 2 | 2.00 | 5.68 | 32.24 |
grid4×2 | 8 | 3 | 2 | 2 | 2 | 2.57 | 2.57 | 2 | 2.10 | 7.88 | 13.22 | 2 | 2.00 | 9.21 | 39.22 |
grid4×3 | 12 | 4 | 2 | 2 | 2 | 2.87 | 2.87 | 2 | 2.22 | 8.62 | 15.16 | 2 | 2.00 | 11.47 | 41.16 |
grid4×4 | 16 | 4 | 2 | 2 | 2 | 3.02 | 3.02 | 2 | 2.49 | 10.62 | 18.11 | 2 | 2.00 | 17.41 | 46.11 |
grid5×1 | 5 | 2 | 2 | 2 | 2 | 2.31 | 2.31 | 2 | 2.03 | 8.19 | 12.97 | 2 | 2.00 | 8.60 | 38.97 |
grid5×2 | 10 | 3 | 2 | 2 | 2 | 2.72 | 2.72 | 2 | 2.09 | 11.00 | 18.84 | 2 | 2.00 | 12.77 | 46.84 |
grid5×3 | 15 | 4 | 2 | 2 | 2 | 3.00 | 3.00 | 2 | 2.29 | 10.86 | 19.28 | 2 | 2.00 | 15.75 | 47.28 |
grid5×4 | 20 | 4 | 2 | 2 | 2 | 3.36 | 3.36 | 2 | 2.60 | 12.98 | 22.29 | 2 | 2.00 | 23.47 | 52.29 |
grid5×5 | 25 | 4 | 2 | 2 | 2 | 3.54 | 3.54 | 2 | 2.90 | 14.84 | 26.34 | 2 | 2.00 | 32.82 | 58.34 |
grid6×1 | 6 | 2 | 2 | 2 | 2 | 2.42 | 2.42 | 2 | 2.01 | 10.69 | 18.22 | 2 | 2.00 | 10.87 | 46.22 |
grid6×2 | 12 | 3 | 2 | 2 | 2 | 2.98 | 2.98 | 2 | 2.19 | 13.47 | 24.30 | 2 | 2.00 | 18.45 | 54.30 |
grid6×3 | 18 | 4 | 2 | 2 | 2 | 3.16 | 3.16 | 2 | 2.43 | 13.59 | 24.37 | 2 | 2.00 | 21.81 | 54.37 |
grid6×4 | 24 | 4 | 2 | 2 | 2 | 3.44 | 3.44 | 2 | 2.68 | 15.94 | 27.46 | 2 | 2.00 | 29.48 | 59.46 |
grid6×5 | 30 | 4 | 2 | 2 | 2 | 3.64 | 3.64 | 2 | 3.02 | 17.38 | 30.01 | 2 | 2.00 | 37.17 | 64.01 |
grid6×6 | 36 | 4 | 2 | 2 | 2 | 3.77 | 3.77 | 2 | 3.19 | 19.68 | 33.51 | 2 | 2.00 | 45.19 | 69.51 |
grid7×1 | 7 | 2 | 2 | 2 | 2 | 2.55 | 2.55 | 2 | 2.03 | 13.43 | 22.78 | 2 | 2.00 | 14.18 | 52.78 |
grid7×2 | 14 | 3 | 2 | 2 | 2 | 3.05 | 3.05 | 2 | 2.28 | 16.38 | 28.55 | 2 | 2.00 | 23.90 | 60.55 |
grid7×3 | 21 | 4 | 2 | 2 | 2 | 3.20 | 3.20 | 2 | 2.52 | 16.02 | 29.12 | 2 | 2.00 | 27.62 | 61.12 |
grid7×4 | 28 | 4 | 2 | 2 | 2 | 3.72 | 3.72 | 2 | 2.95 | 17.50 | 31.58 | 2 | 2.00 | 37.18 | 65.58 |
grid7×5 | 35 | 4 | 2 | 2 | 2 | 3.67 | 3.67 | 2 | 3.10 | 20.05 | 34.15 | 2 | 2.00 | 45.59 | 70.15 |
grid7×6 | 42 | 4 | 2 | 2 | 2 | 3.76 | 3.76 | 2 | 3.29 | 21.91 | 37.38 | 2 | 2.00 | 53.19 | 75.38 |
grid7×7 | 49 | 4 | 2 | 2 | 3 | 3.94 | 3.94 | 2 | 3.48 | 23.29 | 40.53 | 2 | 2.00 | 59.70 | 80.53 |
grid8×1 | 8 | 2 | 2 | 2 | 2 | 2.60 | 2.60 | 2 | 2.01 | 18.56 | 28.69 | 2 | 2.00 | 18.90 | 60.69 |
grid8×2 | 16 | 3 | 2 | 2 | 2 | 3.14 | 3.14 | 2 | 2.26 | 18.31 | 33.71 | 2 | 2.00 | 26.49 | 67.71 |
grid8×3 | 24 | 4 | 2 | 2 | 2 | 3.49 | 3.49 | 2 | 2.59 | 18.39 | 34.61 | 2 | 2.00 | 34.81 | 68.61 |
grid8×4 | 32 | 4 | 2 | 2 | 2 | 3.81 | 3.81 | 2 | 2.97 | 20.44 | 36.57 | 2 | 2.00 | 45.52 | 72.57 |
grid8×5 | 40 | 4 | 2 | 2 | 2 | 3.84 | 3.84 | 2 | 3.21 | 21.89 | 39.73 | 2 | 2.00 | 54.22 | 77.73 |
grid8×6 | 48 | 4 | 2 | 2 | 3 | 3.94 | 3.94 | 2 | 3.34 | 23.98 | 43.01 | 2 | 2.00 | 59.95 | 83.01 |
grid8×7 | 56 | 4 | 2 | 2 | 3 | 3.92 | 3.92 | 2 | 3.51 | 24.65 | 43.71 | 2 | 2.00 | 64.47 | 85.71 |
grid8×8 | 64 | 4 | 2 | 2 | 3 | 4.04 | 4.04 | 2 | 3.65 | 27.15 | 47.46 | 2 | 2.00 | 72.08 | 91.46 |
grid9×1 | 9 | 2 | 2 | 2 | 2 | 2.71 | 2.71 | 2 | 2.01 | 19.98 | 32.72 | 2 | 2.00 | 20.30 | 66.72 |
grid9×2 | 18 | 3 | 2 | 2 | 2 | 3.31 | 3.31 | 2 | 2.35 | 21.25 | 38.81 | 2 | 2.00 | 34.05 | 74.81 |
grid9×3 | 27 | 4 | 2 | 2 | 2 | 3.60 | 3.60 | 2 | 2.65 | 21.47 | 39.42 | 2 | 2.00 | 41.74 | 75.42 |
grid9×4 | 36 | 4 | 2 | 2 | 3 | 3.84 | 3.84 | 2 | 3.09 | 22.96 | 41.58 | 2 | 2.00 | 54.24 | 79.58 |
grid9×5 | 45 | 4 | 2 | 2 | 3 | 3.90 | 3.90 | 2 | 3.26 | 24.25 | 52.38 | 2 | 2.00 | 68.05 | 92.38 |
grid9×6 | 54 | 4 | 2 | 2 | 3 | 3.99 | 3.99 | 2 | 3.54 | 24.78 | 46.30 | 2 | 2.00 | 68.07 | 88.30 |
grid9×7 | 63 | 4 | 2 | 2 | 3 | 4.00 | 4.00 | 2 | 3.73 | 26.74 | 47.35 | 2 | 2.00 | 73.15 | 91.35 |
grid9×8 | 72 | 4 | 2 | 2 | 3 | 4.00 | 4.00 | 2 | 3.71 | 29.24 | 51.53 | 2 | 2.00 | 80.43 | 97.53 |
grid9×9 | 81 | 4 | 2 | 2 | 4 | 4.10 | 4.10 | 2 | 3.86 | 29.77 | 54.83 | 2 | 2.00 | 86.26 | 102.83 |
Ising32×8.col | 256 | 4 | 2 | 2 | 4 | 4.20 | 4.20 | 4 | 4.01 | 45.79 | 85.72 | 2 | 2.00 | 140.34 | 149.72 |
ising32×8-torus.col | 256 | 4 | 2 | 2 | 4 | 4.37 | 4.37 | 4 | 4.01 | 43.37 | 76.80 | 2 | 2.00 | 124.08 | 136.80 |
Average | 2.33 | 3.27 | 3.27 | 2.09 | 2.74 | 17.81 | 31.49 | 2.00 | 2.00 | 38.19 | 66.02 | ||||
# times best | 0 | 0 | 42 | ||||||||||||
# times all equal | 3 | 3 | 3 | ||||||||||||
# times worst | 43 | 0 | 0 |
4.5 Results for small instances from Lee (2008)
Finally, we present results obtained by the three algorithms for rather small instances used by Lee (2008) for the evaluation of a firefly-inspired distributed graph coloring algorithm. We do not directly compare with the results presented in Lee (2008), because the algorithm proposed in Lee (2008) assumes that the number of colors required for the coloring is known a priori, that is, the algorithm must be run for a pre-determined number of colors. When graphs are large and chromatic numbers are unknown, such an algorithm is not practical. Anyway, FrogSim and the algorithm from Lee (2008) behave very similarly for most instances, with some exceptions: for hexagon-based instances, FrogSim is not quite able to match the average results obtained by the algorithm from Lee (2008). Moreover, concerning icosahedron.col, the best solution by FrogSim uses one color more than the best one by Lee’s algorithm. On the other side, concerning 4-partite-4-diff-sizes.col and dodecahedron.col, FrogSim improves over the average results obtained by Lee’s algorithm.
Results for the instances introduced in Lee (2008). The first column indicates the instance name. The group of columns labeled “Properties” provides for each problem instance the number of nodes |V|, the maximum degree Δ, the chromatic number χ, and the quality of the coloring (column “cent.”) obtained with the centralized algorithm by Malaguti et al. (2008). For each of the three algorithms Finocchi, FrogSim^{⊖} and FrogSim three measures are provided: (1) the value of the best solution found (column “colors”), (2) the average solution quality (column “avg.”), and (3) the average number of communication rounds that were used (column “rounds”). In the case of FrogSim^{⊖} and FrogSim, the average number of communication rounds at which the algorithms converged is additionally provided (column “conv.”). The best algorithm for each instance is indicated in bold face. The best algorithm is hereby defined as the one that generates the best solution. Ties are broken by the average performance
Instance | Properties | Finocchi | FrogSim^{⊖} | FrogSim | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|V| | Δ | χ | Cent. | Colors | Avg. | Rounds | Colors | Avg. | Rounds | Conv. | Colors | Avg. | Rounds | Conv. | |
1hexagon-tess.col | 7 | 6 | 3 | 3 | 3 | 3.33 | 3.33 | 3 | 3.070 | 5.430 | 10.040 | 3 | 3.050 | 5.640 | 34.040 |
2-partite-size6.col | 12 | 6 | 2 | 2 | 2 | 2.00 | 2.00 | 2 | 2.00 | 5.00 | 6.50 | 2 | 2.00 | 5.00 | 30.50 |
2hexagon-tess.col | 10 | 6 | 3 | 3 | 3 | 3.93 | 3.93 | 3 | 3.58 | 5.68 | 11.42 | 3 | 3.35 | 8.27 | 35.42 |
3-partite-3-diff-sizes.col | 6 | 5 | 3 | 3 | 3 | 3.00 | 3.00 | 3 | 3.00 | 5.00 | 9.17 | 3 | 3.00 | 5.00 | 33.17 |
3-partite-size-6.col | 18 | 12 | 3 | 3 | 3 | 3.31 | 2.31 | 3 | 3.00 | 5.00 | 11.04 | 3 | 3.00 | 5.00 | 35.04 |
3hexagon-tess.col | 12 | 6 | 3 | 3 | 3 | 4.18 | 4.18 | 3 | 3.86 | 6.04 | 12.43 | 3 | 3.48 | 10.15 | 36.43 |
3partite6.col | 18 | 12 | 3 | 3 | 3 | 3.30 | 2.30 | 3 | 3.00 | 5.00 | 11.17 | 3 | 3.00 | 5.00 | 35.17 |
4-partite-4-diff-sizes.col | 10 | 9 | 4 | 4 | 4 | 4.00 | 4.00 | 4 | 4.00 | 5.00 | 10.38 | 4 | 4.00 | 5.00 | 34.38 |
4triangles | 12 | 3 | 3 | 3 | 3 | 3.26 | 3.26 | 3 | 3.06 | 7.46 | 13.76 | 3 | 3.00 | 8.33 | 39.76 |
6hexagon-tess.col | 19 | 6 | 3 | 3 | 3 | 4.64 | 4.64 | 3 | 4.25 | 8.29 | 16.29 | 3 | 3.95 | 12.82 | 42.29 |
7partite2.col | 14 | 12 | 7 | 7 | 7 | 7.06 | 6.06 | 7 | 7.00 | 5.00 | 10.62 | 7 | 7.00 | 5.00 | 34.62 |
dodecahedron.col | 20 | 3 | 3 | 3 | 3 | 3.64 | 3.64 | 3 | 3.46 | 12.00 | 19.58 | 3 | 3.43 | 12.66 | 49.58 |
icosahedron.col | 12 | 5 | 4 | 4 | 4 | 4.77 | 4.77 | 4 | 4.48 | 7.88 | 12.99 | 4 | 4.40 | 9.01 | 38.99 |
peterson.col | 10 | 3 | 3 | 3 | 3 | 3.15 | 3.15 | 3 | 3.02 | 5.34 | 10.62 | 3 | 3.02 | 5.34 | 34.62 |
Average | 3.36 | 3.83 | 3.61 | 3.36 | 3.63 | 6.29 | 11.86 | 3.36 | 3.55 | 7.30 | 36.72 | ||||
# times best | 0 | 0 | 7 | ||||||||||||
# times all equal | 3 | 3 | 3 | ||||||||||||
# times worst | 11 | 0 | 0 |
4.6 Summary concerning communication round requirements
Concerning all problem instances tackled in this work, algorithm FrogSim^{⊖} needs, on average, 13.16 communication rounds for finding its best solution. Algorithm Finocchi uses, on average, a comparable number of communication rounds (13.14). The average number of communication rounds that FrogSim spends on phase I before converging and switching to phase II is 19.65. Counting both phases, FrogSim requires, on average, 26.41 communication rounds for finding its best solution. It should be noted that, in the case of FrogSim these numbers do not depend so much on the size of the network, but rather on the networks’ edge density.
5 Conclusions and future work
Graph coloring is a classical problem of modern mathematics with more than 150 years of history. The problem has been extensively studied in theory and practice. Recently, its connection to problems that have arisen with the proliferation of wireless networks has caused a special interest in resolving the problem in a distributed manner. Due to the lack of global knowledge, in distributed algorithms the nodes have to base their color choices exclusively on information they receive from their neighbors.
The algorithm we have presented in this paper is inspired by the behavior of a family of frogs native to Japan, namely the calling behavior of Japanese tree frogs. The results achieved by the proposed algorithm compare very favorably with a current state-of-the-art algorithm. In particular, an improved performance has been measured for about 90% of the studied instances. The benchmark set that we chose for comparison includes random geometric graphs, most of the graphs of the DIMACS challenge, and grid graphs. Apart from the favorable results, the proposed algorithm uses messages of constant size, which means that it is scalable up to very large networks. Moreover, the number of communication rounds required is comparable to that required by other algorithms that provide high quality solutions. Finally, our algorithm provides a valid coloring immediately in the very first communication round.
With regard to future work, we consider the use of the proposed algorithm for time division multiplexing (TDM), a mechanism for collision-free communication in wireless networks that is strongly related to graph coloring. Finally, due to its adaptive nature, our algorithm might also be interesting for mobile networks, or any dynamically changing network.
Footnotes
- 1.
In the scope of this paper the time complexity is, as usual, measured in terms of communication rounds. A communication round is the unit of time in which each node is allowed to send at most one message.
- 2.
All graphs that we used for the experimental evaluation can be found for download at http://www.lsi.upc.edu/~hhernandez/graphcoloring.
- 3.
Note that random geometric graphs are a generalization of unit disk graphs, because unit disk graphs are restricted to r=1. Moreover, note that all random geometric graphs considered in this work are connected graphs. In the case of disconnected graphs, the proposed algorithm would simply color each component independently of the other ones.
Notes
Acknowledgements
The authors greatly appreciate the help by Enrico Malaguti who kindly provided experimental results of the centralized algorithm from Malaguti et al. (2008) for all problem instances.
Furthermore, we would like to thank Martin Middendorf who made us aware of the literature dealing with the calling behavior of Japanese tree frogs.
Finally, it is mandatory to mention the work of the Editor, Marco Dorigo, and the anonymous reviewers, who did a great job in helping to fine-tune the paper.
This work was supported by grant TIN2007-66523 (FORMALISM) of the Spanish government, and by the EU project FRONTS (FP7-ICT-2007-1). In addition, C. Blum acknowledges support from the Ramón y Cajal program of the Spanish Government, and H. Hernández acknowledges support from the Comissionat per a Universitats i Recerca del Departament d’Innovació, Universitats i Empresa de la Generalitat de Catalunya and from the European Social Fund.
References
- Aihara, I. (2009). Modeling synchronized calling behavior of Japanese tree frogs. Physical Review E, 80(1), 11–18. CrossRefGoogle Scholar
- Aihara, I., Kitahata, H., Yoshikawa, K., & Aihara, K. (2008). Mathematical modeling of frogs’ calling behavior and its possible application to artificial life and robotics. Artificial Life and Robotics, 12(1), 29–32. CrossRefGoogle Scholar
- Avanthay, C., Hertz, A., & Zufferey, N. (2003). A variable neighborhood search for graph coloring. European Journal of Operational Research, 151(2), 379–388. MathSciNetMATHCrossRefGoogle Scholar
- Barenboim, L., & Elkin, M. (2010). Deterministic distributed vertex coloring in polylogarithmic time. In SIGACT-SIGOPS 2010—Proceedings of the 29th ACM symposium on principles of distributed computing (pp. 410–419). New York: ACM Press. CrossRefGoogle Scholar
- Battiti, R., Bertossi, A. A., & Brunato, M. (2000). Distributed saturation degree methods for code assignment in multihop radio networks. In WSDAAL 2000—Proceedings of the 5th workshop on distributed systems: algorithms, architectures and languages (pp. 18–20). Google Scholar
- Blöchliger, I., & Zufferey, N. (2008). A graph coloring heuristic using partial solutions and a reactive tabu scheme. Computers & Operations Research, 35(3), 960–975. MathSciNetMATHCrossRefGoogle Scholar
- Blum, C., & Merkle, D. (Eds.) (2008). Swarm intelligence: introduction and applications. Natural computing. Berlin: Springer. MATHGoogle Scholar
- Bonabeau, E., Dorigo, M., & Theraulaz, G. (1999). Swarm intelligence: from natural to artificial systems. New York: Oxford University Press. MATHGoogle Scholar
- Braunstein, A., Mulet, R., Pagnani, A., Weigt, M., & Zecchina, R. (2003). Polynomial iterative algorithms for coloring and analyzing random graphs. Physics Review E, 68, 15 pp. Google Scholar
- Bui, M., Butelle, F., & Lavault, C. (2004). A distributed algorithm for constructing a minimum diameter spanning tree. Journal of Parallel and Distributed Computing, 64(5), 571–577. MATHCrossRefGoogle Scholar
- Cardei, M., MacCallum, E. D., & Cheng, X. (2002). Wireless sensor networks with energy efficient organization. Journal of Interconnection Networks, 3(4), 213–229. CrossRefGoogle Scholar
- Degesys, J., & Nagpal, R. (2008). Towards desynchronization of multi-hop topologies. In S. Brueckner, P. Robertson, & U. Bellur (Eds.), SASO 2008—Proceedings of the 2nd IEEE international conference on self-adaptive and self-organizing systems (pp. 129–138). Piscataway: IEEE Press. CrossRefGoogle Scholar
- Dorigo, M., & Birattari, M. (2007). Swarm intelligence. Scholarpedia, 2(9), 1462. CrossRefGoogle Scholar
- Dorne, R., & Hao, J. K. (1998). A new genetic local search algorithm for graph coloring. In A. Eiben, T. Bäck, M. Schoenauer, & H.-P. Schwefel (Eds.), Lecture notes in computer science: Vol. 1498. PPSN 1998—Proceedings of the 5th international conference on parallel problem solving from nature (pp. 745–755). Berlin: Springer. CrossRefGoogle Scholar
- Finocchi, I., Panconesi, A., & Silvestri, R. (2005). An experimental analysis of simple, distributed vertex coloring algorithms. Algorithmica, 41(1), 1–23. MathSciNetMATHCrossRefGoogle Scholar
- Center for Discrete Mathematics and Theoretical Computer Science (2006). Dimacs implementation challenges. http://dimacs.rutgers.edu/Challenges/.
- Fraigniaud, P., Gavoille, C., Ilcinkas, D., & Pelc, A. (2009). Distributed computing with advice: information sensitivity of graph coloring. Distributed Computing, 21(6), 395–403. CrossRefGoogle Scholar
- Galinier, P., & Hao, J.-K. (1999). Hybrid evolutionary algorithms for graph coloring. Journal of Combinatorial Optimization, 3, 379–397. MathSciNetMATHCrossRefGoogle Scholar
- Gavoille, C., Klasing, R., Kosowski, A., Kuszner, L., & Navarra, A. (2009). On the complexity of distributed graph coloring with local minimality constraints. Networks, 54(1), 12–19. MathSciNetMATHCrossRefGoogle Scholar
- Guo, C., Zhong, L. C., & Rabaey, J. M. (2001). Low power distributed mac for ad hoc sensor radio networks. In GLOBECOM 2001—IEEE global telecommunications conference, Vol. 5 (pp. 2944–2948). Piscataway: IEEE Press. Google Scholar
- Hansen, J., Kubale, M., Kuszner, Ł., & Nadolski, A. (2004). Distributed largest-first algorithm for graph coloring. In M. Danelutto, M. Vanneschi, & D. Laforenza (Eds.), Lecture notes in computer science: Vol. 3149. Euro-Par 2004—Proceedings of the 10th international European conference on parallel and distributed computing (pp. 804–811). Berlin: Springer. Google Scholar
- Herman, T., & Tixeuil, S. (2004). A distributed TDMA slot assignment algorithm for wireless sensor networks. In S. Nikoletseas & J. D. P. Rolim (Eds.), Lecture notes in computer science: Vol. 3121. ALGOSENSORS 2004—Proceedings of 1st international workshop on algorithmic aspects of wireless sensor networks (pp. 45–58). Berlin: Springer. CrossRefGoogle Scholar
- Hernández, H., & Blum, C. (2011). Implementing a model of Japanese tree frogs’ calling behavior in sensor networks: a study of possible improvements. In N. Krasnogor & P. L. Lanzi (Eds.), BIS-WSN 2011—Proceedings of the 1st international GECCO workshop on bio-inspired solutions for wireless sensor networks, Vol. 2 (pp. 615–622). New York: ACM Press. Google Scholar
- Hertz, A., Plumettaz, M., & Zufferey, N. (2008). Variable space search for graph coloring. Discrete Applied Mathematics, 156(13), 2551–2560. MathSciNetMATHCrossRefGoogle Scholar
- Karp, R. M. (1972). Reducibility among combinatorial problems. Complexity of Computer Computations, 40(4), 85–103. MathSciNetCrossRefGoogle Scholar
- Keshavarzian, A., Lee, H., & Venkatraman, L. (2006). Wakeup scheduling in wireless sensor networks. In MobiHoc 06—Proceedings of the 7th ACM international symposium on mobile ad-hoc networking and computing (pp. 322–333). New York: ACM Press. CrossRefGoogle Scholar
- Kosowski, A., & Kuszner, Ł. (2006). On greedy graph coloring in the distributed model. In W. E. Nagel, W. V. Walter, & W. Lehner (Eds.), Lecture notes in computer science: Vol. 4128. Euro-Par 2006—Proceedings of the 12th international European conference on parallel and distributed computing (pp. 592–601). Berlin: Springer. Google Scholar
- Kroc, L., Sabharwal, A., & Selman, B. (2009). Counting solution clusters in graph coloring problems using belief propagation. In D. Koller, D. Schuurmans, Y. Bengio, & L. Bottou (Eds.), Proceedings of NIPS 2008—22nd annual conference on neural information processing systems (pp. 873–880). Cambridge: MIT Press. Google Scholar
- Kubale, M., & Kuszner, Ł. (2002). A better practical algorithm for distributed graph coloring. In PARELEC 02—Proceedings of the international conference on parallel computing in electrical engineering (pp. 72–75). Washington: IEEE Computer Society. CrossRefGoogle Scholar
- Kuhn, F., & Wattenhofer, R. (2006). On the complexity of distributed graph coloring. In PODC 2006—Proceedings of the 25th annual ACM symposium on principles of distributed computing (pp. 7–15). New York: ACM Press. Google Scholar
- Lee, S. A. (2008). Firefly inspired distributed graph coloring algorithms. In H. R. Arabnia & Y. Mun (Eds.), PDPTA 2008—Proceedings of the international conference on parallel and distributed processing techniques and applications (pp. 211–217). CSREA Press. Google Scholar
- Lee, S. A. (2010). k-Phase oscillator synchronization for graph coloring. Mathematics in Computer Science, 3(1), 61–72. MathSciNetMATHCrossRefGoogle Scholar
- Lee, S. A., & Lister, R. (2008). Experiments in the dynamics of phase coupled oscillators when applied to graph coloring. In ACSC 2008—Proceedings of the 31st Australasian conference on computer science (pp. 83–89). Darlinghurst: Australian Computer Society, Inc. Google Scholar
- Lu, G., Sadagopan, N., Krishnamachari, B., & Goel, A. (2005). Delay efficient sleep scheduling in wireless sensor networks. In K. Makki & E. Knightly (Eds.), INFOCOM 2005—Proceedings of the IEEE 24th international conference on computer communications (pp. 2470–2481). Piscataway: IEEE Press. Google Scholar
- Lü, Z., & Hao, J. K. (2010). A memetic algorithm for graph coloring. European Journal of Operational Research, 203(1), 241–250. MathSciNetMATHCrossRefGoogle Scholar
- Lynch, N. A. (2009). Distributed algorithms. San Mateo: Morgan Kaufmann. Google Scholar
- Malaguti, E., Monaci, M., & Toth, P. (2008). A metaheuristic approach for the vertex coloring problem. Journal on Computing, 20(2), 302–316. MathSciNetGoogle Scholar
- Malaguti, E., Monaci, M., & Toth, P. (2011). An exact approach for the vertex coloring problem. Discrete Optimization, 8(2), 174–190. MathSciNetCrossRefGoogle Scholar
- Malaguti, E., & Toth, P. (2010). A survey on vertex coloring problems. International Transactions in Operational Research, 17(1), 1–34. MathSciNetMATHCrossRefGoogle Scholar
- Maneva, E., Mossel, E., & Wainwright, M. J. (2007). A new look at survey propagation and its generalizations. Journal of the ACM, 54(4), 17. MathSciNetCrossRefGoogle Scholar
- Moscibroda, T., & Wattenhofer, R. (2008). Coloring unstructured radio networks. Distributed Computing, 21(4), 271–284. CrossRefGoogle Scholar
- Mutazono, A., Sugano, M., & Murata, M. (2009). Frog call-inspired self-organizing anti-phase synchronization for wireless sensor networks. In INDS 2009—Proceedings of the 2nd international workshop on nonlinear dynamics and synchronization (pp. 81–88). Piscataway: IEEE Press. Google Scholar
- Panagopoulou, P., & Spirakis, P. (2008). A game theoretic approach for efficient graph coloring. In S.-H. Hong, H. Nagamochi, & T. Fukunaga (Eds.), Lecture notes in computer science: Vol. 5369. ISAAC 2008—Proceedings of the 19th international symposium on algorithms and computation (pp. 183–195). Berlin: Springer. Google Scholar
- Pearl, J. (1986). Fusion, propagation, and structuring in belief networks. Artificial Intelligence, 29(3), 241–288. MathSciNetMATHCrossRefGoogle Scholar
- Santi, P. (2005a). Topology control in wireless ad hoc and sensor networks. ACM Computer Surveys, 37, 164–194. CrossRefGoogle Scholar
- Santi, P. (2005b). Topology control in wireless ad hoc and sensor networks. Chichester: Wiley. CrossRefGoogle Scholar
- Wells, K. D. (1977). The social behaviour of anuran amphibians. Animal Behaviour, 25, 666–693. CrossRefGoogle Scholar
- Zhang, W., Wang, G., Xing, Z., & Wittenburg, L. (2005). Distributed stochastic search and distributed breakout: properties, comparison and applications to constraint optimization problems in sensor networks. Artificial Intelligence, 161(1–2), 55–87. MathSciNetMATHCrossRefGoogle Scholar
- Zivan, R. (2008). Anytime local search for distributed constraint optimization. In AAMAS 08—The 7th international joint conference on autonomous agents and multiagent systems, Vol. 3 (pp. 1449–1452). Richland: International Foundation for Autonomous Agents and Multiagent Systems. Google Scholar