Log In Sign Up

Minimum Partition into Plane Subgraphs: The CG:SHOP Challenge 2022

We give an overview of the 2022 Computational Geometry Challenge targeting the problem Minimum Partition into Plane Subsets, which consists of partitioning a given set of line segments into a minimum number of non-crossing subsets.


page 7

page 10

page 11


On computing the vertex connectivity of 1-plane graphs

A graph is called 1-plane if it has an embedding in the plane where each...

Computing Smallest Convex Intersecting Polygons

A polygon C is an intersecting polygon for a set O of objects in the pla...

Rectangular Partitions of a Rectilinear Polygon

We investigate the problem of partitioning a rectilinear polygon P with ...

Area-Optimal Simple Polygonalizations: The CG Challenge 2019

We give an overview of theoretical and practical aspects of finding a si...

Computing Convex Partitions for Point Sets in the Plane: The CG:SHOP Challenge 2020

We give an overview of the 2020 Computational Geometry Challenge, which ...

Minimum-Width Double-Strip and Parallelogram Annulus

In this paper, we study the problem of computing a minimum-width double-...

Locally Fair Partitioning

We model the societal task of redistricting political districts as a par...

1 Introduction

The “CG:SHOP Challenge” (Computational Geometry: Solving Hard Optimization Problems) originated as a workshop at the 2019 Computational Geometry Week (CG Week) in Portland, Oregon in June, 2019. The goal was to conduct a computational challenge competition that focused attention on a specific hard geometric optimization problem, encouraging researchers to devise and implement solution methods that could be compared scientifically based on how well they performed on a database of carefully selected and varied instances. While much of computational geometry research is theoretical, often seeking provable approximation algorithms for -hard optimization problems, the goal of the CG Challenge was to set the metric of success based on computational results on a specific set of benchmark geometric instances. The 2019 CG Challenge focused on the problem of computing simple polygons of minimum and maximum area for given sets of vertices in the plane. This Challenge generated a strong response from many research groups, from both the computational geometry and the combinatorial optimization communities, and resulted in a lively exchange of solution ideas.

For CG Weeks 2020 and 2021, the Challenge problems were Minimum Convex Partition and Coordinated Motion Planning, respectively. The CG:SHOP Challenge became an event within the CG Week program, with top performing solutions reported in the Symposium on Computational Geometry proceedings. The schedule for the Challenge was advanced earlier, to give an opportunity for more participation, particularly among students, e.g., as part of course projects.

The fourth edition of the Challenge in 2022 continued this format, leading to contributions in the SoCG proceedings. A record number of 40 teams registered, with 32 submitting at least one valid solution.

2 The Challenge: Partition into Plane Subgraphs

A suitable contest problem has a number of desirable properties.

  • The problem is of geometric nature.

  • The problem is of general scientific interest and has received previous attention.

  • Optimization problems tend to be more suitable than feasibility problems; in principle, feasibility problems are also possible, but they need to be suitable for sufficiently fine-grained scoring to produce an interesting contest.

  • Computing optimal solutions is difficult for instances of reasonable size.

  • This difficulty is of a fundamental algorithmic nature, and not only due to issues of encoding or access to sophisticated software or hardware.

  • Verifying feasibility of provided solutions is relatively easy.

In this fourth year, a call for suitable problems was communicated in May 2021. In response, a total of seven interesting problems were proposed for the 2022 Challenge. These were evaluated with respect to difficulty, distinctiveness from previous years, and existing literature and related work. In the end, the Advisory Board selected the chosen problem. Special thanks go to Johannes Obenaus (FU Berlin) who suggested this problem, based on his own related work [obenaus2021edge, aichholzer2020plane].

2.1 The Problem

The specific problem that formed the basis of the 2022 CG Challenge was the following; see Figure 1 for a simple example.

Figure 1: A possible instance, given by a set of line segments in the plane (left) and a feasible partition into three plane subgraphs represented as an edge coloring (right). Note that segments sharing a common endpoint are not considered intersecting, but a segment with a point in the interior of another segment is considered to intersect that segment.

Problem: Partitioning into Plane Subgraphs

Given: A set of distinct segments in the plane. Arbitrarily many segments may share a common endpoint and the points need not be in general position. This input can also be considered to be the straight-line embedding of a graph with a vertex for each distinct segment endpoint and an edge corresponding to each segment.

Goal: The task is to compute a partition of into a minimum number of disjoint subsets , such that and no two segments in the same subset intersect.

For the purpose of this contest, two segments are considered intersecting iff they have a common point that is not an endpoint of both segments. In other words, two segments intersect if they share a point that is an endpoint of neither segment or if the endpoint of one segment lies in the interior of the other. By this definition, segments that merely share an endpoint do not intersect.

The problem can also be cast as graph coloring on the conflict graph (also known as intersection graph) of . This graph contains a vertex for each segment, i.e., , and two vertices are adjacent in if the corresponding segments intersect. In graph coloring, the task is to assign a color value from to each of the vertices, such that adjacent vertices receive different colors, while minimizing the number of colors .

2.2 Related Work

There is not much research regarding the specific, geometric version of the contest problem. However, the fact that it can be equivalently stated as graph coloring of the conflict graph means that any research on solving graph coloring can be applied directly. Due to its fundamental nature and its prominence in theoretical computer science and mathematics, there is more research on graph coloring than we can reasonably cite here. We therefore focus on practical approaches that do not require graphs to have certain attributes and that could be applied to our problem; an overview over many heuristic approaches can also be found in 

[jensen2011graph] or in the book by Lewis [lewisbook], who also provides implementations of several heuristic and metaheuristic approaches. Additionally, much of the existing practical research on graph coloring focuses on rather sparse graphs [10.1007/978-3-030-19212-9_25, lin2017reduction]. In contrast, the conflict graphs in our contest are typically fairly dense with somewhere between and of all possible edges; some of them have more than 1.5 billion edges with under 75,000 nodes.

2.2.1 Simple Heuristics

In order to come up with a decent initial coloring, greedy heuristics can be used. A very well-known greedy heuristic due to Welsh and Powell [welsh1967upper] assigns the lowest possible color to the uncolored vertex with highest degree, until all vertices are colored.

This result has been improved in various ways. One of the most prominent greedy coloring strategies is called DSATUR (degree of saturation), and is due to Brélaz [dsatur]. A suitable implementation, in particular for dense graphs, runs in time. It is also possible to achieve an running time, which may be preferable if the number of edges is . It assigns colors to vertices one-by-one, like the classic greedy algorithm, but instead of choosing the vertex with maximum degree, it chooses the vertex with most colors, breaking ties by maximum degree. This heuristic has been studied w.r.t. various aspects, including theoretical guarantees for certain graph classes and sizes [janczewski2001smallest].

Other greedy-type heuristics include RLF due to Leighton [rlf], which runs in time . It constructs one maximal color class at a time, while trying to minimize the number of edges that remain in the uncolored graph, i.e., edges that may still cause conflicts in each step. Variations of this heuristic have been studied and shown to be successful for certain graph classes [matula1972graph].

2.2.2 Exact Methods

DSATUR has also been used as a subroutine in a branch-and-bound-based exact graph coloring algorithm, sometimes called Backtracking DSATUR [sager1991pruning], which became the de-facto standard algorithm for exact graph coloring for a while after its presentation in 1991; it was later improved by further research, in part driven by the 1993 DIMACS implementation challenge on Cliques, Coloring and Satisfiability [sewell1996improved]. More recently, San Segundo [san2012new] and Furini et al. [furini2017improved] presented improved branch-and-bound-based exact coloring methods that also make extensive use of DSATUR.

Graph coloring has also been tackled using branch-and-bound algorithms based on integer programming [mendez2006branch]. The obvious formulation (with a zero-one-variable for each vertex and each color) is known to have a weak relaxation that suffers from many symmetric solutions due to the fact that colors can be used interchangeably, and has trivial solutions with value 2 for any graph [malaguti2010survey].

Another formulation proposed by Mehrotra and Trick [mehrotra1996column]

turns the coloring problem into a set cover problem by introducing binary variables for independent sets in a column-generation approach, aiming to cover all vertices with as few independent sets as possible. This approach was adapted into a branch-cut-and-price approach by Furini and Malaguti 

[furini2012exact]; it can also be based on constraint programming instead of integer programming [gualandi2012exact]. These approaches are typically enough to solve instances with several hundred vertices; the size of our contest instances was significantly higher, consisting of at least several thousand vertices in the conflict graph.

Other approaches to exact graph coloring involve listing small independent sets [eppstein2002small] or make use of tree-, path- or linear-decompositions of a graph [lucet2006exact].

2.2.3 Metaheuristics & Improvement Search

Due to the limited size of instances that can still be solved to provable optimality, most practical methods focus on providing good solution without aiming for provable optimality. These methods typically start with an initial coloring produced by the application of one or more simple heuristics, such as DSATUR or RLF, and then try to improve it.

One way to improve a given initial coloring is by using a folklore procedure sometimes called iterated greedy coloring. Given a valid coloring, permute the color values; this can be done according to different strategies, e.g., by reversing the color values or by randomly permuting them. Afterwards, iterate through the vertices in order of non-decreasing color, and assign to each vertex the lowest color that is not currently present in its neighborhood. Because each vertex will receive at most its color in the permuted list of colors, the resulting coloring will use at most the same number of colors as the original coloring, but may also use fewer colors. Repeated application of this scheme tends to reduce the number of colors for colorings produced by simple heuristics.

While being fast and simple, this approach, which maintains the validity of the coloring in each step, is typically weak when compared to other approaches to improving a coloring. These typically try to remove a color class, e.g., by recoloring all vertices with random colors. This of course may make the coloring invalid; typical improvement methods then try to restore the validity of the coloring by minimizing the number of conflicts — i.e., the number of edges with — using some type of local search, ultimately trying to reduce it to 0.

One classical approach in this vein is the TABUCOL algorithm introduced by Hertz and De Werra [hertz1987using], which tries to minimize the number of conflicts using tabu search. The basic operation is to take a conflicting vertex and recolor it, such that the number of conflicts is minimized, subject to a tabu list of color assignments.

Another local search approach is to allow partial colorings instead of conflicts; removing a color class is done by making vertices from some color class uncolored. This approach was introduced by Blöchliger and Zufferey [blochliger2008graph] for their PARTIALCOL algorithm, which also makes use of tabu search to minimize the number of uncolored vertices.

Another approach to minimizing the number of conflicts using metaheuristics is the use of population-based algorithms. They are often combined with tabu search or other local search mechanisms, which can be applied in a population-based algorithm in several ways, into so-called

hybrid evolutionary algorithms

, yielding some of the best recently developed coloring metaheuristics [moalic2018variations]. For instance, tabu search may be used as a mutation operator as in MACOL [lu2010memetic]; it may also simply be applied on each new population member to restore a decent level of conflict-freeness after crossover.

There are also multiple options for mate selection and crossover. One of the best-known crossover routines is called Greedy Partition Crossover (GPX) and due to Galinier and Hao [galinier1999hybrid]. In it, a possibly conflicting -coloring is constructed from two parents by carrying over entire color classes from a parent to the child, relabeling colors in the process. The next color class to be copied is chosen greedily, maximizing the number of currently uncolored vertices in the class. The first color assignment to a vertex done in this manner determines the color of the vertex in the child. Vertices that remain uncolored — because only color classes can be copied — are assigned a color in some way, e.g., randomly or using a heuristic such as DSATUR. Other crossover operators choose the color class to be copied randomly [falkenauer1996hybrid] or form new color classes from the union of color classes of the parents [dorne1998new]; in more recent work, crossover has become even more complex [porumbel2010evolutionary]. In recent work, Goudet et al. [goudet2021deep]

combine deep learning with population-based metaheuristics to obtain a new coloring algorithm that they find highly competitive compared to existing metaheuristics.

Another approach that is different from simple local search procedures and hybrids between population-based and local-search-based metaheuristics is quantum annealing [titiloye2011quantum, titiloye2012parameter].

In recent years, research has also focused on computing colorings for very large graphs in a distributed fashion; in many cases, these approaches are applied to graphs that are too large even for the standard greedy heuristics, which is not the case for our contest graphs. These methods often begin by stripping a graph of its low-degree vertices, and then trying to solve the coloring problem on the remaining kernel. Hebrard and Katsirelos [10.1007/978-3-030-19212-9_25] present an algorithm based on a combination of the idea outlined above with local search. They present methods to find subgraphs that require a large number of colors, which provides them with good lower bounds, allowing them to cut off more vertices; on the other hand, a local search procedure is used to find good colorings. In some cases, this can lead to provably optimal results for large graphs.

2.3 Instances

An important part of any challenge is the creation of suitable instances. If the instances are easy to solve to optimality, the challenge becomes trivial; On the other hand, if instances require a huge amount of computation for important common pre-processing steps or for finding any decent solutions, the challenge may heavily favor teams that can afford better computation equipment. The same is true if the set of instances becomes too large to manage with a single (or few) computers.

We implemented simple exact solvers based on integer programming, constraint programming, SAT solvers and heuristics to obtain a rough estimate on the maximum instance size that can be solved to optimality using these methods. SAT solvers were able to solve some instances exceeding 2,000 segments in a day; therefore, our contest did not contain any instances with fewer than 2,000 segments.

A priori, it is difficult to tell how hard finding a good solution to an instance is and which parameters influence the difficulty of solving an instance (and in what way). Therefore, it is important to create a set of instances that are diverse with respect to parameters that are likely to influence their difficulty.

Furthermore, it can be argued that good instances should also avoid containing too many parts that can be easily discarded. They also should not offer ways to subdivide the problem into independent subproblems. If the instances have many such features, they may become much easier than anticipated by their size or may even become accidentally trivial.

In the context of this contest, this means that the conflict graphs should be connected and should not easily be disconnected by removing a few vertices. Furthermore, they should not have too many vertices of small degree: any vertex with degree for some lower bound on the required number of colors can simply be discarded; such vertices can later be colored in a greedy fashion in reverse order of removal without increasing the number of colors. Similarly, if two (non-adjacent) vertices have , can be removed and later be colored using the same color as . Such vertices increase an instance’s size without contributing to its difficulty.

Besides the aforementioned issues, the presence of a large fraction of trivially removable features could force contestants to implement an even larger number of well-known ideas in their code instead of focusing on developing fresh ideas. Of course it can also be argued that the removal of such features should not be done, e.g., because practical instances can also have trivially discardable parts or may admit a subdivision into independent subproblems, and making use of such features is important in a solver that is used on real-world instances. It is therefore a judgement call whether to extensively prune such features from contest instances during their generation or not. We did not extensively apply such pruning techniques to our instances, but for several generators we took care to avoid trivial instances and situations in which a subdivision into independent subproblems was obvious, such as disconnected conflict graphs.

To create interesting and challenging instances, we developed several instance generators that can be tuned by adjusting several parameters to create diverse instances. We used the following generators to generate our instances.


We begin by generating a set of integer points , choosing integer - and -coordinates uniformly at random within some rectangle . We then compute the list of all possible edges on and sort them by their length. We then exclude all edges that are outside some quantile range, i.e., edges that are shorter than percent or longer than

percent of all edges. We then uniformly sample our instance’s edges from the remaining edges, adding each edge uniformly at random with some probability



We begin by obtaining a polygon from the Salzburg Database of Polygonal Data [salzburgpoly] with a number of vertices within a certain range. We then randomly generate a set of points in the interior of that polygon uniformly at random and connect each pair of points by an edge if is visible from in . The connected points form the segments of our resulting instance. Should the conflict graph of the instance be disconnected into several large components, or the instance be too large, or too small, we discard it and retry.


We begin by generating a random regular graph with some number of vertices and some regular degree , such that is even. We then embed this graph in the plane, using the algorithm of Kamada and Kawai [kamadakawai]. The edges of this embedded graph are included in the instance. Finally, we add some additional edges uniformly at random between the points with a small probability .

Each generator is optionally modified by a procedure that adds an aspect of edge coloring to the instance. In edge coloring, we have to color edges that share a vertex with different colors. Our procedure scales each individual segment by a factor , for some small , shifting its endpoints outwards from the segment’s center. In this way, segments that formerly shared an endpoint and could potentially receive the same color are now truly intersecting and must receive different colors. We denote the application of this procedure by a suffix ecn added to the generator name. Furthermore, each generator can be augmented by a procedure that adds a small number of edges between randomly selected points as noise. We denote the application of this procedure by a prefix r added to the generator name. Our contest instances used the generators sqrp, sqrpecn, visp, vispecn and reecn. In all our generators, we maintain integrality of coordinates by scaling with a large constant and rounding the resulting coordinates to the nearest integer. Figure 2 shows examples of actual contest instances.

(a) Instance reecn6910.
(b) Instance sqrp7730.
(c) Instance sqrpecn3020.
(d) Instance vispecn2518.
(e) Instance rvisp20601.
(f) Instance visp26405.
Figure 2: A selection of actual contest instances made by different generators.

We measured several properties for each of the generated instances, including the number of edges, the density, i.e., the number of edges compared to the potential edges, the number of edges and density of the conflict graph, as well as the number of colors required by well-known coloring heuristics such as DSATUR [dsatur] and RLF [rlf].

Based on these properties, we then defined and tuned a distance function between the instances and used a greedy dispersion algorithm to select a total of 225 diverse instances from a much larger set of candidate instances; see Figure 5 for an analysis of the difficulty of the various instances.

2.4 Evaluation

The contest was run on a total of 225 instances. For the coloring problem, it is often considerably harder to find a solution with the optimal number of colors than it is to find a solution that comes close to the optimum, say or colors.

In order to reflect this in the scoring of solutions, instead of a score that linearly depends on the number of colors, we introduced an exponential scoring function. For an instance , let be the number of colors required in the best solutions submitted for that instance. Furthermore, let be the number of colors in the best solution of some team for . The score of team for instance is

In other words, the team loses of its current score for each further percent by which they exceed the best submitted solution; teams submitting a solution with colors receive a score of . Teams that did not submit any valid solution for an instance receive a default score of , corresponding to a solution with infinitely many colors.

The total score of each team was then calculated by summing the score for that team over all instances . The winner of the contest was the team with the highest score. In case of ties, the tiebreaker was set to be the time a specific score was obtained. This turned out to be unnecessary.

2.5 Categories

The contest was run in an Open Class, in which participants could use any computing device, any amount of computing time (within the duration of the contest) and any team composition. In the Junior Class, a team was required to consist exclusively of participants who were eligible according to the rules of CG:YRF (the Young Researchers Forum of CG Week), defined as not having defended a formal doctorate before 2020.

2.6 Server and Timeline

The contest itself was run through a dedicated server at TU Braunschweig, hosted at It opened at 00:00 (UTC) on September 19, 2021, and closed at 24:00 (midnight, AoE), on January 19, 2022.

3 Outcomes

A total of 40 teams signed up for the competition, and 32 teams submitted at least one valid solution. In the end, the leaderboard for the top 10 teams looked as shown in Table 1. The overall winner of the contest are Team Shadoks, with a perfect score of 225, meaning that no other team beat their solution on any instance.

Rank Team Score Junior
1 Shadoks 225.000
2 gitastrophe 217.486
4 TU Wien 195.967
5 OMEGA-UHA 144.481
6 Luiwammus 131.275
7 Expressway65 127.765
8 The Turtles 123.600
9 Wouter 122.317
10 ALGA@TUe 119.213
Table 1: The top 10 of the final score, rounded to three decimal places. Teams that satisfy the criteria for being considered a junior team have a checkmark in the “Junior” column.

The progress over time of each team’s score can be seen in Figure 3; the best solutions for all instances (displayed by score) can be seen in Figure 4. The top four teams were invited for contributions in the 2022 SoCG proceedings, as follows.

  1. Team Shadoks: Loïc Crombez, Guilherme D. da Fonseca, Yan Gerard and Aldo Gonzalez-Lorenzo [shadoks].

  2. Team gitastrophe: Jack Spalding-Jamieson, Brandon Zhang and Da Wei Zheng [gitastrophe].

  3. Team LASAOFOOFUBESTINNRRALLDECA: Florian Fontan, Pascal Lafourcade, Luc Libralesso and Benjamin Momège [lasawhatever].

  4. Team TU Wien: André Schidler [tuwien].

All these teams engineered their solutions based on a spectrum of heuristics for generating initial solutions. Some teams relied on well-known graph coloring heuristics for the initial solutions, some augmented these heuristics, making use of the geometric nature of the problem. These initial solutions were then improved by various methods, including local search; several teams based their improvement search on an adaptation of the conflict optimization method used by Team Shadoks in the previous installment of the contest [crombez2021shadoks]. Details of their methods and the engineering decisions they made are given in their respective papers.

For comparison, we ran the heuristics DSATUR and RLF, as well as several hundred iterations of the iterated greedy improvement strategy on all instances; we also ran a previously existing implementation [lewisbook] of a simple, tabu-search-based hybrid evolutionary algorithm on all instances with a very modest time limit of minutes. Table 2 shows how these algorithms would have performed in the contest.

Heuristic Score Rank
Hybrid EA 61.017 19
Iterated Greedy 59.743 19
DSATUR & RLF 53.924 21
DSATUR 52.809 22
RLF 33.698 24
Table 2: The score that simple heuristics and metaheuristics would have achieved, and the rank they would have gotten, had they participated in the contest.

This shows the massive advantage of the approaches of the top teams over simple, out-of-the-box methods; it also shows that the majority of contest participants actually came up with algorithms that were able to beat such methods.

Figure 3: Score progress of the teams over time. It is remarkable that the initial solutions submitted by the team Shadoks in September were only surpassed by three other teams. By multiple smaller improvements, team Shadoks maintained their lead after their initial submission until the end. Team LASAOFOOFUBESTINNRRALLDECA also joined early and strong while team gitastrophe only joined in late December, quickly raising to rank 2.
Figure 4: The (mean) scores over the instance sizes of the ten best teams. We can see that team Shadoks submitted the best solution on all instances, leading to the perfect score of 225. The performance of team TU Wien seems to slightly decrease with size, while the top 3 teams get closer. Most other teams reach slightly higher scores for the large instances than for the medium-sized instances.
Figure 5: The distribution of the scores achieved by the teams, by instance type and size. This plot provides some clues for the practical difficulty of instances, indicated by low average scores. Because the scores are based on the best submitted solution, this implies that some teams with special approaches where able to obtain significantly better results than “basic” approaches. In particular, vispecn instances seem to be harder for most participants than many other instance types.

4 Conclusions

The 2022 CG:SHOP Challenge motivated a considerable number of teams to engage in extensive optimization studies. The outcomes promise further insight into the underlying, important optimization problem. Moreover, the success of the teams that based their approach on the winning team’s approach from last year, which considered a completely different problem, shows that the contest may drive research that may be applicable to various problems from different problem domains. Moreover, the considerable participation of junior teams indicates that the Challenge itself motivates a great number of students and young researchers to work on practical algorithmic problems.