Algorithmica

, Volume 68, Issue 3, pp 692–714

Scheduling Partially Ordered Jobs Faster than 2n

Authors

  • Marek Cygan
    • Institute of InformaticsUniversity of Warsaw
    • Institute of InformaticsUniversity of Warsaw
  • Michał Pilipczuk
    • Faculty of Mathematics, Informatics and MechanicsUniversity of Warsaw
  • Jakub Onufry Wojtaszczyk
    • Google Inc.
Open AccessArticle

DOI: 10.1007/s00453-012-9694-7

Cite this article as:
Cygan, M., Pilipczuk, M., Pilipczuk, M. et al. Algorithmica (2014) 68: 692. doi:10.1007/s00453-012-9694-7
  • 527 Views

Abstract

In a scheduling problem, denoted by 1|prec|∑Ci in the Graham notation, we are given a set of n jobs, together with their processing times and precedence constraints. The task is to order the jobs so that their total completion time is minimized. 1|prec|∑Ci is a special case of the Traveling Repairman Problem with precedences. A natural dynamic programming algorithm solves both these problems in 2nnO(1) time, and whether there exists an algorithms solving 1|prec|∑Ci in O(cn) time for some constant c<2 was an open problem posted in 2004 by Woeginger. In this paper we answer this question positively.

Keywords

Moderately-exponential algorithmsDynamic programming2n-BarrierSchedulingPartially ordered jobs

1 Introduction

It is commonly believed that no NP-hard problem is solvable in polynomial time. However, while all NP-complete problems are equivalent with respect to polynomial time reductions, they appear to be very different with respect to the best exponential time exact solutions. In particular, most NP-complete problems can be solved significantly faster than the (generic for the NP class) obvious brute-force algorithm that checks all possible solutions; examples are Independent Set [11], Dominating Set [11, 23], Chromatic Number [4] and Bandwidth [8]. The area of moderately exponential time algorithms studies upper and lower bounds for exact solutions for hard problems. The race for the fastest exact algorithm inspired several very interesting tools and techniques such as Fast Subset Convolution [3] and Measure&Conquer [11] (for an overview of the field we refer the reader to a recent book by Fomin and Kratsch [10]).

For several problems, including TSP, Chromatic Number, Permanent, Set Cover, #Hamiltonian Cycles and SAT, the currently best known time complexity is of the form1O(2n), which is a result of applying dynamic programming over subsets, the inclusion-exclusion principle or a brute force search. The question remains, however, which of those problems are inherently so hard that it is not possible to break the 2n barrier and which are just waiting for new tools and techniques still to be discovered. In particular, the hardness of the k-SAT problem is the starting point for the Strong Exponential Time Hypothesis of Impagliazzo and Paturi [15], which is used as an argument that other problems are hard [7, 19, 22]. Recently, on the positive side, O(cn) time algorithms for a constant c<2 have been developed for Capacitated Domination [9], Irredundance [1], Maximum Induced Planar Subgraph [12] and (a major breakthrough in the field) for the undirected version of the Hamiltonian Cycle problem [2].

In this paper we extend this list by one important scheduling problem. The area of scheduling algorithms originates from practical questions regarding scheduling jobs on single- or multiple-processor machines or scheduling I/O requests. It has quickly become one of the most important areas in algorithmics, with significant influence on other branches of computer science. For example, the research of the job-shop scheduling problem in 1960s resulted in designing the competitive analysis [13], initiating the research of online algorithms. Up to today, the scheduling literature consists of thousands of research publications. We refer the reader to the classical textbook of Brucker [5].

Among scheduling problems one may find a bunch of problems solvable in polynomial time, as well as many NP-hard ones. For example, the aforementioned job-shop problem is NP-complete on at least three machines [17], but polynomial on two machines with unitary processing times [14].

Scheduling problems come in numerous variants. For example, one may consider scheduling on one machine, or many uniform or non-uniform machines. The jobs can have different attributes: they may arrive at different times, may have deadlines or precedence constraints, preemption may or may not be allowed. There are also many objective functions, for example the makespan of the computation, total completion time, total lateness (in case of deadlines for jobs) etc.

Let us focus on the case of a single machine. Assume we are given a set of jobs V, and each job v has its processing time t(v)∈[0,+∞). For a job v, its completion time is the total amount of time that this job waited to be finished; formally, the completion time of a job v is defined as the sum of processing times of v and all jobs scheduled earlier. If we are to minimize the total completion time (i.e, the sum of completion times over all jobs), it is clear that the jobs should be scheduled in order of increasing processing times. The question of minimizing the makespan of the computation (i.e., maximum completion time) is obvious in this setting, but we note that minimizing makespan is polynomially solvable even if we are given a precedence constraints on the jobs (i.e., a partial order on the set of jobs is given, and a job cannot be scheduled before all its predecessors in the partial order are finished) and jobs arrive at different times (i.e., each job has its arrival time, before which it cannot be scheduled) [16].

Lenstra and Rinnooy Kan [18] in 1978 proved that the question of minimizing total completion time on one machine becomes NP-complete if we are given precedence constraints on the set of jobs. To the best of our knowledge the currently smallest approximation ratio for this case equals 2, due to independently discovered algorithms by Chekuri and Motwani [6] as well as Margot et al. [20]. The problem of minimizing total completion time on one machine, given precedence constraints on the set of jobs, can be solved by a standard dynamic programming algorithm in time O(2n), where n denotes the number of jobs. In this paper we break the 2n-barrier for this problem.

Before we start, let us define formally the considered problem. As we focus on a single scheduling problem, for brevity we denote it by SCHED. We note that the proper name of this problem in the Graham notation is 1|prec|∑Ci.
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Figa_HTML.gif

If u<v for u,vV (i.e., uv and uv), we say that uprecedesv, u is a predecessor or prerequisite of v, u is required for v or that v is a successor of u. We denote |V| by n.

SCHED is a special case of the precedence constrained Traveling Repairman Problem (prec-TRP), defined as follows. A repairman needs to visit all vertices of a (directed or undirected) graph G=(V,E) with distances d:E→[0,∞) on edges. At each vertex, the repairman is supposed to repair a broken machine; a cost of a machine v is the time Cv that it waited before being repaired. Thus, the goal is to minimize the total repair time, that is, ∑vVCv. Additionally, in the precedence constrained case, we are given a partial order (V,≤) on the set of vertices of G; a machine can be repaired only if all its predecessors are already repaired. Note that, given an instance (V,≤,t) of SCHED, we may construct equivalent prec-TRP instance, by taking G to be a complete directed graph on the vertex set V, keeping the precedence constraints unmodified, and setting d(u,v)=t(v).

The TRP problem is closely related to the Traveling Salesman Problem (TSP). All these problems are NP-complete and solvable in O(2n) time by an easy application of the dynamic programming approach (here n stands for the number of vertices in the input graph). In 2010, Björklund [2] discovered a genuine way to solve probably the easiest NP-complete version of the TSP problem—the question of deciding whether a given undirected graph is Hamiltonian—in randomized O(1.66n) time. However, his approach does not extend to directed graphs, not even mentioning graphs with distances defined on edges.

Björklund’s approach is based on purely graph-theoretical and combinatorial reasonings, and seem unable to cope with arbitrary (large, real) weights (distances, processing times). This is also the case with many other combinatorial approaches. Probably motivated by this, Woeginger at International Workshop on Parameterized and Exact Computation (IWPEC) in 2004 [24] has posed the question (repeated in 2008 [25]), whether it is possible to construct an O((2−ε)n) time algorithm for the SCHED problem.2 This problem seems to be the easiest case of the aforementioned family of TSP-related problems with arbitrary weights. In this paper we present such an algorithm, thus affirmatively answering Woeginger’s question. Woeginger also asked [24, 25] whether an O((2−ε)n) time algorithm for one of the problems TRP, TSP, prec-TRP, SCHED implies O((2−ε)n) time algorithms for the other problems. This problem is still open.

The most important ingredient of our algorithm is a combinatorial lemma (Lemma 2.6) which allows us to investigate the structure of the SCHED problem. We heavily use the fact that we are solving the SCHED problem and not its more general TSP related version, and for this reason we believe that obtaining O((2−ε)n) time algorithms for other problems listed by Woeginger is much harder.

2 The Algorithm

2.1 High-Level Overview—Part 1

Let us recall that our task in the SCHED problem is to compute an ordering σ:V→{1,2,…,n} that satisfies the precedence constraints (i.e., if u<v then σ(u)<σ(v)) and minimizes the total completion time of all jobs defined as
$$T(\sigma) = \sum_{v \in V}\ \ \sum _{u:\sigma(u) \leq\sigma(v)} t(u) = \sum_{v \in V} \bigl(n-\sigma(v)+1\bigr)t(v). $$
We define the cost of jobvat positioni to be T(v,i)=(ni+1)t(v). Thus, the total completion time is the total cost of all jobs at their respective positions in the ordering σ.
We begin by describing the algorithm that solves SCHED in O(2n) time, which we call the DP algorithm—this will be the basis for our further work. The idea—a standard dynamic programming over subsets—is that if we decide that a particular set XV will (in some order) form the prefix of our optimal σ, then the order in which we take the elements of X does not affect the choices we make regarding the ordering of the remaining VX; the only thing that matters are the precedence constraints imposed by X on VX. Thus, for each candidate set XV to form a prefix, the algorithm computes a bijection σ[X]:X→{1,2,…,|X|} that minimizes the cost of jobs from X, i.e., it minimizes T(σ[X])=∑vXT(v,σ[X](v)). The value of T(σ[X]) is computed using the following easy to check recursive formula:
$$ T(\sigma[X]) = \min_{v \in\max(X)} \bigl[T\bigl (\sigma \bigl[X \setminus\{v\} \bigr]\bigr ) + T\bigl (v, |X|\bigr ) \bigr]. $$
(1)
Here, by max(X) we mean the set of maximum elements of X—those which do not precede any element of X. The bijection σ[X] is constructed by prolonging σ[X∖{v}] by v, where v is the job at which the minimum is attained. Notice that σ[V] is exactly the ordering we are looking for. We calculate σ[V] recursively, using formula (1), storing all computed values σ[X] in memory to avoid recomputation. Thus, as the computation of a single σ[X] value given all the smaller values takes polynomial time, while σ[X] for each X is computed at most once the whole algorithm indeed runs in O(2n) time.

The overall idea of our algorithm is to identify a family of sets XV that—for some reason—are not reasonable prefix candidates, and we can skip them in the computations of the DP algorithm; we will call these unfeasible sets. If the number of feasible sets is not larger than cn for some c<2, we will be done—our recursion will visit only feasible sets, assuming T(σ[X]) to be ∞ for unfeasible X in formula (1), and the running time will be O(cn). This is formalized in the following proposition.

Proposition 2.1

Assume we are given a polynomial-time algorithm\(\mathcal{R}\)that, given a setXV, either accepts it or rejects it. Moreover, assume that the number of sets accepted by\(\mathcal{R}\)is bounded byO(cn) for some constantc. Then one can find in timeO(cn) an optimal ordering of the jobs inVamong those orderingsσwhereσ−1({1,2,…,i}) is accepted by\(\mathcal{R}\)for all 1≤in, whenever such ordering exists.

Proof

Consider the following recursive procedure to compute optimal T(σ[X]) for a given set XV:
  1. 1.

    if X is rejected by \(\mathcal{R}\), return T(σ[X])=∞;

     
  2. 2.

    if X=∅, return T(σ[X])=0;

     
  3. 3.

    if T(σ[X]) has been already computed, return the stored value of T(σ[X]);

     
  4. 4.

    otherwise, compute T(σ[X]) using formula (1), calling recursively the procedure itself to obtain values T(σ[X∖{v}]) for v∈max(X), and store the computed value for further use.

     
Clearly, the above procedure, invoked on X=V, computes optimal T(σ[V]) among those orderings σ where σ−1({1,2,…,i}) is accepted by \(\mathcal {R}\) for all 1≤in. It is straightforward to augment this procedure to return the ordering σ itself, instead of only its cost.

If we use balanced search tree to store the computed values of σ[X], each recursive call of the described procedure runs in polynomial time. Note that the last step of the procedure is invoked at most once for each set X accepted by \(\mathcal{R}\) and never for a set X rejected by \(\mathcal{R}\). As an application of this step results in at most |X|≤n recursive calls, we obtain that a computation of σ[V] using this procedure results in the number of recursive calls bounded by n times the number of sets accepted by \(\mathcal{R}\). The time bound follows. □

2.2 The Large Matching Case

We begin by noticing that the DP algorithm needs to compute σ[X] only for those XV that are downward closed, i.e., if vX and u<v then uX. If there are many constraints in our problem, this alone will suffice to limit the number of feasible sets considerably, as follows. Construct an undirected graph G with the vertex set V and edge set E={uv:u<vv<u}. Let \(\mathcal {M}\) be a maximum matching3 in G, which can be found in polynomial time [21]. If XV is downward closed, and \(uv \in \mathcal {M}\), u<v, then it is not possible that uX and vX. Obviously checking if a subset is downward closed can be performed in polynomial time, thus we can apply Proposition 2.1, accepting only downward closed subsets of V. This leads to the following lemma:

Lemma 2.2

The number of downward closed subsets ofVis bounded by\(2^{n-2|\mathcal {M}|}\* 3^{|\mathcal {M}|}\). If\(|\mathcal {M}| \geq \varepsilon _{1} n\), then we can solve theSCHEDproblem in time
$$T_1(n) = O^\star\bigl((3\slash4)^{\varepsilon _1 n} 2^n\bigr). $$

Note that for any small positive constant ε1 the complexity T1(n) is of required order, i.e., T1(n)=O(cn) for some c<2 that depends on ε1. Thus, we only have to deal with the case where \(|\mathcal {M}| < \varepsilon _{1} n\).

Let us fix a maximum matching \(\mathcal {M}\), let MV be the set of endpoints of \(\mathcal {M}\), and let I1=VM. Note that, as M is a maximum matching in G, no two jobs in I1 are bound by a precedence constraint, and |M|≤2ε1n, |I1|≥(1−2ε1)n. See Fig. 1 for an illustration.
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Fig1_HTML.gif
Fig. 1

An illustration of the case left after Lemma 2.2. In this and all further figures, an arrow points from the successor job to the predecessor one

2.3 High-Level Overview—Part 2

We are left in the situation where there is a small number of “special” elements (M), and the bulk remainder (I1), consisting of elements that are tied by precedence constraints only to M and not to each other.

First notice that if M was empty, the problem would be trivial: with no precedence constraints we should simply order the tasks from the shortest to the longest. Now let us consider what would happen if all the constraints between any uI1 and wM would be of the form u<w—that is, if the jobs from I1 had no predecessors. For any prefix set candidate X we consider XI=XI1. Now for any xXI, yI1XI we have an alternative prefix candidate: the set X′=(X∪{y})∖{x}. If t(y)<t(x), there has to be a reason why X′ is not a strictly better prefix candidate than X—namely, there has to exist wM such that x<w, but \(y\not< w\).

A similar reasoning would hold even if not all of I1 had no predecessors, but just some constant fraction J of I—again, the only feasible prefix candidates would be those in which for every xXIJ and yJXI there is a reason (either t(x)<t(y) or an element wM which requires x, but not y) not to exchange them. It turns out that if |J|>ε2n, where ε2>2ε1, this observation suffices to prove that the number of possible intersections of feasible sets with J is exponentially smaller than 2|J|. This is formalized and proved in Lemma 2.6, and is the cornerstone of the whole result.

A typical application of this lemma is as follows: say we have a set KI1 of cardinality |K|>2j, while we know for some reason that all the predecessors of elements of K appear on positions j and earlier. If K is large (a constant fraction of n), this is enough to limit the number of feasible sets to (2−ε)n. To this end it suffices to show that there are exponentially fewer than 2|K| possible intersections of a feasible set with K. Each such intersection consists of a set of at most j elements (that will be put on positions 1 through j), and then a set in which every element has a reason not to be exchanged with something from outside the set—and there are relatively few of those by Lemma 2.6—and when we do the calculations, it turns out the resulting number of possibilities is exponentially smaller than 2|K|.

To apply this reasoning, we need to be able to tell that all the prerequisites of a given element appear at some position or earlier. To achieve this, we need to know the approximate positions of the elements in M. We achieve this by branching into 4|M| cases, for each element wM choosing to which of the four quarters of the set {1,…,n} will σopt(w) belong. This incurs a multiplicative cost4 of 4|M|, which will be offset by the gains from applying Lemma 2.6.

We will now repeatedly apply Lemma 2.6 to obtain information about the positions of various elements of I1. We will repeatedly say that if “many” elements (by which we always mean more than εn for some ε) do not satisfy something, we can bound the number of feasible sets, and thus finish the algorithm. For instance, look at those elements of I1 which can appear in the first quarter, i.e., none of their prerequisites appear in quarters two, three and four. If there is more than \((\frac{1}{2}+\delta)n\) of them for some constant δ>0, we can apply the above reasoning for j=n/4 (Lemma 2.10). Subsequent lemmata bound the number of feasible sets if there are many elements that cannot appear in any of the two first quarters (Lemma 2.8), if less than \((\frac{1}{2}-\delta)n\) elements can appear in the first quarter (Lemma 2.10) and if a constant fraction of elements in the second quarter could actually appear in the first quarter (Lemma 2.11). We also apply similar reasoning to elements that can or cannot appear in the last quarter.

We end up in a situation where we have four groups of elements, each of size roughly n/4, split upon whether they can appear in the first quarter and whether they can appear in the last one; moreover, those that can appear in the first quarter will not appear in the second, and those that can appear in the fourth will not appear in the third. This means that there are two pairs of parts which do not interact, as the set of places in which they can appear are disjoint. We use this independence of sorts to construct a different algorithm than the DP we used so far, which solves our problem in this specific case in time O(23n/4+ε) (Lemma 2.12).

As can be gathered from this overview, there are many technical details we will have to navigate in the algorithm. This is made more precarious by the need to carefully select all the epsilons. We decided to use symbolic values for them in the main proof, describing their relationship appropriately, using four constants εk, k=1,2,3,4. The constants εk are very small positive reals, and additionally εk is much smaller than εk+1 for k=1,2,3. At each step, we shortly discuss the existence of such constants. We discuss the choice of optimal values of these constants in Sect. 2.9, although the value we perceive in our algorithm lies rather in the existence of an O((2−ε)n) algorithm than in the value of ε (which is admittedly very small).

2.4 Technical Preliminaries

We start with a few simplifications. First, we add a few dummy jobs with no precedence constraints and zero processing times, so that n is divisible by four. Second, by slightly perturbing the jobs’ processing times, we can assume that all processing times are pairwise different and, moreover, each ordering has different total completion time. This can be done, for instance, by replacing time t(v) with a pair (t(v),(n+1)π(v)−1), where π:V→{1,2,…,n} is an arbitrary numbering of V. The addition of pairs is performed coordinatewise, whereas comparison is performed lexicographically. Note that this in particular implies that the optimal solution is unique, we denote it by σopt. Third, at the cost of an n2 multiplicative overhead, we guess the jobs \(v_{begin} = \sigma_{opt}^{-1}(1)\) and \(v_{end}=\sigma_{opt}^{-1}(n)\) and we add precedence constraints vbegin<v<vend for each vvbegin,vend. If vbegin or vend were not in M to begin with, we add them there.

A number of times our algorithm branches into several subcases, in each branch assuming some property of the optimal solution σopt. Formally speaking, in each branch we seek the optimal ordering among those that satisfy the assumed property. We somewhat abuse the notation and denote by σopt the optimal solution in the currently considered subcase. Note that σopt is always unique within any subcase, as each ordering has different total completion time.

For vV by pred(v) we denote the set {uV:u<v} of predecessors of v, and by succ(v) we denote the set {uV:v<u} of successors of v. We extend this notation to subsets of V: pred(U)=⋃vUpred(v) and succ(U)=⋃vUsucc(v). Note that for any set UI1, both pred(U) and succ(U) are subsets of M.

In a few places in this paper we use the following simple bound on binomial coefficients that can be easily proven using the Stirling’s formula.

Lemma 2.3

Let 0<α<1 be a constant. Then
$$\binom{n}{\alpha n} = O^\ast \biggl( \biggl(\frac{1}{\alpha^\alpha(1-\alpha )^{1-\alpha}} \biggr)^n \biggr). $$
In particular, ifα≠1/2 then there exists a constantcα<2 that depends only onαand
$$\binom{n}{\alpha n} = O^\ast \bigl(c_\alpha^n \bigr). $$

2.5 The Core Lemma

We now formalize the idea of exchanges presented at the beginning of Sect. 2.3.

Definition 2.4

Consider some set KI1, and its subset LK. If there exists uL such that for every wsucc(u) we can find vw∈(Kpred(w))∖L with t(vw)<t(u) then we say L is succ-exchangeable with respect to K, otherwise we say L is non-succ-exchangeable with respect to K.

Similarly, if there exists v∈(KL) such that for every wpred(v) we can find uwLsucc(w) with t(uw)>t(v), we call Lpred-exchangeable with respect to K, otherwise we call it non-pred-exchangeable with respect to K.

Whenever it is clear from the context, we omit the set K with respect to which its subset is or is not pred- or succ-exchangeable.

Let us now give some more intuition on the exchangeable sets. Let L be a non-succ-exchangeable set with respect to KI1 and let uL. By the definition, there exists wsucc(u), such that for all vw∈(Kpred(w))∖L we have t(vw)≥t(u); in other words, all predecessors of w in K that are scheduled after L have larger processing time than u—which seems like a “correct” choice if we are to optimize the total completion time.

On the other hand, let \(L = \sigma_{opt}^{-1}(\{1,2,\ldots,i\}) \cap K\) for some 1≤in and assume that L is a succ-exchangeable set with respect to K with a job uL witnessing this fact. Let w be the job in succ(u) that is scheduled first in the optimal ordering σopt. By the definition, there exists vw∈(Kpred(w))∖L with t(vw)<t(u). It is tempting to decrease the total completion time of σopt by swapping the jobs vw and u in σopt: by the choice of w, no precedence constraint involving u will be violated by such an exchange, so we need to care only about the predecessors of vw.

We formalize the aforementioned applicability of the definition of pred- and succ-exchangeable sets in the following lemma:

Lemma 2.5

LetKI1. If for allvK,xpred(K) we have thatσopt(v)>σopt(x), then for any 1≤inthe set\(K \cap\sigma_{opt}^{-1}(\{1, 2,\ldots, i\})\)is non-succ-exchangeable with respect toK.

Similarly, if for allvK,xsucc(K) we haveσopt(v)<σopt(x), then the sets\(K \cap\sigma_{opt}^{-1}(\{1, 2,\ldots, i\})\)are non-pred-exchangeable with respect toK.

Proof

The proofs for the first and the second case are analogous. However, to help the reader get intuition on exchangeable sets, we provide them both in full detail. See Fig. 2 for an illustration on the succ-exchangeable case.
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Fig2_HTML.gif
Fig. 2

Figure illustrating the succ-exchangeable case of Lemma 2.5. Gray circles indicate positions of elements of K, black contour indicates that an element is also in L. Black squares indicate positions of elements from pred(K), and black circles—positions of other elements from M

Non-succ-exchangeable sets. Assume, by contradiction, that for some i the set \(L = K \cap\sigma_{opt}^{-1}(\{1,2,\ldots,i\} )\) is succ-exchangeable. Let uL be a job witnessing it. Let w be the successor of u with minimum σopt(w) (there exists one, as vendsucc(u)). By Definition 2.4, we have vw∈(Kpred(w))∖L with t(vw)<t(u). As vwKL, we have σopt(vw)>σopt(u). As vwpred(w), we have σopt(vw)<σopt(w).

Consider an ordering σ′ defined as σ′(u)=σopt(vw), σ′(vw)=σopt(u) and σ′(x)=σopt(x) if x∉{u,vw}; in other words, we swap the positions of u and vw in the ordering σopt. We claim that σ′ satisfies all the precedence constraints. As σopt(u)<σopt(vw), σ′ may only violates constraints of the form x<vw and u<y. However, if x<vw, then xpred(K) and σ′(vw)=σopt(u)>σopt(x)=σ′(x) by the assumptions of the Lemma. If u<y, then σ′(y)=σopt(y)≥σopt(w)>σopt(vw)=σ′(u), by the choice of w. Thus σ′ is a feasible solution to the considered SCHED instance. Since t(vw)<t(u), we have T(σ′)<T(σopt), a contradiction.

Non-pred-exchangeable sets. Assume, by contradiction, that for some i the set \(L = K \cap\sigma_{opt}^{-1}(\{1,2,\ldots,i\} )\) is pred-exchangeable. Let v∈(KL) be a job witnessing it. Let w be the predecessor of v with maximum σopt(w) (there exists one, as vbeginpred(v)). By Definition 2.4, we have uwLsucc(w) with t(uw)>t(v). As uwL, we have σopt(uw)<σopt(v). As uwsucc(w), we have σopt(uw)>σopt(w).

Consider an ordering σ′ defined as σ′(v)=σopt(uw), σ′(uw)=σopt(v) and σ′(x)=σopt(x) if x∉{v,uw}; in other words, we swap the positions of v and uw in the ordering σopt. We claim that σ′ satisfies all the precedence constraints. As σopt(uw)<σopt(v), σ′ may only violates constraints of the form x>uw and v>y. However, if x>uw, then xsucc(K) and σ′(uw)=σopt(v)<σopt(x)=σ′(x) by the assumptions of the Lemma. If v>y, then σ′(y)=σopt(y)≤σopt(w)<σopt(uw)=σ′(v), by the choice of w. Thus σ′ is a feasible solution to the considered SCHED instance. Since t(uw)>t(v), we have T(σ′)<T(σopt), a contradiction. □

Lemma 2.5 means that if we manage to identify a set K satisfying the assumptions of the lemma, the only sets the DP algorithm has to consider are the non-exchangeable ones. The following core lemma proves that there are few of those (provided that K is big enough), and we can identify them easily.

Lemma 2.6

For any setKI1the number of non-succ-exchangeable (non-pred-exchangeable) subsets with regard toKis at most\(\sum_{l \leq|M|} \binom{|K|}{l}\). Moreover, there exists an algorithm which checks whether a set issucc-exchangeable (pred-exchangeable) in polynomial time.

The idea of the proof is to construct a function f that encodes each non-exchangeable set by a subset of K no larger than M. To show this encoding is injective, we provide a decoding function g and show that gf is an identity on non-exchangeable sets.

Proof

As in Lemma 2.5, the proofs for succ- and pred-exchangeable sets are analogous, but for the sake or clarity we include both proofs in full detail.

Non-succ-exchangeable sets. For any set YK we define the function fY:MK∪{nil} as follows: for any element wM we define fY(w) (the least expensive predecessor ofwoutsideY) to be the element of (KY)∩pred(w) which has the smallest processing time, or nil if (KY)∩pred(w) is empty. We now take f(Y) (the set of the least expensive predecessors outsideY) to be the set {fY(w):wM}∖{nil}. We see that f(Y) is indeed a set of cardinality at most |M|.

Now we aim to prove that f is injective on the family of non-succ-exchangeable sets. To this end we define the reverse function g. For a set ZK (which we think of as the set of the least expensive predecessors outside some Y) let g(Z) be the set of such elements v of K that there exists wsucc(v) such that for any zwZpred(w) we have t(zw)>t(v). Notice, in particular, that g(Z)∩Z=∅, as for vZ and wsucc(v) we have vZpred(w).

First we prove g(f(Y))⊆Y for any YK. Take any vKY and consider any wsucc(v). Then fY(w)≠nil and t(fY(w))≤t(v), as v∈(KY)∩pred(w). Thus vg(f(Y)), as for any wsucc(v) we can take a witness zw=fY(w) in the definition of g(f(Y)).

In the other direction, let us assume that Y does not satisfy Yg(f(Y)). This means we have uYg(f(Y)). Then we show that Y is succ-exchangeable. Consider any wsucc(u). As ug(f(Y)), by the definition of the function g applied to the set f(Y), there exists zwf(Y)∩pred(w) with t(zw)≤t(u). But f(Y)∩Y=∅, while uY; and as all the values of t are distinct, t(zw)<t(u) and zw satisfies the condition for vw in the definition of succ-exchangeability.

Non-pred-exchangeable sets. For any set YK we define the function fY:MK∪{nil} as follows: for any element wM we define fY(w) (the most expensive successor ofwinY) to be the element of Ysucc(w) which has the largest processing time, or nil if Ysucc(w) is empty. We now take f(Y) (the set of the most expensive successors inY) to be the set {fY(w):wM}∖{nil}. We see that f(Y) is indeed a set of cardinality at most |M|.

Now we aim to prove that f is injective on the family of non-pred-exchangeable sets. To this end we define the reverse function g. For a set ZK (which we think of as the set of most expensive successors in some Y) let g(Z) be the set of such elements v of K that for any wpred(v) there exists a zwZsucc(w) with t(zw)≥t(v). Notice, in particular, that g(Z)⊆Z, as for vZ the job zw=v is a good witness for any wpred(v).

First we prove Yg(f(Y)) for any YK. Take any vY and consider any wpred(v). Then fY(w)≠nil and t(fY(w))≥t(v), as vYsucc(w). Thus vg(f(Y)), as for any wpred(v) we can take zw=fY(w) in the definition of g(f(Y)).

In the other direction, let us assume that Y does not satisfy g(f(Y))⊆Y. This means we have vg(f(Y))∖Y. Then we show that Y is pred-exchangeable. Consider any wpred(v). As vg(f(Y)), by the definition of the function g applied to the set f(Y), there exists zwf(Y)∩succ(w) with t(zw)≥t(v). But f(Y)⊆Y, while \(v \not\in Y\); and as all the values of t are distinct, t(zw)>t(v) and zw satisfies the condition for uw in the definition of pred-exchangeability.

Thus, in both cases, if Y is non-exchangeable then g(f(Y))=Y (in fact it is possible to prove in both cases that Y is non-exchangeable iff g(f(Y))=Y). As there are \(\sum_{l = 0}^{|M|} \binom{|K|}{l}\) possible values of f(Y), the first part of the lemma is proven. For the second, it suffices to notice that succ- and pred-exchangeability can be checked in time O(|K|2|M|) directly from the definition. □

Example 2.7

To illustrate the applicability of Lemma 2.6, we analyze the following very simple case: assume the whole set M∖{vbegin} succeeds I1, i.e., for every wM∖{vbegin} and vI1 we have \(w \not< v\). If ε1 is small, then we can use the first case of Lemma 2.5 for the whole set K=I1: we have pred(K)={vbegin} and we only look for orderings that put vbegin as the first processed job. Thus, we can apply Proposition 2.1 with algorithm \(\mathcal{R}\) that rejects sets XV where XI1 is succ-exchangeable with respect to I1. By Lemma 2.6, the number of sets accepted by \(\mathcal {R}\) is bounded by \(2^{|M|} \sum_{l \leq|M|} \binom{|I_{1}|}{l}\), which is small if |M|≤ε1n.

2.6 Important Jobs at n/2

As was already mentioned in the overview, the assumptions of Lemma 2.5 are quite strict; therefore, we need to learn a bit more on how σopt behaves on M in order to distinguish a suitable place for an application. As |M|≤2ε1n, we can afford branching into few subcases for every job in M.

Let A={1,2,…,n/4}, B={n/4+1,…,n/2}, C={n/2+1,…,3n/4}, D={3n/4+1,…,n}, i.e., we split {1,2,…,n} into quarters. For each wM∖{vbegin,vend} we branch into two cases: whether σopt(w) belongs to AB or CD; however, if some predecessor (successor) of w has been already assigned to CD (AB), we do not allow w to be placed in AB (CD). Of course, we already know that σopt(vbegin)∈A and σopt(vend)∈D. Recall that the vertices of M can be paired into a matching; since for each w1<w2, w1,w2M we cannot have w1 placed in CD and w2 placed in AB, this branching leads to \(3^{|M|/2} \leq3^{\varepsilon _{1} n}\) subcases, and thus the same overhead in the time complexity. By the above procedure, in all branches the guesses about alignment of jobs from M satisfy precedence constraints inside M.

Now consider a fixed branch. Let MAB and MCD be the sets of elements of M to be placed in AB and CD, respectively.

Let us now see what we can learn in a fixed branch about the behavior of σopt on I1. Let
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Eque_HTML.gif
that is \(W_{\mathrm {half}}^{AB}\) (resp. \(W_{\mathrm {half}}^{CD}\)) are those elements of I1 which are forced into the first (resp. second) half of σopt by the choices we made about M (see Fig. 3 for an illustration). If one of the Whalf sets is much larger than M, we have obtained a gain—by branching into at most \(3^{\varepsilon _{1} n}\) branches we gained additional information about a significant (much larger than (log23)ε1n) number of other elements (and so we will be able to avoid considering a significant number of sets in the DP algorithm). This is formalized in the following lemma:
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Fig3_HTML.gif
Fig. 3

An illustration of the sets MAB, MCD, \(W_{\mathrm {half}}^{AB}\) and \(W_{\mathrm {half}}^{CD}\)

Lemma 2.8

Consider a fixed branch. If\(W_{\mathrm {half}}^{AB}\)or\(W_{\mathrm {half}}^{CD}\)has at leastε2nelements, then the DP algorithm can be augmented to solve the instance in the considered branch in time
$$T_2(n) = \biggl( 2^{(1-\varepsilon _2)n} + \binom{n}{(1/2 - \varepsilon _2)n} + 2^{\varepsilon _2 n}\binom{(1-\varepsilon _2)n}{n/2} \biggr) n^{ O(1)}. $$

Proof

We describe here only the case \(|W_{\mathrm {half}}^{AB}| \geq \varepsilon _{2} n\). The second case is symmetrical.

Recall that the set \(W_{\mathrm {half}}^{AB}\) needs to be placed in AB by the optimal ordering σopt. We use Proposition 2.1 with an algorithm \(\mathcal{R}\) that accepts sets XV such that the set \(W_{\mathrm {half}}^{AB} \setminus X\) (the elements of \(W_{\mathrm {half}}^{AB}\) not scheduled in X) is of size at most max(0,n/2−|X|) (the number of jobs to be scheduled after X in the first half of the jobs). Moreover, the algorithm \(\mathcal{R}\) tests if the set X conforms with the guessed sets MAB and MCD, i.e.:
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Equg_HTML.gif
Clearly, for any 1≤in, the set \(\sigma_{opt}^{-1}(\{ 1,2,\ldots,i\})\) is accepted by \(\mathcal{R}\), as σopt places \(M^{AB} \cup W_{\mathrm {half}}^{AB}\) in AB and MCD in CD.
Let us now estimate the number of sets X accepted by \(\mathcal{R}\). Any set X of size larger than n/2 needs to contain \(W_{\mathrm {half}}^{AB}\); there are at most \(2^{n-|W_{\mathrm {half}}^{AB}|} \leq2^{(1-\varepsilon _{2})n}\) such sets. All sets of size at most \(n/2 - |W_{\mathrm {half}}^{AB}|\) are accepted by \(\mathcal{R}\); there are at most \(n\binom{n}{(1/2 - \varepsilon _{2})n}\) such sets. Consider now a set X of size n/2−α for some \(0 \leq\alpha \leq|W_{\mathrm {half}}^{AB}|\). Such a set needs to contain \(|W_{\mathrm {half}}^{AB}|-\beta\) elements of \(W_{\mathrm {half}}^{AB}\) for some 0≤βα and \(n/2 - |W_{\mathrm {half}}^{AB}| - (\alpha-\beta)\) elements of \(V \setminus W_{\mathrm {half}}^{AB}\). Therefore the number of such sets (for all possible α) is bounded by:
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Equh_HTML.gif
The last inequality follows from the fact that the function \(x \mapsto 2^{x} \binom{n-x}{n/2}\) is decreasing for x∈[0,n/2]. The bound T2(n) follows. □

Note that we have \(3^{\varepsilon _{1} n}\) overhead so far, due to guessing placement of the jobs from M. By Lemma 2.3, \(\binom{(1-\varepsilon _{2}) n}{n/2} = O((2-c(\varepsilon _{2}))^{(1-\varepsilon _{2}) n})\) and \(\binom{n}{(1/2 - \varepsilon _{2})n} = O((2-c'(\varepsilon _{2}))^{n})\), for some positive constants c(ε2) and c′(ε2) that depend only on ε2. Thus, for any small fixed ε2 we can choose ε1 sufficiently small so that \(3^{\varepsilon _{1} n} T_{2}(n) = O(c^{n})\) for some c<2. Note that \(3^{\varepsilon _{1} n} T_{2}(n)\) is an upper bound on the total time spent on processing all the considered subcases.

Let \(W_{\mathrm {half}}= W_{\mathrm {half}}^{AB} \cup W_{\mathrm {half}}^{CD}\) and I2=I1Whalf. From this point we assume that \(|W_{\mathrm {half}}^{AB}|, |W_{\mathrm {half}}^{CD}| \leq \varepsilon _{2} n\), hence |Whalf|≤2ε2n and |I2|≥(1−2ε1−2ε2)n. For each \(v \in M^{AB} \cup W_{\mathrm {half}}^{AB}\) we branch into two subcases, whether σopt(v) belongs to A or B. Similarly, for each \(v \in M^{CD} \cup W_{\mathrm {half}}^{CD}\) we guess whether σopt(v) belongs to C or D. Moreover, we terminate branches which are trivially contradicting the constraints.

Let us now estimate the number of subcases created by this branch. Recall that the vertices of M can be paired into a matching; since for each w1<w2, w1,w2M we cannot have w1 placed in a later segment than w2; this gives us 10 options for each pair w1<w2. Thus, in total they are at most \(10^{|M|/2} \leq10^{\varepsilon _{1} n}\) ways of placing vertices of M into quarters without contradicting the constraints. Moreover, this step gives us an additional \(2^{|W_{\mathrm {half}}|} \leq2^{2\varepsilon _{2} n}\) overhead in the time complexity for vertices in Whalf. Overall, at this point we are considering at most \(10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} n^{ O(1)}\) subcases.

We denote the set of elements of M and Whalf assigned to quarter Γ∈{A,B,C,D} by MΓ and \(W_{\mathrm {half}}^{\varGamma}\), respectively.

2.7 Quarters and Applications of the Core Lemma

In this section we try to apply Lemma 2.6 as follows: We look which elements of I2 can be placed in A (the set PA) and which cannot (the set P¬A). Similarly we define the set PD (can be placed in D) and P¬D (cannot be placed in D). For each of these sets, we try to apply Lemma 2.6 to some subset of it. If we fail, then in the next subsection we infer that the solutions in the quarters are partially independent of each other, and we can solve the problem in time roughly O(23n/4). Let us now proceed with a more detailed argumentation.

We define the following two partitions of I2:
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Equi_HTML.gif
In other words, the elements of P¬A cannot be placed in A because some of their requirements are in MB, and the elements of P¬D cannot be placed in D because they are required by some elements of MC (see Fig. 4 for an illustration). Note that these definitions are independent of σopt, so sets PΔ for Δ∈{AAD,D} can be computed in polynomial time. Let
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Equj_HTML.gif
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Fig4_HTML.gif
Fig. 4

An illustration of the sets PΔ for Δ∈{AAD,D} and their relation with the sets MΓ for Γ∈{A,B,C,D}

Note that pΓn/4 for every Γ∈{A,B,C,D}. As \(p^{A} = n/4 - |M^{A} \cup W_{\mathrm {half}}^{A}|\), \(p^{D} = n/4 - |M^{D} \cup W_{\mathrm {half}}^{D}|\), these values can be computed by the algorithm. We branch into (1+n/4)2 further subcases, guessing the (still unknown) values pB and pC.

Let us focus on the quarter A and assume that pA is significantly smaller than |PA|/2 (i.e., |PA|/2−pa is a constant fraction of n). We claim that we can apply Lemma 2.6 as follows. While computing σ[X], if |X|≥n/4, we can represent XPA as a disjoint sum of two subsets \(X^{A}_{A}, X^{A}_{BCD} \subseteq P^{A}\). The first one is of size pA, and represents the elements of XPA placed in quarter A, and the second represents the elements of XPA placed in quarters BCD. Note that the elements of \(X^{A}_{BCD}\) have all predecessors in the quarter A, so by Lemma 2.5 the set \(X^{A}_{BCD}\) has to be non-succ-exchangeable with respect to \(P^{A} \setminus X_{A}^{A}\); therefore, by Lemma 2.6, we can consider only a very narrow choice of \(X^{A}_{BCD}\). Thus, the whole part XPA can be represented by its subset of cardinality at most pA plus some small information about the rest. If pA is significantly smaller than |PA|/2, this representation is more concise than simply remembering a subset of PA. Thus we obtain a better bound on the number of feasible sets.

A symmetric situation arises when pD is significantly smaller than |PD|/2; moreover, we can similarly use Lemma 2.6 if pB is significantly smaller than |P¬A|/2 or pC than |P¬D|/2. This is formalized by the following lemma.

Lemma 2.9

IfpΓ<|PΔ|/2 for some (Γ,Δ)∈{(A,A),(BA),(CD), (D,D)} andε1≤1/4, then the DP algorithm can be augmented to solve the remaining instance in time bounded by
$$T_p (n) = 2^{n-|P^\varDelta|} \binom{|P^\varDelta|}{p^\varGamma} \binom {n}{|M|} n^{ O(1)}. $$

Proof

We first describe in detail the case Δ=Γ=A, and, later, we shortly describe the other cases that are proven analogously. An illustration of the proof is depicted on Fig. 5.
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Fig5_HTML.gif
Fig. 5

An illustration of the proof of Lemma 2.9 for (Γ,Δ)=(A,A)

On a high-level, we want to proceed as in Proposition 2.1, i.e., use the standard DP algorithm described in Sect. 2.1, while terminating the computation for some unfeasible subsets of V. However, in this case we need to slightly modify the recursive formula used in the computations, and we compute σ[X,L] for XV, LXPA. Intuitively, the set X plays the same role as before, whereas L is the subset of XPA that was placed in the quarter A. Formally, σ[X,L] is the ordering of X that attains the minimum total cost among those orderings σ for which L=PAσ−1(A). Thus, in the DP algorithm we use the following recursive formula:
$$ T(\sigma[X,L]) = \begin{cases} \min_{v\in\max(X)} [T(\sigma[X \setminus\{v\}, L \setminus\{v\} ]) + T(v,|X|) ] \\ \hphantom{+\infty \quad} \mbox{if}\ |X| \leq n/4\ \mbox{and}\ L=X \cap P^A, \\ +\infty \quad \mbox{if}\ |X| \leq n/4\ \mbox{and}\ L \neq X \cap P^A, \\ \min_{v\in\max(X) \setminus L} [T(\sigma[X \setminus\{v\}, L]) + T(v,|X|) ] \\ \hphantom{+\infty \quad} \mbox{otherwise}. \end{cases} $$
In the next paragraphs we describe a polynomial-time algorithm \(\mathcal {R}\) that accepts or rejects pairs of subsets (X,L), XV, LXPA; we terminate the computation on rejected pairs (X,L). As each single calculation of σ[X,L] uses at most |X| recursive calls, the time complexity of the algorithm is bounded by the number of accepted pairs, up to a polynomial multiplicative factor. We now describe the algorithm \(\mathcal{R}\).

First, given a pair (X,L), we ensure that we fulfill the guessed sets MΓ and \(W_{\mathrm {half}}^{\varGamma}\), Γ∈{A,B,C,D}, that is: E.g., we require \(M^{B}, W_{\mathrm {half}}^{B} \subseteq X\) if |X|≥n/2 and \((M^{B} \cup W_{\mathrm {half}}^{B}) \cap X = \emptyset\) if |X|≤n/4. We require similar conditions for other quarters A, C and D. Moreover, we require that X is downward closed. Note that this implies XP¬A=∅ if |X|≤n/4 and P¬DX if |X|≥3n/4.

Second, we require the following:
  1. 1.

    If |X|≤n/4, we require that L=XPA and |L|≤pA; as pA≤|PA|/2, there are at most \(2^{n-|P^{A}|} \binom {|P^{A}|}{p^{A}} n\) such pairs (X,L);

     
  2. 2.

    Otherwise, we require that |L|=pA and that the set X∩(PAL) is non-succ-exchangeable with respect to PAL; by Lemma 2.6 there are at most \(\sum_{l \leq|M|} \binom{|P^{A} \setminus L|}{l} \leq n \binom {n}{|M|}\) (since |M|≤2ε1nn/2) non-succ-exchangeable sets with respect to PAL, thus there are at most \(2^{n-|P^{A}|} \binom{|P^{A}|}{p^{A}} \binom{n}{|M|} n\) such pairs (X,L).

     

Let us now check the correctness of the above pruning. Let 0≤in and let \(X = \sigma_{opt}^{-1}(\{1,2,\ldots,i\})\) and \(L = \sigma_{opt}^{-1}(A) \cap X \cap P^{A}\). It is easy to see that Lemma 2.5 implies that in case in/4 the set X∩(PAL) is non-succ-exchangeable and the pair (X,L) is accepted.

Let us now shortly discuss the case Γ=B and ΔA. Recall that, due to the precedence constraints between P¬A and MB, the jobs from P¬A cannot be scheduled in the segment A. Therefore, while computing σ[X] for |X|≥n/2, we can represent XP¬A as a disjoint sum of two subsets \(X^{\neg A}_{B}, X^{\neg A}_{CD}\): the first one, of size pB, to be placed in B, and the second one to be placed in CD. Recall that in Sect. 2.6 we have ensured that for any vI2, all predecessors of v appear in MAB and all successors of v appear in MCD. We infer that all predecessors of jobs in \(X^{\neg A}_{CD}\) appear in segments A and B and, by Lemma 2.5, in the optimal solution the set \(X^{\neg A}_{CD}\) is non-succ-exchangeable with respect to \(P^{\neg A} \setminus X^{\neg A}_{B}\), Therefore we may proceed as in the case of (Γ,Δ)=(A,A); in particular, while computing σ[X,L]:
  1. 1.

    If |X|≤n/4, we require that L=XP¬A=∅;

     
  2. 2.

    If n/4<|X|≤n/2, we require that L=XP¬A and |L|≤pB;

     
  3. 3.

    Otherwise, we require that |L|=pB and that the set X∩(P¬AL) is non-succ-exchangeable with respect to P¬AL.

     

The cases (Γ,Δ)∈{CD),(D,D)} are symmetrical: L corresponds to jobs from PΔ scheduled to be done in segment Γ and we require that X∩(PΔL) is non-pred-exchangeable (instead of non-succ-exchangeable) with respect to PΔL. The recursive definition of T(σ[X,L]) should be also adjusted. □

Observe that if any of the sets PΔ for Δ∈{AAD,D} is significantly larger than n/2 (i.e., larger than \((\frac {1}{2}+\delta)n\) for some δ>0), one of the situations in Lemma 2.9 indeed occurs, since pΓn/4 for Γ∈{A,B,C,D} and |M| is small.

Lemma 2.10

If 2ε1<1/4+ε3/2 and at least one of the setsPA, P¬A, P¬DandPDis of size at least (1/2+ε3)n, then the DP algorithm can be augmented to solve the remaining instance in time bounded by
$$T_3(n) = 2^{(1/2-\varepsilon _3)n} \binom{(1/2+\varepsilon _3)n}{n/4} \binom{n}{2\varepsilon _1 n} n^{ O(1)}. $$

Proof

The claim is straightforward; note only that the term \(2^{n-|P^{\varDelta}|} \binom{|P^{\varDelta}|}{p^{\varGamma}}\) for pΓ<|PΔ|/2 is a decreasing function of |PΔ|. □

Note that we have \(10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} n^{ O(1)}\) overhead so far. As \(\binom{(1/2+\varepsilon _{3})n}{n/4} = O((2-c(\varepsilon _{3}))^{(1/2 + \varepsilon _{3})n})\) for some constant c(ε3)>0, for any small fixed ε3 we can choose sufficiently small ε2 and ε1 to have \(10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} n^{ O(1)} T_{3}(n) = O(c^{n})\) for some c<2.

From this point we assume that |PA|,|P¬A|,|P¬D|,|PD|≤(1/2+ε3)n. As PAP¬A=I2=P¬DPD and |I2|≥(1−2ε1−2ε2)n, this implies that these four sets are of size at least (1/2−2ε1−2ε2ε3)n, i.e., they are of size roughly n/2. Having bounded the sizes of the sets PΔ from below, we are able to use Lemma 2.9 again: if any of the numbers pA, pB, pC, pD is significantly smaller than n/4 (i.e., smaller than \((\frac{1}{4}-\delta)n\) for some δ>0), then it is also significantly smaller than half of the cardinality of the corresponding set PΔ.

Lemma 2.11

Letε123=2ε1+2ε2+ε3. If at least one of the numberspA, pB, pCandpDis smaller than (1/4−ε4)nandε4>ε123/2, then the DP algorithm can be augmented to solve the remaining instance in time bounded by
$$T_4(n) = 2^{(1/2+\varepsilon _{123})n} \binom{(1/2-\varepsilon _{123})n}{(1/4-\varepsilon _4)n} \binom{n}{2\varepsilon _1 n} n^{ O(1)}. $$

Proof

As, before, the claim is a straightforward application of Lemma 2.9, and the fact that the term \(2^{n-|P^{\varDelta}|} \binom {|P^{\varDelta}|}{p^{\varGamma}}\) for pΓ<|PΔ|/2 is a decreasing function of |PΔ|. □

So far we have \(10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} n^{ O(1)}\) overhead. Similarly as before, for any small fixed ε4 if we choose ε1,ε2,ε3 sufficiently small, we have \(\binom{(1/2-\varepsilon _{123})n}{(1/4-\varepsilon _{4})n} = O((2-c(\varepsilon _{4}))^{(1/2-\varepsilon _{123})n})\) and \(10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} n^{ O(1)}T_{4}(n) = O(c^{n})\) for some c<2.

Thus we are left with the case when pA,pB,pC,pD≥(1/4−ε4)n.

2.8 The Remaining Case

In this subsection we infer that in the remaining case the quarters A, B, C and D are somewhat independent, which allows us to develop a faster algorithm. More precisely, note that pΓ≥(1/4−ε4)n, Γ∈{A,B,C,D}, means that almost all elements that are placed in A by σopt belong to PA, while almost all elements placed in B belong to P¬A. Similarly, almost all elements placed in D belong to PD and almost all elements placed in C belong to P¬D. As PAP¬A=∅ and P¬DPD=∅, this implies that what happens in the quarters A and B, as well as C and D, is (almost) independent. This key observation can be used to develop an algorithm that solves this special case in time roughly O(23n/4).

Let \(W_{\mathrm {quarter}}^{B} = I_{2} \cap(\sigma_{opt}^{-1}(B) \setminus P^{\neg A})\) and \(W_{\mathrm {quarter}}^{C} = I_{2} \cap(\sigma_{opt}^{-1}(C) \setminus P^{\neg D})\). As pB,pC≥(1/4−ε4)n we have that \(|W_{\mathrm {quarter}}^{B}|,|W_{\mathrm {quarter}}^{C}| \leq \varepsilon _{4} n\). We branch into at most \(n^{2} \binom{n}{\varepsilon _{4} n}^{2}\) subcases, guessing the sets \(W_{\mathrm {quarter}}^{B}\) and \(W_{\mathrm {quarter}}^{C}\). Let \(W_{\mathrm {quarter}}= W_{\mathrm {quarter}}^{B} \cup W_{\mathrm {quarter}}^{C}\), I3=I2Wquarter, QΔ=PΔWquarter for Δ∈{AAD,D}. Moreover, let \(W^{\varGamma}= M^{\varGamma}\cup W_{\mathrm {half}}^{\varGamma}\cup W_{\mathrm {quarter}}^{\varGamma}\) for Γ∈{A,B,C,D}, using the convention \(W_{\mathrm {quarter}}^{A} = W_{\mathrm {quarter}}^{D} = \emptyset\).

Note that in the current branch for any ordering and any Γ∈{A,B,C,D}, the segment Γ gets all the jobs from WΓ and qΓ=n/4−|WΓ| jobs from appropriate QΔ (Δ=AAD,D for Γ=A,B,C,D, respectively). Thus, the behavior of an ordering σ in A influences the behavior of σ in C by the choice of which elements of QAQ¬D are placed in A, and which in C. Similar dependencies are between A and D, B and C, as well as B and D (see Fig. 6). In particular, there are no dependencies between A and B, as well as C and D, and we can compute the optimal arrangement by keeping track of only three out of four dependencies at once, leading us to an algorithm running in time roughly O(23n/4). This is formalized in the following lemma:
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Fig6_HTML.gif
Fig. 6

Dependencies between quarters and sets QΔ. The left part of the figure illustrates where the jobs from \(Q^{\varDelta_{1}} \cap Q^{\varDelta_{2}}\) may be placed. The right part of the figure illustrates the dependencies between the quarters

Lemma 2.12

If 2ε1+2ε2+ε4<1/4 and the assumptions of Lemmata 2.2 and 2.82.11 are not satisfied, the instance can be solved by an algorithm running in time bounded by
$$T_5(n) = \binom{n}{\varepsilon _4 n}^2 2^{(3/4+\varepsilon _3)n} n^{ O(1)}. $$

Proof

Let (Γ,Δ)∈{(A,A),(BA),(CD),(D,D)}. For each set YQΔ of size qΓ, for each bijection (partial ordering) σΓ(Y):YWΓΓ let us define its cost as
$$T(\sigma^{\varGamma}(Y)) = \sum_{v \in Y \cup W^\varGamma} T(v,\sigma^{\varGamma}(Y) (v)). $$
Let \(\sigma_{opt}^{\varGamma}(Y)\) be the partial ordering that minimizes the cost (recall that it is unique due to the initial steps in Sect. 2.4). Note that if we define \(Y_{opt}^{\varGamma}= \sigma_{opt}^{-1}(\varGamma ) \cap Q^{\varDelta}\) for (Γ,Δ)∈{(A,A),(BA),(CD),(D,D)}, then the ordering σopt consists of the partial orderings \(\sigma_{opt}^{\varGamma}(Y_{opt}^{\varGamma})\).
We first compute the values \(\sigma_{opt}^{\varGamma}(Y)\) for all (Γ,Δ)∈{(A,A),(BA), (CD),(D,D)} and YQΔ, |Y|=qΓ, by a straightforward modification of the DP algorithm. For fixed pair (Γ,Δ), the DP algorithm computes \(\sigma_{opt}^{\varGamma}(Y)\) for all Y in time
$$2^{|W^\varGamma|+|Q^\varDelta|} n^{ O(1)} \leq 2^{(2\varepsilon _1+2\varepsilon _2+\varepsilon _4)n + (1/2+\varepsilon _3)n} n^{ O(1)} = O\bigl(2^{(3/4+\varepsilon _3)n}\bigr). $$
The last inequality follows from the assumption 2ε1+2ε2+ε4<1/4.
Let us focus on the sets QAQ¬D, QAQD, Q¬AQ¬D and Q¬AQD. Without loss of generality we assume that QAQ¬D is the smallest among those. As they all are pairwise disjoint and sum up to I2, we have |QAQ¬D|≤n/4. We branch into at most \(2^{|Q^{A} \cap Q^{\neg D}|+|Q^{\neg A} \cap Q^{D}|}\) subcases, guessing the sets
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Equr_HTML.gif
Then, we choose the set
$$Y_{opt}^{AD} = Y_{opt}^A \cap \bigl(Q^A \cap Q^D\bigr) = \bigl(Q^A \cap Q^D\bigr) \setminus Y_{opt}^D $$
that optimizes
$$T(\sigma_{opt}^{A}\bigl(Y_{opt}^{AC} \cup Y_{opt}^{AD}\bigr))+T(\sigma_{opt}^{D}(Q^D \setminus\bigl(Y_{opt}^{AD} \cup Y_{opt}^{BD} \bigr)). $$
Independently, we choose the set
$$Y_{opt}^{BC} = Y_{opt}^B \cap \bigl(Q^{\neg A} \cap Q^{\neg D}\bigr) = \bigl(Q^{\neg A} \cap Q^{\neg D}\bigr) \setminus Y_{opt}^C $$
that optimizes
$$T(\sigma_{opt}^{B}\bigl(Y_{opt}^{BC} \cup Y_{opt}^{BD}\bigr))+T(\sigma_{opt}^{C}(Q^{\neg D} \setminus\bigl(Y_{opt}^{BC} \cup Y_{opt}^{AC} \bigr)). $$
To see the correctness of the above step, note that \(Y_{opt}^{A} = Y_{opt}^{AC} \cup Y_{opt}^{AD}\), and similarly for other quarters.
The time complexity of the above step is bounded by
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Equw_HTML.gif
and the bound T5(n) follows. □

So far we have \(10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} n^{ O(1)}\) overhead. For sufficiently small ε4 we have \(\binom{n}{\varepsilon _{4} n} = O(2^{n/16})\) and then for sufficiently small constants εk, k=1,2,3 we have \(10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n}n^{ O(1)} T_{5}(n) = O(c^{n})\) for some c<2.

2.9 Numerical Values of the Constants

Table 1 summarizes the running times of all cases of the algorithm. Using the following values of the constants:
https://static-content.springer.com/image/art%3A10.1007%2Fs00453-012-9694-7/MediaObjects/453_2012_9694_Equx_HTML.gif
we get that the running time of our algorithm is bounded by:
$$O\bigl( \bigl(2- 10^{-10} \bigr)^n \bigr). $$
Table 1

Summary of running times of all cases of the algorithm

Reference

Running time

Lemma 2.2

\(T_{1}(n) = O^{\star}((3\slash4)^{\varepsilon _{1} n} 2^{n})\)

Lemma 2.8

\(3^{\varepsilon _{1} n} T_{2}(n) n^{ O(1)} = 3^{\varepsilon _{1} n} ( 2^{(1-\varepsilon _{2})n} + \binom{n}{(1/2 - \varepsilon _{2})n} + 2^{\varepsilon _{2} n}\binom {(1-\varepsilon _{2})n}{n/2} ) n^{ O(1)}\)

Lemma 2.10

\(10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} T_{3}(n) n^{ O(1)} = 10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} 2^{(1/2-\varepsilon _{3})n} \binom{(1/2+\varepsilon _{3})n}{n/4} \binom{n}{2\varepsilon _{1} n} n^{ O(1)}\)

Lemma 2.11

\(10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} T_{4}(n) n^{ O(1)} = 10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} 2^{(1/2+2\varepsilon _{1}+2\varepsilon _{2}+\varepsilon _{3})n} \binom{(1/2-2\varepsilon _{1}-2\varepsilon _{2}-\varepsilon _{3})n}{(1/4-\varepsilon _{4})n} \binom{n}{2\varepsilon _{1} n} n^{ O(1)}\)

Lemma 2.12

\(10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} T_{5}(n) n^{ O(1)} = 10^{\varepsilon _{1} n} 2^{2\varepsilon _{2} n} \binom{n}{\varepsilon _{4} n}^{2} 2^{(3/4+\varepsilon _{3})n} n^{ O(1)}\)

3 Conclusion

We presented an algorithm that solves SCHED in O((2−ε)n) time for some small ε. This shows that in some sense SCHED appears to be easier than resolving CNF-SAT formulae, which is conjectured to need 2n time (the so-called Strong Exponential Time Hypothesis). Our algorithm is based on an interesting property of the optimal solution expressed in Lemma 2.6, which can be of independent interest. However, our best efforts to numerically compute an optimal choice of values of the constants εk, k=1,2,3,4 lead us to an ε of the order of 10−10. Although Lemma 2.6 seems powerful, we lost a lot while applying it. In particular, the worst trade-off seems to happen in Sect. 2.6, where ε1 needs to be chosen much smaller than ε2. The natural question is: can the base of the exponent be significantly improved?

Footnotes
1

The O( ) notation suppresses factors polynomial in the input size.

 
2

Although Woeginger in his papers asks for an O(1.99n) algorithm, the intention is clearly to ask for an O((2−ε)n) algorithm.

 
3

Even an inclusion-maximal matching, which can be found greedily, is enough.

 
4

Actually, this bound can be improved to 10|M|/2, as M are endpoints of a matching in the graph corresponding to the set of precedences.

 

Acknowledgements

We thank Dominik Scheder for very useful discussions on the SCHED problem during his stay in Warsaw. Moreover, we greatly appreciate the detailed comments of anonymous reviewers, especially regarding presentation issues and minor optimizations in our algorithm.

Open Access

This article is distributed under the terms of the Creative Commons Attribution License which permits any use, distribution, and reproduction in any medium, provided the original author(s) and the source are credited.

Copyright information

© The Author(s) 2012