JCOL: A Java package for solving the graph coloring problem

Shalin Shah

Implementation of the three heuristic algorithms including DSatur[1], Iterated Greedy [2] and min-conflicts local search in a mixed strategy (randomized) for graph coloring in Java. The algorithm is created with tha aim of obtaining the best coloring, irrespective of run time. If you need to speed up the algorithm, consider not using local search. Also, if you need help with this, please open an issue.

The heuristic follows the following steps:

Compute a clique (maximum is good)
Color the clique
Sort the rest of the vertices in non-increasing order of the degree of saturation
Color the vertices in the order given by 3. Also, when a vertex is colored, change the degree of saturation of the neighboring vertices so that the order of coloring changes
Improve the coloring using Iterated Greedy techniques [2]
Improve the coloring using min-conflicts local search
Report the coloring

[1]"New methods to color the vertices of a graph", Brelaz D., CACM 22(4) pp 251--256

[2]"Iterated Greedy graph coloring and the difficulty landscape", Culberson J

Cite this work

@article{shah2020jcol,
  doi = {10.21105/joss.01843},
  url = {https://doi.org/10.21105/joss.01843},
  year = {2020},
  publisher = {The Open Journal},
  volume = {5},
  number = {48},
  pages = {1843},
  author = {Shalin Shah},
  title = {JCOL: A Java package for solving the graph coloring problem},
  journal = {Journal of Open Source Software}
}

Maven is needed to compile and package the code.

For e.g. you might run "brew install maven" on a Mac. Compile the code using Maven:

mvn package

(Please ignore the compilation warnings, it is because the code does not use generics)

Then, run the algorithm using any of the two methods:

Heuristics

java -cp target/graphcoloring-1.7-jar-with-dependencies.jar com.gcol.GraphColoring -f data.col

java -cp target/graphcoloring-1.7-jar-with-dependencies.jar com.gcol.GraphColoring
usage: java -cp graphcoloring-1.7-jar-with-dependencies.jar com.gcol.GraphColoring
 -f <arg>   The DIMACS formatted graph file name
 -h         This help message
 -help      This help message
 -i <arg>   Number of iterated greedy iterations
 -j <arg>   Number of local search iterations
 -l <arg>   Enable local search true/false
 -m <arg>   Number of milliseconds to spend on local search
 -v <arg>   Verbose true/false

Backtracking

java -cp target/graphcoloring-1.7-jar-with-dependencies.jar com.gcol.Backtracking -f data.col

java -cp target/graphcoloring-1.7-jar-with-dependencies.jar com.gcol.Backtracking
usage: java -cp graphcoloring-1.7-jar-with-dependencies.jar com.gcol.Backtracking
 -f <arg>   The DIMACS formatted graph file name
 -h         This help message
 -help      This help message
 -t <arg>   Number of milliseconds to spend on each value of k
 -v <arg>   Verbose true/false

Please remove all comments (lines starting with a 'c') and other extraneous text from the file.

Please run automatedtests.sh in the tests directory to test the code.

Instances are available here and here in DIMACS format. (The use of graphs in binary format is not yet supported).

(If you want to use the DIMACS formatted files on ColPack, please use DimacsToMatrix.java)

Very Large Graphs

If you need to run the algorithm for very large graphs, please consider setting local search to false.

java -cp target/graphcoloring-1.7-jar-with-dependencies.jar com.gcol.GraphColoring -f data.col -l false

If you need help, please open an issue.

If you want to call the code as an API, please see API.

Cited By:

1) Mirarab, Siavash, et al. "Statistical binning enables an accurate coalescent-based estimation of the avian tree." Science 346.6215 (2014): 1250463. 2) https://github.com/smirarab/binning/ 3) Ahmad Muklason, Hyper-heuristics and Fairness in Examination Timetabling Problems

The algorithm was run on a few benchmark instances and the results are shown in the following table. The algorithm was run 10 times and the best and the worst results are shown.

• The algorithm was terminated before local search

The algorithm was run on a few more benchmark instances and the results are shown in the following table.

ColPack comparison

I ran ColPack (DISTANCE_ONE) on some of the publicly available data sets for comparison. The results are in the following table. On all of the instances, our algorithm is as good or better than the ColPack implementations. On the le450_5d and the queen9_9 instances, our method is able to achieve a better coloring of the graphs.

About execution time, there are several parameters which can be used to control the run time. For instance, one could disable local search, or reduce the number of iterations and get a much better run time. On the inithx.i.3 instance with 621 vertices, this algorithm takes 2 seconds (1000 iterations, without local search) and ColPack takes 45 milliseconds. But if the goal is to get a good enough coloring as fast as possible, the algorithm could be changed. Please open an issue if this is the case.

The following table shows the results and the time it takes for JCOL (100 iterations, no local search) and ColPack on some benchmarks.

References

[1] Brélaz, D. (1979). New methods to color the vertices of a graph. Communications of the ACM, 22(4), 251–256. doi:10.1145/359094.359101

[2] Culberson, J. (1992). Iterated greedy graph coloring and the difficulty landscape. doi:10.7939/R3M32NH6Q

[3] Gebremedhin, A., Nguyen, D., Patwary, M., & Pothen, A. (2010). ColPack: Software for graph coloring and related problems in scientific computing. Submitted to ACM TOMS. doi:10.1145/2513109.2513110

[4] Malaguti, E., & Toth, P. (2010). A survey on vertex coloring problems. International transactions in operational research, 17(1), 1–34. doi:10.1111/j.1475-3995.2009.00696.x