Coffman–Graham algorithm

The Coffman–Graham algorithm is an algorithm for arranging the elements of a partially ordered set into a sequence of levels. The algorithm chooses an arrangement such that an element that comes after another in the order is assigned to a lower level, and such that each level has a number of elements that does not exceed a fixed width bound $W$. When $W = 2$, it uses the minimum possible number of distinct levels, and in general it uses at most $2 &minus; 2/W$ times as many levels as necessary.

It is named after Edward G. Coffman, Jr. and Ronald Graham, who published it in 1972 for an application in job shop scheduling. In this application, the elements to be ordered are jobs, the bound $W$ is the number of jobs that can be scheduled at any one time, and the partial order describes prerequisite relations between the jobs. The goal is to find a schedule that completes all jobs in minimum total time. Subsequently, the same algorithm has also been used in graph drawing, as a way of placing the vertices of a directed graph into layers of fixed widths so that most or all edges are directed consistently downwards.

For a partial ordering given by its transitive reduction (covering relation), the Coffman–Graham algorithm can be implemented in linear time using the partition refinement data structure as a subroutine. If the transitive reduction is not given, it takes polynomial time to construct it.

Problem statement and applications
In the version of the job shop scheduling problem solved by the Coffman–Graham algorithm, one is given a set of $n$ jobs $J_{1}, J_{2}, ..., J_{n}$, together with a system of precedence constraints $J_{i} < J_{j}$ requiring that job $J_{i}$ be completed before job $J_{j}$ begins. Each job is assumed to take unit time to complete. The scheduling task is to assign each of these jobs to time slots on a system of $W$ identical processors, minimizing the makespan of the assignment (the time from the beginning of the first job until the completion of the final job). Abstractly, the precedence constraints define a partial order on the jobs, so the problem can be rephrased as one of assigning the elements of this partial order to levels (time slots) in such a way that each time slot has at most as many jobs as processors (at most $W$ elements per level), respecting the precedence constraints. This application was the original motivation for Coffman and Graham to develop their algorithm.

In the layered graph drawing framework outlined by the input is a directed graph, and a drawing of a graph is constructed in several stages: In this framework, the $y$-coordinate assignment again involves grouping elements of a partially ordered set (the vertices of the graph, with the reachability ordering on the vertex set) into layers (sets of vertices with the same $W$-coordinate), which is the problem solved by the Coffman–Graham algorithm. Although there exist alternative approaches than the Coffman–Graham algorithm to the layering step, these alternatives in general are either not able to incorporate a bound on the maximum width of a level or rely on complex integer programming procedures.
 * 1) A feedback arc set is chosen, and the edges of this set reversed, in order to convert the input into a directed acyclic graph with (if possible) few reversed edges.
 * 2) The vertices of the graph are given integer $y$-coordinates in such a way that, for each edge, the starting vertex of the edge has a higher coordinate than the ending vertex, with at most $y$ vertices sharing the same $x$-coordinate. In this way, all edges of the directed acyclic graph and most edges of the original graph will be oriented consistently downwards.
 * 3) Dummy vertices are introduced within each edge so that the subdivided edges all connect pairs of vertices that are in adjacent levels of the drawing.
 * 4) Within each group of vertices with the same $y$-coordinate, the vertices are permuted in order to minimize the number of crossings in the resulting drawing, and the vertices are assigned $y$-coordinates consistently with this permutation.
 * 5) The vertices and edges of the graph are drawn with the coordinates assigned to them.

More abstractly, both of these problems can be formalized as a problem in which the input consists of a partially ordered set and an integer $W$. The desired output is an assignment of integer level numbers to the elements of the partially ordered set such that, if $x < y$ is an ordered pair of related elements of the partial order, the number assigned to $x$ is smaller than the number assigned to $y$, such that at most $W$ elements are assigned the same number as each other, and minimizing the difference between the smallest and the largest assigned numbers.

The algorithm
The Coffman–Graham algorithm performs the following steps.
 * 1) Represent the partial order by its transitive reduction or covering relation, a directed acyclic graph $G$ that has an edge from x to y whenever $x < y$ and there does not exist any third element $z$ of the partial order for which $x < z < y$. In the graph drawing applications of the Coffman–Graham algorithm, the resulting directed acyclic graph may not be the same as the graph being drawn, and in the scheduling applications it may not have an edge for every precedence constraint of the input: in both cases, the transitive reduction removes redundant edges that are not necessary for defining the partial order.
 * 2) Construct a topological ordering of $G$ in which the vertices are ordered lexicographically by the set of positions of their incoming neighbors. To do so, add the vertices one at a time to the ordering, at each step choosing a vertex $v$ to add such that the incoming neighbors of $v$ are all already part of the partial ordering, and such that the most recently added incoming neighbor of $v$ is earlier than the most recently added incoming neighbor of any other vertex that could be added in place of $v$. If two vertices have the same most recently added incoming neighbor, the algorithm breaks the tie in favor of the one whose second most recently added incoming neighbor is earlier, etc.
 * 3) Assign the vertices of $G$ to levels in the reverse of the topological ordering constructed in the previous step. For each vertex $v$, add $v$ to a level that is at least one step higher than the highest level of any outgoing neighbor of $v$, that does not already have $W$ elements assigned to it, and that is as low as possible subject to these two constraints.

Output quality
As originally proved, their algorithm computes an optimal assignment for $W = 2$; that is, for scheduling problems with unit length jobs on two processors, or for layered graph drawing problems with at most two vertices per layer. A closely related algorithm also finds the optimal solution for scheduling of jobs with varying lengths, allowing pre-emption of scheduled jobs, on two processors. For $W > 2$, the Coffman–Graham algorithm uses a number of levels (or computes a schedule with a makespan) that is within a factor of $2 &minus; 2/W$ of optimal. For instance, for $W = 3$, this means that it uses at most $4/3$ times as many levels as is optimal. When the partial order of precedence constraints is an interval order, or belongs to several related classes of partial orders, the Coffman–Graham algorithm finds a solution with the minimum number of levels regardless of its width bound.

As well as finding schedules with small makespan, the Coffman–Graham algorithm (modified from the presentation here so that it topologically orders the reverse graph of $G$ and places the vertices as early as possible rather than as late as possible) minimizes the total flow time of two-processor schedules, the sum of the completion times of the individual jobs. A related algorithm can be used to minimize the total flow time for a version of the problem in which preemption of jobs is allowed.

Time complexity
and state the time complexity of the Coffman–Graham algorithm, on an $n$-element partial order, to be $O(n^{2})$. However, this analysis omits the time for constructing the transitive reduction, which is not known to be possible within this bound. shows how to implement the topological ordering stage of the algorithm in linear time, based on the idea of partition refinement. Sethi also shows how to implement the level assignment stage of the algorithm efficiently by using a disjoint-set data structure. In particular, with a version of this structure published later by, this stage also takes linear time.