Decomposition algorithms for submodular optimization with applications to parallel machine scheduling with controllable processing times

In this paper we present a decomposition algorithm for maximizing a linear function over a submodular polyhedron intersected with a box. Apart from this contribution to submodular optimization, our results extend the toolkit available in deterministic machine scheduling with controllable processing times. We demonstrate how this method can be applied to developing fast algorithms for minimizing total compression cost for preemptive schedules on parallel machines with respect to given release dates and a common deadline. Obtained scheduling algorithms are faster and easier to justify than those previously known in the scheduling literature.


Introduction
In scheduling with controllable processing times, the actual durations of the jobs are not fixed in advance, but have to be chosen from a given interval. This area of scheduling has been active since the 1980s, see surveys [16] and [22].
Normally, for a scheduling model with controllable processing times two types of decisions are required: (1) each job has to be assigned its actual processing time, and (2) a schedule has to be found that provides a required level of quality. There is a penalty for assigning shorter actual processing times, since the reduction in processing time is usually associated with an additional effort, e.g., allocation of additional resources or improving processing conditions. The quality of the resulting schedule is measured with respect to the cost of assigning the actual processing times that guarantee a certain scheduling performance.
As established in [23,24], there is a close link between scheduling with controllable processing times and linear programming problems with submodular constraints. This allows us to use the achievements of submodular optimization [4,21] for design and justification of scheduling algorithms. On the other hand, formulation of scheduling problems in terms of submodular optimization leads to the necessity of studying novel models with submodular constraints. Our papers [25,27] can be viewed as convincing examples of such a positive mutual influence of scheduling and submodular optimization.
This paper, which builds up on [26], makes another contribution towards the development of solution procedures for problems of submodular optimization and their applications to scheduling models. We present a decomposition algorithm for maximizing a linear function over a submodular polyhedron intersected with a box. Apart from this contribution to submodular optimization, our results extend the toolkit available in deterministic machine scheduling. We demonstrate how this method can be applied to several scheduling problems, in which it is required to minimize the total penalty for choosing actual processing times, also known as total compression cost. The jobs have to be processed with preemption on several parallel machines, so that no job is processed after a common deadline. The jobs may have different release dates.
The paper is organized as follows. Section 2 gives a survey of the relevant results on scheduling with controllable processing times. In Sect. 3 we reformulate three scheduling problems in terms of linear programming problems over a submodular polyhedron intersected with a box. Section 4 outlines a recursive decomposition algorithm for solving maximization linear programming problems with submodular constraints. The applications of the developed decomposition algorithm to scheduling with controllable processing times are presented in Sect. 5. The concluding remarks are contained in Sect. 6.

Scheduling with controllable processing times: a review
In this section, we give a brief overview of the known results on the preemptive scheduling problems with controllable processing times to minimize the total compression cost for schedules that are feasible with respect to given release dates and a common deadline.
Formally, in the model under consideration the jobs of set N = {1, 2, . . . , n} have to be processed on parallel machines M 1 , M 2 , . . . , M m , where m ≥ 2. For each job j ∈ N , its processing time p( j) is not given in advance but has to be chosen by the decision-maker from a given interval p( j), p( j) . That selection process can be seen as either compressing (also known as crashing) the longest processing time p( j) down to p( j), or decompressing the shortest processing time p( j) up to p( j). In the former case, the value x( j) = p( j) − p( j) is called the compression amount of job j, while in the latter case z( j) = p( j) − p( j) is called the decompression amount of job j. Compression may decrease the completion time of each job j but incurs additional cost w( j)x( j), where w( j) is a given non-negative unit compression cost. The total cost associated with a choice of the actual processing times is represented by the linear function W = j∈N w( j)x( j).
Each job j ∈ N is given a release date r ( j), before which it is not available, and a common deadline d, by which its processing must be completed. In the processing of any job, preemption is allowed, so that the processing can be interrupted on any machine at any time and resumed later, possibly on another machine. It is not allowed to process a job on more than one machine at a time, and a machine processes at most one job at a time.
Given a schedule, let C( j) denote the completion time of job j, i.e., the time at which the last portion of job j is finished on the corresponding machine. A schedule is called feasible if the processing of a job j ∈ N takes place in the time interval [r ( j), d].
We distinguish between the identical parallel machines and the uniform parallel machines. In the former case, the machines have the same speed, so that for a job j with an actual processing time p( j) the total length of the time intervals in which this job is processed in a feasible schedule is equal to p( j). If the machines are uniform, then it is assumed that machine M h has speed s h , 1 ≤ h ≤ m. Without loss of generality, throughout this paper we assume that the machines are numbered in non-increasing order of their speeds, i.e., For some schedule, denote the total time during which a job j ∈ N is processed on machine M h , 1 ≤ h ≤ m, by q h ( j). Taking into account the speed of the machine, we call the quantity s h q h ( j) the processing amount of job j on machine M h . It follows that In all scheduling problems studied in this paper, we need to determine the values of actual processing times and find the corresponding feasible preemptive schedule so that all jobs complete before the deadline and total compression cost is minimized. Adapting standard notation for scheduling problems by Lawler et al. [11], we denote problems of this type by α|r ( j), p( j) = p( j) − x( j), C( j) ≤ d, pmtn|W . Here, in the first field α we write "P" in the case of m ≥ 2 identical machines and "Q " in the case of m ≥ 2 uniform machines. In the middle field, the item "r ( j)" implies that the jobs have individual release dates; this parameter is omitted if the release dates are equal. We write " p( j) = p( j) − x( j)" to indicate that the processing times are controllable and x( j) is the compression amount to be found. The condition "C( j) ≤ d" reflects the fact that in a feasible schedule the common deadline should be respected. The abbreviation " pmtn" is used to point out that preemption is allowed. Finally, in the third field we write the objective function to be minimized, which is the total compression cost W = j∈N w( j)x( j). Scheduling problems with controllable processing times have received considerable attention since the 1980s, see, e.g., surveys by Nowicki and Zdrzałka [16] and by Shabtay and Steiner [22].
If the processing times p( j), j ∈ N , are fixed then the corresponding counterpart of problem α|r ( j), p( j) = p( j) − x( j), C( j) ≤ d, pmtn|W is denoted by α|r ( j), pmtn|C max . In the latter problem it is required to find a preemptive schedule that for the corresponding settings minimizes the makespan In the scheduling literature, there are several interpretations and formulations of scheduling models that are related to those with controllable processing times. Below we give a short overview of them, indicating the points of distinction and similarity with our definition of the model. Janiak and Kovalyov [8] argue that the processing times are resource-dependent, so that the more units of a single additional resource is given to a job, the more it can be compressed. In their model, a job j ∈ N has a 'normal' processing time b( j) (no resource given), and its actual processing time becomes p( j) = b( j) − a( j)u( j), provided that u( j) units of the resource are allocated to the job, where a( j) is interpreted as a compression rate. The amount of the resource to be allocated to a job is limited by 0 ≤ u( j) ≤ τ ( j), where τ ( j) is a known job-dependent upper bound. The cost of using one unit of the resource for compressing job j is denoted by v( j), and it is required to minimize the total cost of resource consumption. This interpretation of the controllable processing times is essentially equivalent to that adopted in this paper, which can be seen by setting A very similar model for scheduling with controllable processing times is due to Chen [2], later studied by McCormick [13]. For example, McCormick [13] gives algorithms for finding a preemptive schedule for parallel machines that is feasible with respect to arbitrary release dates and deadlines. The actual processing time of a job is determined by p( j) = max {b( j) − a( j)λ( j), 0} and the objective is to minimize the function j∈N λ( j). This is also similar to our interpretation due to Another range of scheduling models relevant to our study belongs to the area of imprecise computation; see [12] for a recent review. In computing systems that support imprecise computation, some computations (image processing programs, implementations of heuristic algorithms) can be run partially, producing less precise results. In our notation, a task with processing requirement p( j) can be split into a mandatory part which takes p ( j) time, and an optional part that may take up to p( j)− p( j) additional time units. To produce a result of reasonable quality, the mandatory part must be completed in full, while an optional part improves the accuracy of the solution. If instead of an ideal computation time p( j) a task is executed for p( j) = p( j) − x( j) time units, then computation is imprecise and x( j) corresponds to the error of computation. Typically, the problems of imprecise computation are those of finding a deadline feasible preemptive schedule either on a single machine or on parallel machines. A popular objective function is w( j)x( j), which is interpreted here as the total weighted error. It is surprising that until very recently, the similarity between the models with controllable processing times and those of imprecise computation have not been noticed. Even the most recent survey by Shabtay and Steiner [22] makes no mention of the imprecise computation research.
Scheduling problems with controllable processing times can serve as mathematical models in make-or-buy decision-making; see, e.g., Shakhlevich et al. [25]. In manufacturing, it is often the case that either the existing production capabilities are insufficient to fulfill all orders internally in time or the cost of work-in-process of an order exceeds a desirable amount. Such an order can be partly subcontracted. Subcontracting incurs additional cost but that can be either compensated by quoting realistic deadlines for all jobs or balanced by a reduction in internal production expenses. The make-or-buy decisions should be taken to determine which part of each order is manufactured internally and which is subcontracted. Under this interpretation, the orders are the jobs and for each order j ∈ N , the value of p( j) is interpreted as the processing requirement, provided that the order is manufactured internally in full, while p( j) is a given mandatory limit on the internal production. Further, p( j) = p( j) − x( j) is the chosen actual time for internal manufacturing, where x( j) shows how much of the order is subcontracted and w( j)x( j) is the cost of this subcontracting. Thus, the problem is to minimize the total subcontracting cost and find a deadline-feasible schedule for internally manufactured orders.
It is obvious that for scheduling problems with controllable processing times, minimizing the total compression cost W is equivalent to maximizing either the total decompression cost w( j)z( j) or total weighted processing time w( j) p( j). Most of the problems relevant to this study have been solved using a greedy approach. One way of implementing this approach is to start with a (possibly, infeasible) schedule in which all jobs are fully decompressed to their longest processing times p( j), scan the jobs in non-decreasing order of their weights w( j) and compress each job by the smallest possible amount that guarantees a feasible processing of a job. Another approach, which is in some sense dual to the one described above, is to start with a feasible schedule in which all jobs are fully compressed to their smallest processing times p( j), scan the jobs in non-increasing order of their weights w( j) and decompress each job by the largest possible amount.
Despite the similarity of these approaches, in early papers on this topic each problem is considered separately and a justification of the greedy approach is often lengthy and developed from the first principles. However, as established by later studies, the greedy nature of the solution approaches is due to the fact that many scheduling problems with controllable processing times can be reformulated in terms of linear programming problems over special regions such as submodular polyhedra, (generalized) polymatroids, base polyhedra, etc. See Sect. 3 for definitions and main concepts of submodular optimization.
Nemhauser and Wolsey [15] were among the first who noticed that scheduling with controllable processing times could be handled by methods of submodular optimization; see, e.g., Example 6 (Sect. 6 of Chapter III.3) of the book [15]. A systematic development of a general framework for solving scheduling problems with controllable processing times via submodular methods has been initiated by Shakhlevich and Strusevich [23,24] and further advanced by Shakhlevich et al. [25]. This paper makes another contribution in this direction.
Below we review the known results on the problems to be considered in this paper. Two aspects of the resulting algorithms are important: (1) finding the actual processing times and therefore the optimal value of the function, and (2) finding the corresponding optimal schedule. The second aspect is related to traditional scheduling to minimize the makespan with fixed processing times.
Zero release dates, common deadline The results for the models under these conditions are summarized in the second and third columns of Table 1. If the machines are identical, then solving problem P| pmtn|C max with fixed processing times can be done by a linear-time algorithm that is due to McNaughton [14]. As shown by Jansen and Mastrolilli [9], problem P| p( j) = p( j) − x( j), pmtn, C( j) ≤ d|W reduces to a continuous generalized knapsack problem and can be solved in O(n) time. Shakhlevich and Strusevich [23] consider the bicriteria problem P| p( j) = p( j) − x( j), pmtn| (C max , W ) , in which makespan C max and the total compression cost W = w( j)x( j) have to be minimized simultaneously, in the Pareto sense; the running time of their algorithm is O(n log n).
In the case of uniform machines, the best known algorithm for solving problem Q| pmtn|C max with fixed processing times is due to Gonzalez and Sahni [5]. For problem Q| p( j) = p( j) − x( j), pmtn, C( j) ≤ d|W Nowicki and Zdrzałka [17] show how to find the actual processing times in O(nm + n log n) time. Shakhlevich and Strusevich [24] reduce the problem to maximizing a linear function over a generalized polymatroid; they give an algorithm that requires the same running time as that by Nowicki and Zdrzałka [17], but can be extended to solving a bicriteria problem Q| p( j) = p( j) − x( j), pmtn| (C max , W ). The best running time for the bicriteria problem is O(nm log m), which is achieved in [27] by submodular optimization techniques.
Arbitrary release dates, common deadline The results for the models under these conditions are summarized in the fourth and fifth columns of Table 1. These models are symmetric to those with a common zero release date and arbitrary deadlines. Problem P|r ( j), pmtn|C max with fixed processing times on m identical parallel machines can [ 27] [ 27] [ 27] be solved in O(n log n) time (or in O(n log m) time if the jobs are pre-sorted) as proved by Sahni [18]. For the uniform machines, Sahni and Cho [19] give an algorithm for problem Q|r ( j), pmtn|C max that requires O(mn + n log n) time (or O(mn) time if the jobs are pre-sorted). Prior to our work on the links between submodular optimization and scheduling with controllable processing times [27], no purpose-built algorithms have been known for problems α|r ( j), p( j) = p( j) − x( j), pmtn, C( j) ≤ d|W with α ∈ {P, Q}. It is shown in [27] that the bicriteria problems αm|r ( j), p( j) = p( j) − x( j), pmtn| (C max , W ) can be solved in O n 2 log m time and in O(n 2 m) time for α = P and α = Q, respectively. Since a solution to a single criterion problem αm|r ( j), p( j) = p( j) − x( j), pmtn, C( j) ≤ d|W is contained among the Pareto optimal solutions for the corresponding bicriteria problem αm|r ( j), p( j) = p( j) − x( j), pmtn| (C max , W ), the algorithms from [27] are quoted in Table 1 as the best previously known for the single criterion problems with controllable processing times.
The main purpose of this paper is to demonstrate that the single criterion scheduling problems with controllable processing times to minimize the total compression cost can be solved by faster algorithms that are based on reformulation of these problems in terms of a linear programming problem over a submodular polyhedron intersected with a box. For the latter generic problem, we develop a recursive decomposition algorithm and show that for the scheduling applications it can be implemented in a very efficient way.
problem for which the set of constraints is a submodular polyhedron intersected with a box. Being quite general, the problem represents a range of scheduling models with controllable processing times. In Sect. 3.2 we give the details of the corresponding reformulations.

Preliminaries on submodular polyhedra
For a positive integer n, let N = {1, 2, . . . , n} be a ground set, and let 2 N denote the family of all subsets of N . For a subset X ⊆ N , let R X denote the set of all vectors p with real components p( j), where j ∈ X . For two vectors p = )) ∈ R N , we write p ≤ q if p( j) ≤ q( j) for each j ∈ N . Given a set X ⊆ R N , a vector p ∈ X is called maximal in X if there exists no vector q ∈ X such that p ≤ q and p = q. For a vector p ∈ R N , define p(X ) = j∈X p( j) for every set X ∈ 2 N .
A set function ϕ : 2 N → R is called submodular if the inequality holds for all sets X, Y ∈ 2 N . For a submodular function ϕ defined on 2 N such that ϕ(∅) = 0, the pair (2 N , ϕ) is called a submodular system on N , while ϕ is referred to as the rank function of that system. For a submodular system (2 N , ϕ), define two polyhedra called the submodular polyhedron and the base polyhedron, respectively, associated with the submodular system. Notice that B(ϕ) represents the set of all maximal vectors in P(ϕ).
The main problem that we consider in this section is as follows: where ϕ : 2 N → R is a submodular function with ϕ(∅) = 0, w ∈ R N + is a nonnegative weight vector, and p, p ∈ R N are upper and lower bound vectors, respectively. This problem serves as a mathematical model for many scheduling problems with controllable processing times. Problem (LP) can be classified as a problem of maximizing a linear function over a submodular polyhedron intersected with a box.
In our previous work [25], we have demonstrated that Problem (LP) can be reduced to optimization over a simpler structure, namely, over a base polyhedron. In fact, we have shown that a problem of maximizing a linear function over the intersection of a submodular polyhedron and a box is equivalent to maximizing the same objective function over a base polyhedron associated with another rank function.
Notice that the computation of the valueφ(X ) for a given X ∈ 2 N reduces to minimization of a submodular function, which can be computed in polynomial time by using any of the available algorithms for minimizing a submodular function [7,20]. However, the running time of known algorithms is fairly large. In many special cases of Problem (LP), including its applications to scheduling problems with controllable processing times, the valueφ(X ) can be computed more efficiently without using the submodular function minimization, as shown later.
Throughout this paper, we assume that Problem (LP) has a feasible solution, which, due to claim (i) of Theorem 1, is equivalent to the conditions p ∈ P(ϕ) and p ≤ p. Claim (ii) of Theorem 1 implies that Problem (LP) reduces to the following problem: where the rank functionφ : 2 N → R is given by (5).
An advantage of the reduction of Problem (LP) to a problem of the form (6) is that the solution vector can be obtained essentially in a closed form, as stated in the theorem below.
Theorem 2 (cf. [4]) Let j 1 , j 2 , . . . , j n be an ordering of elements in N that satisfies Then, vector p * ∈ R N given by is an optimal solution to the problem (6) [and also to the problem (4)].
This theorem immediately implies a simple algorithm for Problem (LP), which computes an optimal solution p * by determining the valueφ({ j 1 , j 2 , . . . , j h }) for each h = 1, 2, . . . , n. In this paper, instead, we use a different algorithm based on decomposition approach to achieve better running times for special cases of Problem (LP), as explained in Sect. 4.

Rank functions for scheduling applications
In this subsection, we follow [27] and present reformulations of three scheduling problems on parallel machines with controllable processing times in terms of LP problems defined over a submodular polyhedron intersected with a box of the form (4). We assume that if the jobs have different release dates, they are numbered to satisfy If the machines are uniform they are numbered in accordance with (1). We denote S k represents the total speed of k fastest machines; if the machines are identical, such that all jobs can be completed by a common due date d and the total compression cost W = j∈N w( j)x( j) is minimized. In what follows, we present LP formulations of these problems with p( j), j ∈ N , being decision variables, and the objective function to be maximized being ). Since each decision variable p( j) has a lower bound p( j) and an upper bound p( j), an LP formulation includes the box constraints of the form The derivations of the rank functions for the models under consideration can be justified by the conditions for the existence of a feasible schedule for a given common deadline d formulated, e.g., in [1]. Informally, these conditions state that for a given deadline d a feasible schedule exists if and only if (i) for each k, 1 ≤ k ≤ m − 1, k longest jobs can be processed on k fastest machines by time d, and (ii) all n jobs can be completed on all m machines by time d.
We refer to [27] where the rank functions for the relevant problems are presented and discussed in more details. Below we present their definitions. In all scheduling applications a meaningful interpretation of ϕ(X ) is the largest capacity available for processing the jobs of set X .
For example, problem Q| p( j) = p( j) − x( j), C( j) ≤ d, pmtn|W reduces to Problem (LP) of the form (4) with the rank function It is clear that the conditions p(X ) ≤ ϕ(X ), X ∈ 2 N , for the function ϕ(X ) defined by (11) correspond to the conditions (i) and (ii) above, provided that |X | ≤ m − 1 and |X | ≥ m, respectively. As proved in [24], function ϕ is submodular.
We then consider problem For a set of jobs X ⊆ N , we define r i (X ) to be the i-th smallest release date in set X ∈ 2 N , 1 ≤ i ≤ |X |. Then, for a non-empty set X of jobs, the largest processing capacity available on the fastest machine M 1 is s 1 (d − r 1 (X )), the total largest processing capacity on two fastest machines M 1 and M 2 is It can be verified that this function is submodular.
Hence, the corresponding rank function ϕ can be simplified as

Decomposition of LP problems with submodular constraints
In this section, we describe a decomposition algorithm for solving LP problems defined over a submodular polyhedron intersected with a box. In Sect. 4.1, we demonstrate that the linear programming problem under study can be recursively decomposed into subproblems of a smaller dimension, with some components of a solution vector fixed to one of their bounds. We provide an outline of an efficient recursive decomposition procedure in Sect. 4.2 and analyze its time complexity in Sect. 4.3. In Sect. 5 we present implementation details of the recursive decomposition procedure for the relevant scheduling models with controllable processing times.

Fundamental idea for decomposition
In this section, we show an important property, which makes the foundation of our decomposition algorithm for Problem (LP) of the form (4). The lemma below demonstrates that some components of an optimal solution can be fixed either at their upper or lower bounds, while for some components their sum is fixed. Given a subsetN of N , we say thatN is a heavy-element subset of N with respect to the weight vector w if it satisfies the condition For completeness, we also regard the empty set as a heavy-element subset of N .
Given Problem (LP), in accordance with (5) define a set Y * ⊆ N such that the equalityφ holds for a set X ⊆ N . Because of its special role, in the remainder of this paper we call Y * an instrumental set for set X .

Lemma 1
LetN ⊆ N be a heavy-element subset of N with respect to w, and Y * ⊆ N be an instrumental set for setN . Then, there exists an optimal solution p * of Problem (LP) such that Proof SinceN is a heavy-element subset, there exists an ordering j 1 , j 2 , . . . , j n of elements in N that satisfies (7) Theorems 1 and 2 guarantee that the solution p * given by (8) is optimal. In particular, this implies Since p * is a feasible solution of Problem (LP), the following conditions simultaneously hold: On the other hand, due to the choice of set Y * we have which implies that each inequality of (15) must hold as equality, and that is equivalent to the properties (a), (b), and (c) in the lemma.
In what follows, we use two fundamental operations on a submodular system 2 N , ϕ , as defined in [4, Section 3.1]. For a set A ∈ 2 N , define a set function Then, (2 A , ϕ A ) is a submodular system on A and it is called a restriction of (2 N , ϕ) to A. On the other hand, for a set A ∈ 2 N define a set function ϕ A : 2 N \A → R by Then, (2 N \A , ϕ A ) is a submodular system on N \A and it is called a contraction of (2 N , ϕ) by A.
For an arbitrary set A ∈ 2 N , Problem (LP) can be decomposed into two subproblems of a similar structure by performing restriction of 2 N , ϕ to A and contraction of 2 N , ϕ by A, respectively. These problems can be written as follows: for restriction as and for contraction as We show that an optimal solution of the original Problem (LP) can be easily restored from the optimal solutions of these two subproblems. For every subset A ⊆ N and vectors p 1 ∈ R A and p 2 ∈ R N \A , the direct sum p 1 ⊕ p 2 ∈ R N of p 1 and p 2 is defined by Lemma 2 Let A ∈ 2 N , and suppose that q(A) = ϕ(A) holds for some optimal solution q ∈ R N of Problem (LP). Then,

(i) Each of problems (LP1) and (LP2) has a feasible solution.
(ii) If a vector p 1 ∈ R A is an optimal solution of Problem (LP1) and a vector p 2 ∈ R N \A is an optimal solution of Problem (LP2), then the direct sum p * = p 1 ⊕p 2 ∈ R N of p 1 and p 2 is an optimal solution of Problem (LP).
Proof The proof below is similar to that for Lemma 3.1 in [4]. We define vectors q 1 ∈ R A and q 2 ∈ R N \A by To prove (i), it suffices to show that q 1 and q 2 are feasible solutions of Problems (LP1) and (LP2), respectively. Since q is a feasible solution of Problem (LP), we have Then, (16) and (17) imply that q 1 ∈ R A is a feasible solution of Problem (LP1). It follows from (16) and the equality q(A) = ϕ(A) that which, together with (17), implies that q 2 ∈ R N \A is a feasible solution of Problem (LP2). This concludes the proof of (i).
To prove (ii), we first show that p * is a feasible solution of Problem (LP). Since p 1 and p 2 are feasible solutions of Problem (LP1) and Problem (LP2), respectively, we have For any X ∈ 2 N , we derive where the first inequality is by (18) and (19), and the second by the submodularity of ϕ. This inequality and (20) show that the vector p * is a feasible solution of (LP).
To show optimality of p * , notice that by optimality of p 1 and p 2 we have and due to the definition of p * we obtain so that, p * is an optimal solution of (LP).
From Lemmas 1 and 2, we obtain the following property, which is used recursively in our decomposition algorithm.

Theorem 3
LetN ⊆ N be a heavy-element subset of N with respect to w, and Y * be an instrumental set for setN . Let p 1 ∈ R Y * and p 2 ∈ R N \Y * be optimal solutions of the linear programs (LPR) and (LPC), respectively, where (LPR) and (LPC) are given as Then, the vector p * ∈ R N given by the direct sum p * = p 1 ⊕ p 2 is an optimal solution of (LP).
Notice that Problem (LPR) is obtained from Problem (LP) as a result of restriction to Y * and the values of components p( j), j ∈ Y * \N , are fixed to their lower bounds in accordance with Property (c) of Lemma 1. Similarly, Problem (LPC) is obtained from Problem (LP) as a result of contraction by Y * and the values of components p( j), j ∈N \Y * , are fixed to their upper bounds in accordance with Property (b) of Lemma 1.

Recursive decomposition procedure
In this subsection, we describe how the original Problem (LP) can be decomposed recursively based on Theorem 3, until we obtain a collection of trivially solvable problems with no non-fixed variables. In each stage of this process, the current LP problem is decomposed into two subproblems, each with a reduced set of variables, while some of the original variables receive fixed values and stay fixed until the end.

Remark 1
The definition of a heavy-element set can be revised to take into account the fact that some variables may become fixed during the solution process. The fixed variables make a fixed contribution into the objective function, so that the values of their weights become irrelevant for further consideration and can therefore be made, e.g., zero. This means that a heavy-element set can be selected not among all variables of set N but only among the non-fixed variables. Formally, if the set N of jobs is known to be partitioned as N = Q ∪ F, where the variables of set Q are non-fixed and those of set F are fixed, thenQ ⊆ Q is a heavy-element subset with respect to the weight vector w if it satisfies the condition Notice that for this refined definition of a heavy-element subset, Lemma 1 and Theorem 3 can be appropriately adjusted.
In each stage of the recursive procedure, we need to solve a subproblem that can be written in the following generic form: where -H ⊆ N is the index set of components of vector p; -F ⊆ H is the index set of fixed components, i.e., l( j) = u( j) holds for each j ∈ F; -K ⊆ N \H is the set that defines the rank function ϕ H Throughout this paper, we assume that each Problem LP(H, F, K , l, u) is feasible. This is guaranteed by Lemma 2 if the initial Problem (LP) is feasible.
The original Problem (LP) is represented as Problem LP(N , ∅, ∅, p, p). For j ∈ H , we say that the variable p( j) is a non-fixed variable if l( j) < u( j) holds, and a fixed variable if l( j) = u( j) holds. If all the variables in Problem LP(H, F, K , l, u) are fixed, i.e., l( j) = u( j) holds for all j ∈ H , then an optimal solution is uniquely determined by the vector u ∈ R H .
Consider a general case that Problem LP(H, F, K , l, u) of the form (21) contains at least one non-fixed variable, i.e., |H \F| > 0. We define a function ϕ H By Theorem 1 (ii), the set of maximal feasible solutions of Problem LP (H, F, K , l, u) is given as a base polyhedron B( ϕ H K ) associated with the function ϕ H K . Therefore, if |H \F| = 1 and H \F = { j }, then an optimal solution p * ∈ R H is given by Suppose that |H \F| ≥ 2. Then, we call a procedure Procedure Decomp(H, F, K , l, u) explained below. LetĤ ⊆ H \F be a heavy-element subset of H with respect to the vector (w( j) | j ∈ H ), and Y * ⊆ H be an instrumental set for setĤ , i.e., Theorem 3, when applied to Problem LP (H, F, K , l, u), implies that the problem is decomposed into the two subproblems The first of these subproblems corresponds to Problem (LPR), and in that problem the values of components p( j), j ∈ Y * \Ĥ , are fixed to their lower bounds. The second subproblem corresponds to Problem (LPC), and in that problem the values of components p( j), j ∈Ĥ \Y * , are fixed to their upper bounds.
We denote these subproblems by Problem LP(Y * , F 1 , K , l 1 , u 1 ) and Problem LP(H \Y * , F 2 , K ∪ Y * , l 2 , u 2 ), respectively, where the vectors l 1 , u 1 ∈ R Y * and l 2 , u 2 ∈ R H \Y * , and the updated sets of fixed variables F 1 and F 2 are given by Notice that Problem LP(Y * , F 1 , K , l 1 , u 1 ) inherits the set of fixed variables Y * ∩ F from the problem of a higher level, and additionally the variables of set Y * \Ĥ become fixed. However, sinceĤ contains only non-fixed variables, we deduce that Y * \Ĥ ⊇ Y * ∩ F, so that the complete description of the set F 1 of fixed variables in Problem LP(Y * , F 1 , K , l 1 , u 1 ) is given by Y * \Ĥ .
Problem LP(H \Y * , F 2 , K ∪Y * , l 2 , u 2 ) inherits the set of fixed variables (H \Y * )∩ F from the problem of a higher level, and additionally the variables of setĤ \Y * become fixed. These two sets are disjoint. Thus, the complete description of the set F 2 of fixed variables in Problem LP(H \Y * , F 2 , K , l 2 , u 2 ) is given by (Ĥ ∪ (H ∩ F))\Y * .
Without going into implementation details, we now give a formal description of the recursive procedure, that takes Remark 1 into account. For the current Problem LP (H, F, K , l, u), we compute optimal solutions p 1 ∈ R Y * and p 2 ∈ R H \Y * of the two subproblems by calling procedures Decomp(Y * , F 1 , K , l 1 , u 1 ) and Decomp(H \Y * , F 2 , K ∪ Y * , l 2 , u 2 ). By Theorem 3, the direct sum p * = p 1 ⊕ p 2 is an optimal solution of Problem LP(H, F, K , l, u), which is the output of the procedure Decomp(H, F, K , l, u).
If |H \F| = 1 and H \F = { j }, then compute the valueφ H K ({ j }), and output the vector p * given by (23) and return.
Step 2. Select a heavy-element subsetĤ of H \F with respect to w, and determine an instrumental set Y * ⊆ H for setĤ satisfying (24). Step 3. Define the vectors l 1 , u 1 ∈ R Y * and set F 1 by (25).
Step 5. Output the direct sum p * = p 1 ⊕ p 2 ∈ R H and return.
Recall that the original Problem (LP) is solved by calling Procedure  Decomp(N , ∅, ∅, p, p). Its actual running time depends on the choice of a heavyelement subsetĤ in Step 2 and on the time complexity of finding an instrumental set Y * .

Analysis of time complexity
We analyze the time complexity of Procedure Decomp. To reduce the depth of recursion of the procedure, it makes sense to perform decomposition in such a way that the number of non-fixed variables in each of the two emerging subproblems is roughly a half of the number of non-fixed variables in the current Problem LP (H, F, K , l, u) H, F, K , l, u), let g = |H \F| denote the number of the nonfixed variables. In Step 2 Procedure Decomp(H, F, K , l, u) selects a heavy-element subsetĤ ⊂ H \F that contains g/2 non-fixed variables, i.e., |Ĥ | = g/2 . Then, the number of the non-fixed variables in Problem LP(Y * , F 1 , K , l 1 , u 1 ) considered in Step 3 satisfies |Y * ∩Ĥ | ≤ g/2 .
Due to (26), the number of non-fixed variables in Problem LP(H \Y * , F 2 , K ∪ Y * , l 2 , u 2 ) considered in Step 4 satisfies This lemma implies that the overall depth of recursion of Procedure Decomp applied to Problem LP(N , ∅, ∅, p, p) is O(log n).
Let us analyze the running time of Procedure Decomp applied to Problem LP(H, F, K , l, u). We denote by T LP (h, g) the time complexity of Procedure Decomp (H, F, K , l, u), where h = |H | and g = |H \F|. Let T Y * (h) denote the running time for computing the value ϕ H K (Ĥ ) for a given setĤ ⊆ H and finding an instrumental set Y * that minimizes the right-hand side of the Eq. (22). In Steps 3 and 4, Procedure Decomp splits Problem LP(H, F, K , l, u) into two subproblems: one with h 1 variables among which there exist g 1 ≤ min{h 1 , g/2 } non-fixed variables, and the other one with h 2 = h − h 1 variables, among which there exist g 2 ≤ min{h 2 , g/2 } non-fixed variables. Let T Split (h) denote the time complexity of such a decomposition, i.e., for setting up the instances of the two subproblems. A required heavy-element set can be found in O(h) time by using a linear-time median-finding algorithm. Then, we obtain a recursive equation: By solving the recursive equation under an assumption that both functions T Y * (h) and T Split (h) are non-decreasing and convex, we obtain Thus, the findings of this section can be summarized as the following statement.

Theorem 4 Problem (LP) can be solved by Procedure Decomp in O((T Y * (n) + T Split (n)) log n) time.
In the forthcoming discussion of three scheduling applications of the results of this section, we pay special attention to designing fast algorithms that could find the required set Y * in all levels of the recursive Procedure Decomp. We develop fast algorithms that compute the value ϕ(Ĥ ) and find a set Y * in accordance with its definition; see Sect. 5.

Comparison with decomposition algorithm for maximizing a concave separable function
In this subsection, we refer to our decomposition algorithm for Problem (LP) defined over a submodular polyhedron intersected with a box as Algorithm SSS-Decomp. Below, we compare that algorithm with a known decomposition algorithm that is applicable for maximizing a separable concave function over a submodular polyhedron; see [3], [4, Sect. 8.2] and [6]. Consider the problem of maximizing a separable concave function over a submodular polyhedron: where f j : R → R is a univariate concave function for j ∈ N and ϕ : 2 N → R is a submodular function with ϕ(∅) = 0.
The decomposition algorithm for Problem (SCFM) was first proposed by Fujishige [3] for the special case where each f j is quadratic and ϕ is a polymatroid rank function. Groenevelt [6] then generalized the decomposition algorithm for the case where each f j is a general concave function and ϕ is a polymatroid rank function. Later, it was pointed out by Fujishige [4, Sect. 8.2] that the decomposition algorithm in [6] can be further generalized to the case where ϕ is a general submodular function. We refer to that algorithm as Algorithm FG-Decomp.
For simplicity of presentation, in the description of Algorithm FG-Decomp we assume that each f j is monotone increasing; the general case with non-monotone f j can be dealt with by an appropriate modification of the algorithm; see [6].

Algorithm FG-Decomp
Step 1. Find an optimal solution q ∈ R N of the following "relaxed" problem with a single constraint: Note: since f j is monotone it follows that q(N ) = ϕ(N ).
Step 2. Find a maximal vector q ∈ R N satisfying the following condition: Step 3. Find a (unique) maximal set Y * ⊆ N such that ϕ(Y * ) = q (Y * ).
Step 4. If Y * = N , then output the vector q and stop. Otherwise, go to Step 5.
Step 5. Find an optimal solution p 1 ∈ R Y * of the following problem: Maximize Step 6. Find an optimal solution p 2 ∈ R N \Y * of the following problem: Maximize Step 7. Output the direct sum p * = p 1 ⊕ p 2 ∈ R N and stop.
It is easy to see that Problem (LP) can be reduced to Problem (SCFM) by setting the functions f j as with a sufficiently large positive number M. Thus, Algorithm FG-Decomp (appropriately adjusted to deal with non-monotone functions f j ) can be applied to solving Problem (LP).
For Problem (LP), Algorithm FG-Decomp is quite similar to Algorithm SSS-Decomp. Indeed, both algorithms recursively find a set Y * and decompose a problem into two subproblems by using restriction to Y * and contraction by Y * .
The difference of the two decomposition algorithms is in the selection rule of a set Y * . In fact, a numerical example can be provided that demonstrates that for the same instance of Problem (LP) the two decomposition algorithms may find different sets Y * in the same iteration.
In addition, Algorithm SSS-Decomp fixes some variables in the subproblems so that the number of non-fixed variables in each subproblem is at most the half of the non-fixed variables in the original problem; this is an important feature of our algorithm which is not enjoyed by Algorithm FG-Decomp. This difference affects the efficiency of the two decomposition algorithms; indeed, for Problem (LP) the height of the decomposition tree can be Θ(n) if Algorithm FG-Decomp is used, while it is O(log n) in our Algorithm SSS-Decomp.
Thus, despite certain similarity between the two decomposition algorithms, our algorithm cannot be seen as a straightforward adaptation of Algorithm FG-Decomp designed for solving problems of non-linear optimization with submodular constraints to a less general problem of linear programming.
On the other hand, assume that the feasible region for Problem (SCFM) is additionally restricted by imposing the box constraints, similar to those used in Problem (LP). Theorem 1 can be used to reduce the resulting problem to Problem (SCFM) with a feasible region being the base polyhedron with a modified rank function. Although the obtained problem can be solved by Algorithm FG-Decomp, this approach is computationally inefficient, since it requires multiple calls to a procedure for minimizing a submodular function. It is more efficient not to rely on Theorem 1, but to handle the additional box constraints by adapting the objective function, similarly to (27), and then to use Algorithm FG-Decomp.

Application to parallel machine scheduling problems
In this section, we show how the decomposition algorithm based on Procedure Decomp can be adapted for solving problems with parallel machines efficiently. Before considering implementation details that are individual for each scheduling problem under consideration, we start this section with a discussion that addresses the matters that are common to all three problems.
Recall that each scheduling problem we study in this paper can be formulated as Problem (LP) of the form (4) with an appropriate rank function. Thus, each of these problems can be solved by the decomposition algorithm described in Sect. 4.2 applied to Problem LP (N , ∅, ∅, l, u), where l = p and u = p.
For an initial Problem LP(N , ∅, ∅, l, u), we assume that the following preprocessing is done before calling Procedure Decomp(N , ∅, ∅, l, u): 1. If required, the jobs are numbered in non-decreasing order of their release dates in accordance with (9). 2. If required, the machines are numbered in non-increasing order of their speeds in accordance with (1), and the partial sums S v are computed for all v, 0 ≤ v ≤ m, by (10). 3. The lists (l( j) | j ∈ N ) and (u( j) | j ∈ N ) are formed and their elements are sorted in non-decreasing order.
The required preprocessing takes O(n log n) time.
To adapt the generic Procedure Decomp to solving a particular scheduling problem, we only need to provide the implementation details for Procedure Decomp (H, F, K , l, u) that emerges at a certain level of recursion. To be precise, we need to explain how to compute for each particular problem the function ϕ H K (X ) for a chosen set X ∈ 2 H and how to find for a current heavy-element set an instrumental set Y * defined by (22), which determines the pair of problems into which the current problem is decomposed.
Given Problem LP (H, F, K , l, it follows that for a given set X ⊆ H the function ϕ H K : 2 H → R can be computed as follows: where ϕ is the initial rank function associated with the scheduling problem under consideration, and Notice that if the minimum in the left-hand side of (30) is achieved for Y = Y * , then Y * is an instrumental set for set X .

Uniform machines, equal release dates
In this subsection, we show that problem Q| p( j) = p( j) − x( j), C( j) ≤ d, pmtn|W can be solved in O(n log n) time by the decomposition algorithm. To achieve this, we consider Problem LP(H, F, K , l, u) that arises at some level of recursion of Procedure Decomp and present a procedure for computing the function ϕ H K : 2 H → R given by (22). We show that for an arbitrary set X ⊆ H the value ϕ H K (X ) can be computed in O(h) time. For a heavy-element setĤ ⊆ H \F, finding a set Y * that is instrumental for setĤ also requires O(h) time.
Recall that for problem Q| p( j) = p( j) − x( j), C( j) ≤ d, pmtn|W the rank function ϕ : 2 N → R is defined by (11), i.e., This, together with (30), implies The computation of the minimum in the last term in (32) is done differently for the sets Y ⊆ H with |Y | ≤ĥ and with |Y | >ĥ, whereĥ is defined by (29), provided that the corresponding sets exist. and Then, we can rewrite the last term in (32) as Notice that Φ = +∞ corresponds to the case that the set Y ∈ H v does not exist for We then assume h > m − k − 1. Since λ( j) ≥ 0 for j ∈ H , the maximum in the right-hand side of the top line of (34) is achieved for Y = H , i.e., Below we describe the procedure that uses Eqs. (35) and (36) for computing the values Φ and Φ . Since the procedure will be used as a subroutine within the recursive Procedure Decomp, here we present it for computing ϕ H K (X ) with X being a heavyelement setĤ . Besides, its output contains set Y * , an instrumental set for setĤ .

Procedure CompQr0
Input: Problem LP(H, F, K , l, u), a heavy-element setĤ ⊆ H \F, the values of h, k andĥ defined by (29), and the list (λ( j) | j ∈ H ) computed by (31) with respect to X =Ĥ . Output: the value of function ϕ H K (X ) and an instrumental set Y * for set X =Ĥ . Step 1. If k ≥ m, then set Φ := +∞ and go to Step 3.
Step 2-2. Compute the value Φ by using (35). In the analysis of the time complexity of Procedure CompQr0, we assume that certain information is given as part of the input. This assumption can be satisfied by an appropriate preprocessing. In particular, when we decompose a problem with a set of job H at a certain level of recursion into two subproblems, we may create the sorted lists (u( j) | j ∈ H ) and (l( j) | j ∈ H ). This can be done in O(h) time, since the sorted lists (u( j) | j ∈ N ) and (l( j) | j ∈ N ) are available as a result of the initial preprocessing. Thus, we have that T Split (h) = O(h). Hence, the theorem follows from Theorem 4.

Identical machines, different release dates
In this subsection, we show that problem P|r ( j), p( j) = p( j) − x( j), C( j) ≤ d, pmtn|W can be solved in O(n log m log n) time by the decomposition algorithm. To achieve this, we consider Problem LP (H, F, K , l, u) that arises at some level of recursion of Procedure Decomp and present a procedure for computing the function ϕ H K : 2 H → R given by (22). We show that for an arbitrary set X ⊆ H the value ϕ H K (X ) can be computed in O(h log m) time. For a heavy-element setĤ ⊆ H \F, finding a set Y * that is instrumental for setĤ also requires O(h log m) time.
Recall that for problem P|r ( j), p( j) = p( j) − x( j), C( j) ≤ d, pmtn|W the rank function ϕ : 2 N → R is defined by (13), i.e., where r i (X ) denotes the i-th smallest release dates among the jobs of set X. This, together with (30), implies that where λ( j), j ∈ H, are given by (31). Letĥ be defined by (29). Computation of the minimum in the last term in (37) is done differently for sets Y ⊆ H with |Y | ≤ĥ and |Y | >ĥ. and Similarly to Sect. 5.1, the values Φ and Φ are responsible for computing the minimum in the last term in (37) over the sets Y ⊆ H with |Y | ≤ĥ and with |Y | >ĥ, respectively, provided that the corresponding sets exist. Thus, (37) can be rewritten as We now explain how to compute the values Φ and Φ . From the list ( λ( j) | j ∈ H ), where Suppose that m > k. Computing of Φ can be done in a similar manner as in Sect. 5.1. The top line of the formula (38) can be rewritten as For v, 1 ≤ v ≤ĥ, let λ v be the v-th largest value among the numbers λ( j), j ∈ H . Then, we have We now turn to computing the value Φ . We may assumeĥ < h, i.e., h > m −k −1, since otherwise Φ = +∞. For simplicity of the description, we assume, without loss of generality, that the jobs of set H ∪ K are renumbered in such a way that For t = m, m + 1, . . . , h + k, introduce The following lemma is useful for computing the value Φ efficiently.

Lemma 4 Let Y ∈ 2 H be a set satisfying |Y | >ĥ and
Let t * ∈ H ∪ K be a job such that m ≤ t * ≤t and the set { j ∈ Y ∪ K | j ≤ t * } contains exactly m elements. Define the sets Then the following properties hold: Proof First, notice that set Y ∪ K contains at leastĥ + 1 + k ≥ m jobs, so that job t * exists and m ≤ t * ≤ h + k. Notice that job t * might belong to set H \Y , and that job t * is not necessarily unique. Indeed, if, e.g., job t * + 1 ∈ H \Y , then We need to show that there exists a t * that satisfies t * ≤t. To prove this, we only need to consider the case that k ≥ m, since otherwise by definitiont = h + k. For k ≥ m, let t * be the smallest value of t such that the equality |{ j ∈ Y ∪ K | j ≤ t}| = m holds. Since |{ j ∈ K | j ≤ t * }| ≤ m, we have t * ≤t by the definition oft.
Take a t * that satisfies the lemma conditions. For an arbitrarily chosen set i.e., property (i) holds.
Since λ( j) ≥ 0 for j ∈ H , we should include all jobs j ∈ H with j > t * into set Y 2 to achieve the maximum in (45), i.e., property (iii) holds.
For each t, m ≤ t ≤t, define We see from Lemma 4 that Notice that Thus, we have Lemma 5 Let t be an integer with m < t ≤t.

(i) Given the values ρ[t − 1] and η 2 [t − 1], ρ[t] and η 2 [t] can be obtained as
can be obtained as (51) Below we describe the procedure that uses Eqs. (42) and (47) for computing the values Φ and Φ . As in Sect. 5.1, the procedure outputs ϕ H K (X ) for X =Ĥ and an instrumental set Y * for setĤ .

Procedure CompPrj
Input: Problem LP(H, F, K , l, u), a heavy-element setĤ ⊆ H \F, the values of h, k andĥ defined by (29), the lists (λ( j) | j ∈ H ) and λ( j) | j ∈ H computed by (31) with respect to X =Ĥ and by ( 41), and the non-decreasing lists (r ( j) | j ∈ H ) and (r ( j) | j ∈ K ). Output: the value of function ϕ H K (X ) and an instrumental set Y * for set X =Ĥ .
then define Y to be the set of jobs in H that correspond to the values λ 1 , λ 2 , . . . , λ v .
Step 4-5. Perform Step 4-3 again, breaking the loop after t exceeds t * , i.e., after the value η 1 [t * ] is computed. With the found set Q, define the sets Step 5. Compute the value ϕ H K (X ) by (40) applied to X =Ĥ . If Φ < Φ , define Y * := Y ; otherwise, define Y * := Y . In Steps 3 and 4 we compute the value Φ and find set Y .
Step 3 can be also done in constant time. We assume that both (r ( j) | j ∈ H ) and (r ( j) | j ∈ K ) are given as sorted lists; this can be easily satisfied by appropriate preprocessing. Then, In the rest of this subsection, we show that a slightly modified version of Procedure CompPrj can also be run in O(h log m) time for h < k.
First, consider the case that h ≥ m. Then, we have k > h ≥ m. Let K m be a set of m jobs in K with m smallest release dates. It is easy to see that the jobs in K \K m do not affect the values r i (K ) and r i (Y ∪ K ), i.e., it holds that It follows that in the formula (37) for ϕ H K (X ), the value in the right-hand side remains the same even if we replace K and k with K m and m, respectively. Making the same replacement in Procedure CompPrj, we deduce that it will run in O((h + m) log m) = O(h log m) time, provided that set K m is given in advance.
We finally consider the case that h < m. From the discussion above, we may assume that k ≤ m. For any Y ∈ 2 H , the contribution of the release dates into the right-hand side of (37) is equal to . Let k = m − h and K be the set of jobs in K with k smallest release dates among r ( j), j ∈ K . Since |Y | ≤ h < m, each of the values r ( j), j ∈ K , contributes to the sum Thus, in formula (37), the value in the right-hand side remains the same if we replace K and k with K \K and k − k , respectively. Making the same replacement in Procedure CompPrj, we deduce that it will run in O((h + k − k ) log m) time, provided that the set K \K is given in advance.
We are now ready to prove the main statement regarding problem P|r ( j), p( j) = p( j) − x( j), C( j) ≤ d, pmtn|W . In the analysis of the time complexity of Procedure CompPrj, we assume that certain information is given as part of the input. This assumption can be satisfied by an appropriate preprocessing, when we decompose a problem at a certain level of recursion into two subproblems, based on the found set Y * . It is not hard to see that this can be done in O(h log m) time, i.e., we have T Split (h) = O(h log m). Hence, the theorem follows from Theorem 4.

Uniform machines, different release dates
In this subsection, we show that problem Q|r ( j), p( j) = p( j) − x( j), C( j) ≤ d, pmtn|W can be solved in O(nm log n) time by the decomposition algorithm. To achieve this, we consider Problem LP(H, F, K , l, u) that arises at some level of recursion of Procedure Decomp and present a procedure for computing the function ϕ H K : 2 H → R given by (22). We show that for an arbitrary set X ⊆ H the value ϕ H K (X ) can be computed in O(hm) time. For a heavy-element setĤ ⊆ H \F, finding a set Y * that is instrumental for setĤ also requires O(hm) time.
Recall that for problem Q|r ( j), p( j) = p( j) − x( j), C( j) ≤ d, pmtn|W the rank function ϕ : 2 N → R is defined by (12), i.e., where r i (X ) denotes the i-th smallest release dates among the jobs of set X . This, together with (30), implies that where λ( j), j ∈ H, are given by (31). Letĥ be defined by (29). Computation of the minimum in the last term in (52) is done differently for sets Y ⊆ H with |Y | ≤ĥ and |Y | >ĥ. and Thus, (52) can be rewritten as We explain how to compute the values Φ and Φ . As in Sect. 5.2, for simplicity of the description, we assume, without loss of generality, that the jobs are renumbered so that (43) holds.
In order to compute Φ , for v and t such that 0 ≤ v ≤ĥ and Notice that all k jobs of set K and v jobs of can be computed by a dynamic programming algorithm. Assume that for the current numbering of the jobs in H ∪ K , the jobs in set K get the numbers j 1 , j 2 , . . . , j k , so that r ( j 1 ) ≤ · · · ≤ r ( j k ).
For v = 0, notice that H 0 [t] = {∅}, so that in accordance with (56) we compute Given a job t ∈ H , let us determine the position of job t relative to the jobs of set K . If r (t) > r ( j k ), then define t = k + 1; otherwise, set t to be equal to such that for job j ∈ K we have that j −1 < t < j . The values of t can be found for all t ∈ H in O(h + k) time by scanning the sorted sequence of jobs of set H ∪ K .
For some t ∈ H and v, 1 ≤ v ≤ĥ, assume that we have found the value , then job t has the largest release date among the jobs of setȲ ∪ K ∪{t}, so that If ≤ k, then among jobs j ∈Ȳ ∪ K such that j ≤ j , there are v − 1 jobs of set H and jobs of set K , i.e., job j has the ( + v − 1) −th smallest release date inȲ ∪ K . We deduce that the total contribution of the jobs j , j +1 , . . . , For computing ξ v [t], we need to find a setȲ + ∈ H v [t] such that Otherwise, it is sought in the sets obtained from sets of H v−1 [t − 1] by including job t. In the latter case, setȲ + can be found based on setȲ and on those changes that are caused by the insertion of job t. As a result of this insertion, job t has the ( + v − 1) −th smallest release date inȲ ∪ K ∪ {t}, so that it will contribute s +v−1 r (t) + λ(t) into ξ v [t]. Notice that all jobs of set K continue making contributions, since v < m − k.
We now consider the value Φ . It is assumed thatĥ < h, i.e., h + k ≥ m. Suppose that we know the set Y ∈ 2 H such that |Y | >ĥ and Similarly to Sect. 5.2, for t, 1 ≤ t ≤ h + k, introduce sets K [t] and H z [t] of the form (44). Let t * ∈ H ∪ K be the job such that the set { j ∈ Y ∪ K | j ≤ t * } contains exactly m elements. Since the jobs are numbered in non-decreasing order of the release dates, the set { j ∈ Y ∪ K | j ≤ t * } contains the jobs in Y ∪ K with m smallest release dates. Putting .
Thus, we should include all jobs j ∈ H with j > t * into set Y 2 to achieve the maximum in (63), i.e., we may assume For z and t, 1 ≤ z ≤ m, Provided that these values are known, we can compute Φ by Notice that for a given t, t ≥ m, the term j∈H, j>t λ( j) is identical to η 2 [t] used in Sect. 5.2 and for its computation we can use the formulae (50) with the initial condition (49).
For convenience, define λ( j) = 0 for j ∈ K . The required values of ζ z [t] can be found recursively by with the initial conditions To see why the recursion (66) works, notice that if in the expression for ζ z [t] job t ∈ H does not belong to set Y that delivers the maximum in (64), then ζ z [t] = ζ z [t −1]. Otherwise, job t ∈ H , as the job with the largest release date, will be matched with the smallest multiplier s z and will make an additional contribution of λ(t), so that ζ z [t] = ζ z−1 [t − 1] + s z r (t) + λ(t). The latter situation also occurs if t ∈ K , since in this case t ∈ K [t].
Now we are ready to present the procedure that outputs ϕ H K (X ) for X =Ĥ and an instrumental set Y * for setĤ .
The most time consuming parts of the procedure are the double loops is Steps 6 and 10, which require O ĥ (h + k) time and O(m(h + k)) time, respectively. Thus, the overall time complexity of Procedure CompQrj is O(m(h + k)).
For h ≥ k, the time complexity becomes O(mh). We can show that the bound O(mh) also applies to the case that h < k; this can be done by an approach similar to that used in Sect. 5.2. Hence, the next theorem follows from Theorem 4.

Conclusions
In this paper, we develop a decomposition recursive algorithm for maximizing a linear function over a submodular polyhedron intersected with a box. We illustrate the power of our approach by adapting the algorithm to solving three scheduling problems with controllable processing times. In these problems, it is required to find a preemptive schedule that is feasible with respect to a given deadline and minimizes total compression cost. The resulting algorithms run faster than previously known.
We intend to extend this approach to other scheduling models with controllable processing times, e.g., to a single machine with distinct release dates and deadlines. It will be interesting to identify problems, including those outside the area of scheduling, for which an adaptation of our approach is beneficial.
Although throughout the paper we assume that the processing times are real numbers from intervals p( j), p( j) , the formulated approach is applicable to the case where the processing times may only take integer values in the interval. Indeed, if all the input numbers, except for costs w( j), are given by integers, then the submodular rank function takes integer values, and the optimal solution p( j), j ∈ N , found by Procedure Decomp is integral.
which implies that the values λ 1 , λ 2 , . . . , λĥ are the largest values in the merger of the lists and Z . In order to merge these lists in O(g +ĥ logĥ) time, we find thê h−th largest element and find the sorted sequence ofĥ largest elements in these two lists. After that we compute the partial sums v i=1 λ v , 1 ≤ v ≤ĥ, in O(ĥ) time. To compute Φ and determine set Y , we perform Step 2-2, which takes O(ĥ) time.
Sinceĥ < m, we deduce that Step 2 of Procedure CompQr0 can be made to run in O(g + m log m) time. In Step 3, we need to compute λ (H ) which contributes to Φ . Notice that λ(H ) = λ(H \F) + λ (F), where λ (F) is known as part of the input. Thus, Step 3 requires O (g) time. In Step 4, to compute the rank function ϕ H K (X ) for X =Ĥ , we need the value u(Ĥ ), which can be found in O(g) time, since the heavy-element setĤ is chosen from the non-fixed variables only.
Thus, in terms of Theorem 4, the described modifications imply that T Y * (h) = O(g + m log m).
In accordance with Procedure Decomp, Problem LP(H, F, K , l, u) has to be decomposed into two subproblems with respect to a found set Y * , which is either |Y * | ≤ m − 1 or Y * = H . However, if either Y * = ∅ or Y * = H , then for one of the two emerging subproblems the set of variables will be empty. Besides, if |Y * | < m, one of the subproblems will have at most m variables and can be recursively solved in O(m log m) time by a straightforward application of the method described in Sect. 5.1. Thus, in any case we are left with exactly one non-trivial subproblem to be solved at each level of recursion. Let us show that the instance of that subproblem together with the accompanying information can be derived in O(g + m) time; in other words, that T Split (h) = O(g + m). Without loss of generality, we assume that the parameters of the generated problem are defined by (26), i.e., we deal with Problem LP H \Y * , Ĥ ∪ F \Y * , K ∪ Y * , l 2 , u 2 . Recall that the variables of setĤ \Y * become fixed and can be excluded from the list in O(g) time. We will also need O(g) time to update the sum of the processing times of the fixed variables. To obtain a new list Z we add the values u( j), j ∈Ĥ \Y * , to the old list Z , find the (m − 1)-th largest element in the resulting list and keep the elements that do not exceed that element. The new list Z will be found in O(g + m) time.
As implied by Lemma 3, the heavy-elementĤ is selected in such a way that the number of non-fixed variables is reduced by half in each new level of recursion, i.e., it is n in the initial level 0, at most n/2 in the next level 1, at most n/4 in level 2, etc. Thus, the running time of the modified algorithm for solving problem Q| p( j) = p( j) − x( j), C( j) ≤ d, pmtn|W is at most