Paper deep dive
Scheduling with Time Dependent Utilities: Fairness and Efficiency
Gaia Nicosia, Andrea Pacifici, Ulrich Pferschy
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 93%
Last extracted: 4/1/2026, 1:14:01 AM
Summary
This paper introduces a class of multi-agent single-machine scheduling problems where each job is associated with a self-interested agent having a time-dependent utility function. The authors focus on achieving max-min fairness (maximizing the minimum utility) and compare it with system-optimal (total utility maximization) solutions. The study analyzes complexity, provides exact algorithms (binary search, greedy), and explores variants including release/due dates, adjustable linear utility functions, rescheduling with new jobs, and leader-follower bi-level settings.
Entities (5)
Relation Signals (3)
Max-min fairness → isalternativeto → System-optimal solution
confidence 95% · We aim to achieve a fair solution by maximizing the minimum utility... we also consider a system-optimal solution
Smith's rule → solves → System-optimal solution
confidence 90% · a system-optimal solution can be obtained by sequencing jobs in non-increasing order of a j /p j , according to Smith’s rule
Multi-agent scheduling → utilizes → Max-min fairness
confidence 90% · In this work, we investigate a family of fairness-driven multi-agent single-machine scheduling problems
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:A new class of multi agent single machine scheduling problems is introduced, where each job is associated with a self interested agent with a utility function decreasing in completion time. We aim to achieve a fair solution by maximizing the minimum utility across all agents. We study the problem's complexity and propose solution methods for several variants. For the general case, we present a binary search procedure to find the largest possible minimum utility, as well as an exact greedy based alternative. Variants with release and due dates are analyzed, showing strong NP hardness for arbitrary release dates, but weak NP hardness for a single release date job, and polynomial solvability when all jobs share processing times. For all these cases we also study the corresponding problem of finding efficient solutions where the sum of utilities is maximized. We also examine settings where linear utility functions can be adjusted within budget constraints, exploring the impact on optimal schedules when intercepts or slopes are modified. From a single agent perspective, we investigate the effect of improving one agent's utility in the overall solution. Adding a new job to be inserted with the best possible utility gives rise to rescheduling problems, where different lower bounds depending on the utilities of the original fair schedule are imposed. Finally, we consider a bi level setting where a leader wants to enforce a certain target schedule by modifying utility functions while the follower computes a fair solution for the modified instance. Our work contributes to scheduling theory, multi agent systems, and algorithmic fairness, highlighting fairness oriented objectives in competitive scheduling.
Tags
Links
- Source: https://arxiv.org/abs/2603.28800v1
- Canonical: https://arxiv.org/abs/2603.28800v1
Trouble viewing inline? Open PDF directly →
Full Text
145,777 characters extracted from source content.
Expand or collapse full text
Scheduling with Time-Dependent Utilities: Fairness and Efficiency Gaia Nicosia ∗ Andrea Pacifici † Ulrich Pferschy ‡ April 1, 2026 Abstract A new class of multi-agent single-machine scheduling problems is introduced, where each job is associated with a self-interested agent with a utility function decreasing in completion time. We aim to achieve a fair solution by maximizing the minimum utility across all agents. We study the problem’s complexity and propose solution methods for several variants. For the general case, we present a binary search procedure to find the largest possible minimum utility, as well as an exact greedy-based alternative. Variants with release and due dates are analyzed, showing strong NP-hardness for arbitrary release dates, but weak NP-hardness for a single release-date job, and polynomial solvability when all jobs share processing times. For all these cases we also study the corresponding problem of finding efficient solutions where the sum of utilities is maximized. We also examine settings where linear utility functions can be adjusted within budget constraints, exploring the impact on optimal schedules when intercepts or slopes are modified. From a single-agent perspective, we investigate the effect of improving one agent’s utility in the overall solution. Adding a new job to be inserted with the best possible utility gives rise to rescheduling problems, where different lower bounds depending on the utilities of the original fair schedule are imposed. Finally, we consider a bi-level setting where a leader wants to enforce a certain target schedule by modifying utility functions while the follower computes a fair solution for the modified instance. Our work contributes to scheduling theory, multi-agent systems, and algorithmic fairness, highlighting fairness-oriented objectives in competitive scheduling. Keywords: Scheduling; Multi Agents; Fairness; Complexity Theory 1 Introduction Scheduling problems have long been a central topic in operations research and computer science, with applications ranging from manufacturing and logistics to cloud computing and service oper- ations. While classical models typically assume a single decision maker optimizing system-wide ∗ Dipartimento di Ingegneria Civile, Informatica e delle Tecnologie Aeronautiche, Universit`a degli Studi “Roma Tre”, via della Vasca Navale 79, 00146 Rome, Italy, e-mail: gaia.nicosia@uniroma3.it † Dipartimento di Ingegneria Civile e Ingegneria Informatica, Universit`a degli Studi di Roma “Tor Vergata”, Via del Politecnico 1, 00133 Rome, Italy, e-mail: andrea.pacifici@uniroma2.it ‡ Department of Operations and Information Systems, University of Graz, Universitaetsstrasse 15, 8010 Graz, Austria. e-mail: ulrich.pferschy@uni-graz.at 1 arXiv:2603.28800v1 [cs.GT] 26 Mar 2026 performance, increasing attention has been devoted in recent decades to multi-agent schedul- ing problems, where multiple autonomous agents compete for access to shared resources—most commonly, a single machine. The study of multi-agent scheduling was initiated by the seminal works of Baker and Smith (2003) and Agnetis et al. (2004), which established the foundations for modeling scheduling problems involving multiple decision makers with potentially conflicting objectives. Since then, an extensive body of literature has examined settings in which agents control multiple jobs and seek to minimize individual completion-time-based cost functions (see, e.g., Agnetis et al., 2025, 2019, 2015; Hermelin et al., 2025; Wellman et al., 2001). More recently, growing attention has turned to the particular case where each job corre- sponds to a distinct agent (Niu et al., 2023). This formulation captures scenarios with highly individualized preferences and has been primarily addressed through classical non-cooperative game-theoretic models, where agents select strategies such as machine choices in parallel-machine environments (e.g., Correa and Queyranne, 2012; Hoeksma and Uetz, 2019). However, strategic behavior alone does not account for collective welfare considerations, and may lead to highly unbalanced outcomes in which some agents incur disproportionately high costs. In this work, we investigate a family of fairness-driven multi-agent single-machine scheduling problems in which each job corresponds to a self-interested agent with a utility function depend- ing on its completion time. Rather than aggregating utilities through utilitarian or Nash-style objectives, we focus on the max-min fairness criterion, which seeks to maximize the minimum utility (or equivalently, minimize the maximum cost) across agents. This objective ensures that no agent is excessively penalized, promoting balanced and socially acceptable schedules, a relevant concern in competitive environments where fairness and equity play a central role. In many shared-resource scheduling settings, agents derive time-sensitive utility from the completion of their activities, with delays inducing a monotonic loss of value (Raut et al., 2008a,b). This naturally arises in economic environments where payoffs are discounted over time, so that later completion corresponds to a reduced net present value due to opportunity costs, uncertainty, or foregone alternative uses of capital. When access to a common resource is constrained, objectives focusing solely on aggregate performance may result in highly uneven completion times, disproportionately penalizing some agents. So, a max–min utility criterion provides a principled mechanism to mitigate such imbalances by explicitly limiting the extent to which any individual participant can be disadvantaged by scheduling decisions. Similar considerations apply in market contexts characterized by rapidly decaying demand or willingness to pay. For products with short commercial lifecycles or strong initial hype, revenues associated with delayed production or delivery may decrease sharply over time (Dedehayir and Steinert, 2016). In such cases, maximizing total utility can still lead to schedules in which some agents experience delays that render their participation economically marginal. Optimizing the minimum utility instead promotes a more equitable allocation of completion times, ensuring that all agents retain a non-negligible share of the attainable value while preserving sensitivity to time-dependent economic effects. We examine several variants of the problem, taking into account different agent-specific utility functions and temporal constraints, such as release dates and due dates. We also analyze 2 versions of the problem in which certain input parameters can be adjusted either to obtain specific classes of solutions or to analyze how such modifications affect the resulting solutions. Our main contributions are as follows: • We propose exact solution approaches, including a binary search framework for identifying the largest achievable minimum utility and a greedy alternative with wide applicability. • We establish complexity results for these variants, showing, for example, strong NP- hardness in the presence of arbitrary release dates and weak NP-hardness when only a single job has a release constraint, while identifying polynomially solvable situations such as the equal processing times case. • The framework is extended to scenarios where linear utility functions can be adjusted within budget constraints. We analyze how modifications to intercepts or slopes influence equilibrium schedules. • From a single-agent perspective, we study how improving one agent’s utility affects the overall fairness-oriented solution, providing structural insights into the trade-off between individual incentives and collective guarantees. • We also investigate our problem in a leader-follower setting, where the leader aims to enforce a target solution by a adjusting the utility functions of the follower-agents who, in turn, will have their jobs arranged according to a fair schedule. The individual problems treated in this paper will be introduced in Section 3 which also describes the organization of the paper. 2 Related literature This section reviews the existing literature on scheduling problems that are closely related to the focus of this study, aiming to position our work within the broader research context. We begin with multi-agent scheduling, examining Pareto-optimal solutions and fairness-related con- siderations, which remain central in practical applications, then turn to scenarios where jobs themselves are treated as agents, and finally consider scheduling problems in which job values evolve over time, emphasizing the challenges posed by dynamic priorities and the opportunities they create for adaptive approaches. Multi-agent scheduling involves multiple agents, each with distinct objectives and job sets, competing for shared processing resources. This paradigm is prevalent in various applications, including manufacturing systems, cloud computing, and collaborative robotics, where efficient resource allocation among competing entities is crucial. Initial research predominantly focused on scenarios involving two agents (see, e.g. Agnetis et al., 2004; Baker and Smith, 2003). However, real-world applications frequently encompass environments with more than two agents, necessitating more sophisticated scheduling strategies capable of handling higher-dimensional interactions among heterogeneous objectives. This has led to a substantial expansion of the literature on multi-agent scheduling beyond the two-agent setting. For example, Agnetis et al. (2007) analyzed multi-agent single-machine scheduling where each agent owns a set of non-preemptive jobs, highlighting key complexity results across several classical performance criteria. Similarly, Yuan (2017) studied single-machine models with a fixed 3 number of competing agents, identifying problem variants that remain polynomially solvable and offering constructive algorithmic solutions. In the same vein, Li and Yuan (2020) examined com- petitive multi-agent scheduling under total weighted late work objectives, proposing methods for determining Pareto-optimal solutions that reflect trade-offs among agents. More recently, Wang et al. (2021) investigated a multitasking scheduling model on a cloud manufacturing platform involving multiple competing agents, providing updated complexity results and relevant solution procedures, while Chen et al. (2026) addressed several single-machine feasibility problems with equal-length jobs considering different agent objectives. Fairness has become an increasingly important theme in this context, as solutions driven purely by efficiency may disproportionately benefit certain agents (Agnetis et al., 2019). Conse- quently, incorporating fairness into scheduling algorithms has become essential in systems where multiple decision makers compete for shared resources. In recent years, a growing body of lit- erature has addressed fairness from a variety of perspectives (see, e.g., Agnetis et al., 2025; Hermelin et al., 2025, for recent contributions). In particular, Agnetis et al. (2025) investigate how the introduction of fairness constraints reshapes the structure of multi-agent single-machine scheduling problems and affects the trade-off between efficiency and equity. Complementarily, Hermelin et al. (2025) study fairness-aware scheduling models, showing that equity requirements can give rise to new algorithmic challenges and significantly modify the set of feasible solutions. A social welfare solution (i.e., one maximizing the overall utility of the system) may be highly unbalanced in terms of individual utilities and hence unsatisfactory for some of the agents. On the other hand, the global utility of a fair schedule can be potentially far away from its maximum value. A natural question then arises to assess what is the maximum loss in terms of social welfare when scheduling jobs according to a fair schedule. In this regard, a relevant fraction of the literature deals with finding upper bounds to the so-called Price of Fairness (PoF), introduced by Bertsimas et al. (2011) and then considered in several papers (Agnetis et al., 2019; Nicosia et al., 2017; Zhang et al., 2020) as the relative loss of a fair solution with respect to the utility of a total utility maximizer, in the context of general resource allocation problems. A recent contribution establishes tight bounds on the PoF under envy-freeness for time-dependent utility models, offering insights into how structural parameters affect fairness- induced utility loss (Vardi and Haskell, 2025) . In related research streams, jobs may themselves be treated as agents. In cooperative schedul- ing games, for example, players may exchange utility to stabilize a globally optimal schedule (Curiel et al., 1989), whereas in non-cooperative environments the focus shifts to the interplay between incentives and fairness constraints, as illustrated by Vardi and Haskell (2025). A final set of contributions concerns scheduling problems in which job values evolve over time. Deteriorating job values are considered in the work of Raut et al. (2008a), who analyze a single- machine problem where the value of each job decreases as its starting time is delayed. Their study considers unrestricted, truncated, and capacity-constrained deterioration functions, showing that while some special cases—such as linear unrestricted deterioration—are polynomially solvable, the general problem is unary NP-hard. They model the problem via a time-indexed formulation and propose several heuristics whose empirical performance is carefully assessed. Building on this line of research, Raut et al. (2008b) extend the model to a capacitated setting, where the 4 machine can process only a limited number of jobs simultaneously. They demonstrate that the added capacity constraints preserve the NP-hard nature of the problem and develop new heuristics based on multiplicative piecewise metrics that perform favorably relative to existing methods. These works highlight how time-dependent job utilities introduce significant structural complexity and require tailored algorithmic strategies. 3 Problem statement Given a set of n non-preemptive jobs J , we consider a class of single-machine scheduling problems in which each job is associated to an agent. For any j ∈ J , a processing time p j , a single-valued non-increasing utility function u j (·) and, possibly, a release date r j and a due date d j are given. Any schedule σ of the jobs in J implies a completion time C j (σ) for every job/agent j. We define the utility of agent j in schedule σ as u j (C j (σ)). Depending on the context, we will write equivalently u j (C j ) or u j (σ) or, simply, u j . With no loss of generality, we assume that u j ≥ 0 for all feasible schedules. This can be easily reached by adding a suitably large constant to all utility functions, namely M := max0,−u j ( ̄ C) where ̄ C is some upper bound on all completion times, e.g., P := P j p j , or max j r j + P j p j , if release dates r j are present. We also sometimes use of the following generalized inverse utility function (K ̈ampke and Radermacher, 2015) giving the latest possible completion for reaching a utility target value u T : u −1 j (u T ) := supC ∈ R| u j (C)≥ u T .(1) Hereafter, we deal with the cases of general non-increasing linear utility functions but sometimes also restrict our attention to linear utility functions u j (C j ) = b j − a j C j with a j ≥ 0. In the remainder of this work, we indicate by S the set of feasible semi-active schedules (in which each job cannot start earlier without violating the given order) for the problem at hand. Table 1 reports the notation adopted for all the problems addressed in the remainder of the paper. The fair scheduling problems considered in this work aim at determining a fair schedule σ F , namely a schedule that maximizes the minimum utility among all agents. Let u min (σ) := min j∈J u j (σ), then the fair schedule is defined as σ F ∈ arg max σ∈S u min (σ), u F := u min (σ F ).(2) As a notable special case, when all agents share the same utility function, computing σ F reduces to minimizing the maximum completion time over all jobs, that is, the classical makespan objective C max . For a given problem, in addition to a fair solution, we also consider a system-optimal solution, that is, a schedule σ SYS maximizing the global utility (or social welfare) of the system. Let 5 u sum (σ) := P j∈J u j (σ); then the system-optimal schedule is defined as σ SYS ∈ arg max σ∈S u sum (σ), u SYS := u sum (σ SYS ).(3) Depending on the characteristics of the agents’ utility functions, finding a system-optimal J :=1,...,nset of jobs/agents indexed by j p j , r j , d j ,processing time, release date, due date of job j P := P n j p j total processing time of the jobs s j (σ), s j starting time of job j in schedule σ C j (σ), C j completion time of job j in schedule σ u j (C j (σ)), u j (C j ), u j (σ)utility of job j completing at C j in schedule σ u j (C j ) = b j − a j C j linear utility of job j completing at C j −a j slope of the linear function b j intercept of the linear function Sset of feasible (semi-active) schedules u min (σ) = min j∈J u j (σ)minimum utility attained in schedule σ u sum (σ) = P j∈J u j (σ) total utility of schedule σ σ F = arg max σ∈S u min (σ)fair (max–min) solution σ SYS = arg max σ∈S u sum (σ)system-optimal solution u F = u min (σ F )fair (max–min) solution value u SYS = u sum (σ SYS )system-optimal solution value ∆a j ∆b j var δ j disruption Table 1: Notation schedule σ SYS may amount to minimizing a regular objective function, for which many results are available in the scheduling literature. In particular, in the case of linear utility functions, since max X j∈J u j (C j ) = max X j∈J (b j − a j C j ) = X j∈J b j − min X j∈J a j C j ,(4) computing σ SYS is equivalent to minimizing the weighted sum of completion times. This problem has been extensively studied. Indeed, in the absence of additional constraints or special system features, when u j (C j ) = b j − a j C j , a system-optimal solution can be obtained by sequencing jobs in non-increasing order of a j /p j , according to Smith’s rule (also known as the WSPT rule). Obviously, in the general case of non-increasing u j (·), finding a schedule that maximizes the sum of utilities depends on the specific form of the utility functions and may be far from trivial. For instance, suppose the utility of agent j is given by u j (C j ) = mind, b j − a j C j . In this case, the utility of agent j starts decreasing from d whenever j completes after the “due date” (b j − d)/a j . This formulation encompasses the classical scheduling problem 1|| P w j T j (minimization of total weighted tardiness), which is well known to be strongly NP-hard (cf. p. 359 in Lenstra et al. (1977)). Finding a system optimal solution remains strongly NP-hard even when u j = b j −a j f (C j ) and f (·) is a piecewise linear function (cf. Theorem 5 in H ̈ohn and Jacobs, 2015). Interestingly, the quadratic case u j = b j − a j C 2 j becomes polynomially solvable when a j is identical for all agents, since the SPT rule yields an optimal schedule to the standard scheduling problem 1|| P C 2 j (Townsend, 1978). However, the complexity status remains open 6 for arbitrary agent weights in the case u j (C j ) = b j −a j C 2 j (Chen et al., 1998; H ̈ohn and Jacobs, 2015). To summarize we can state the following: Observation 1 For general (resp., linear) non-increasing utility functions of the agents, max- imizing the total utility, i.e., finding a system optimal solution is strongly NP-hard (resp., poly- nomially solvable through the Smith’s rule). It is worth to mention here that the global utility of a fair solution can be quite small com- pared to that of a system optimum and, concurrently, that the fairness value u min (σ SYS ) = min j u j (σ SYS ) (i.e., the utility of the worse-off agent in a system optimal solution) can be arbitrarily small compared to that of a fair solution u F = min j u j (σ F ). This can be shown through a simple example in which the ratio between u sum (σ SYS ) = P j∈J u j (σ SYS ) and u sum (σ F ) = P j∈J u j (σ F ) becomes arbitrarily large, even when all jobs have identical processing times. Consider n = 2 jobs with p 1 = p 2 = 1 and linear utility functions u 1 (C 1 ) = 2M +1−MC 1 and u 2 (C 2 ) = 2−C 2 . If job 1 is scheduled first, we obtain u 1 = M + 1 and u 2 = 0, which yields the global optimal schedule σ SYS . Conversely, scheduling job 2 first results in u 2 = 1 and u 1 = 1, making this ordering the fair schedule σ F . Due to this negative result, in this study we do not address Price of Fairness issues any further. In this work we consider four different classes of problems depending on the agents/jobs perspective. These problems are rigorously stated in the following Sections 3.1–3.4. As it is customary in scheduling field, we denote the addressed problems using a three-field notation. The fair scheduling problem defined above is then 1|β|u min , where additional peculiarities are specified in the middle field β. The corresponding system-optimum is instead found by solving problem 1|β| P u j . We give an synthetic description of these problems and the corresponding notation in Table 2 settings below. N.Problem specificationsNotationSection 1general utilities, objective f = u min or f = P u j 1|u j |f4.1,4.2 2linear utilities, objective f ∈u min , P u j 1|u j = b j − a j C j |f4.1,4.2 3release dates, linear utilities, objective f ∈u min , P u j 1|r j ,u j = b j − a j C j |f4.3 4release dates, unitary proc. times, lin. utilities, obj. f ∈u min , P u j 1|p j = 1,r j ,u j = b j − a j C j |f4.3 5release dates, equal proc. times, lin. utilities, obj. f ∈u min , P u j 1|p j = p,r j ,u j = b j − a j C j |f4.3 6due dates, lin. utilities, bounded # of late jobs, obj. f ∈u min , P u j 1| P U j ≤ k,u j = b j − a j C j |f4.4 7increase of intercepts1|u j = ̃ b j − a j C j |u min 5.1 8decrease of slopes1|u j = b j − ̃a j C j |u min 5.2 9variation of utilities with constant area1|u j = ̃ b j − ̃a j C j , ̃ A j = A j |u min 5.3 10variation of utilities of a single agent i, objective u i 1| ̃u i |u i 5.4 11resched. with new agent, bounded individual disruptions δ j 1|resch,δ j ≥ 0|u n+1 6 12resched. with new agent, bounded aggregate disruptions δ j 1|resch, P δ j ≥ 0|u n+1 6 13resched. with new agent, schedule optimality preservation1|resch,u j ≥ u F |u n+1 6 14target sequence σ F (leader-follower setting), minimize increase of b j 1|σ F = σ T ,u j = ̃ b j − a j C j | P ̃ b j 7 15target sequence σ F (leader-follower setting), minimize decrease of a j 1|σ F = σ T ,u j = b j − ̃a j C j | P − ̃a j 7 16target sequence σ SYS (leader-follower setting), minimize decrease of a j 1|σ SYS = σ T ,u j = b j − ̃a j C j | P − ̃a j 7 Table 2: Description of addressed problem variants and adopted Graham notation. 7 3.1 Problem with fixed parameters The first set of problems we address concerns classical offline single-machine scheduling problems, in which agents are equivalent to standard jobs characterized by fixed, given parameters. In particular, we consider several variants of the problem, with or without release dates and due dates, with arbitrary, unit, or constant processing times, and under two different objective functions corresponding to fair and system-optimal solutions. The notation for these variants is summarized in the first six rows of Table 2, while the associated algorithmic and complexity results are presented in Section 4. 3.2 Variable linear utility functions A second class of problems involves agents whose utility functions are linear, i.e., u j = b j −a j C j , with a j ≥ 0, where C j denotes the completion time of agent j. Certain parameters of these utility functions can be modified to improve either the max-min fairness or the total system utility. To ensure realistic adjustments, modifications are subject to constraints. We indicate modifiable parameters with a tilde (see lines 7–10 in Table 2). In the following we formalize the types of variations we consider. Increasing the intercepts b j . We introduce a model in which each intercept b j is allowed to be increased by a non-negative amount ∆b j yielding the new intercept ̃ b j = b j + ∆b j , under a total budget constraint X j ∆b j ≤ B. The modified utility functions take the form u j = (b j + ∆b j )−a j C j . Formally, the optimization problem is max ∆b j ≥0 min j (b j + ∆b j )− a j C j s.t. X j ∆b j ≤ B. This problem is studied in Section 5.1 and is denoted as 1|u j = ̃ b j − a j C j |u min . Decreasing the slopes a j . Analogously, we consider decreasing the slopes a j by non-negative amounts ∆a j , subject to 0≤ ∆a j ≤ a j , X j ∆a j ≤ A, so that modified utilities with new slopes ̃a j = a j − ∆a j remain non-increasing in C j . The modified utility functions become u j = b j −(a j −∆a j )C j . We address this problem in Section 5.2 and denote it as 1|u j = b j − ̃a j C j |u min . Variation with area constraint. We consider a variation of the linear utility model in which both the intercepts b j and the slopes a j are allowed to vary simultaneously, but subject to an aggregate constraint on the expected utility value taken by each agent. Assuming that a job completion time is a random variable with uniform distribution C j ∼ U (0,P ), then, by linearity, the expected utility value for agent j is E[u j ] = ̃ b j − ̃a j E[C j ] = ̃ b j − ̃a j P 2 . We are interested in choosing ̃a j and ̃ b j while keeping E[u j ] constant, in particular equal to the original value b j − a j P 2 . As the area of the trapezoid bounded by the utility line 8 and the horizontal axis over [0,P ] is A j = Z P 0 b j − a j t dt = P b j − a j P 2 =: P ̃ b j − ̃a j P 2 = ̃ A j , our constraint is equivalent to impose that the area of the trapezoid remain constant. Additionally, to ensure that the linear utility functions remain non-increasing and non- negative over the entire interval of feasible completion times, we impose ̃a j ≥ 0 and ̃ b j − ̃a j t ≥ 0, ∀t∈ [0,P ], which is equivalent to ̃ b j ≥ ̃a j P . In conclusion we denote the problem in scheduling notation as 1|u j = ̃ b j − ̃a j C j , ̃ A = A j |u min and address it in Section 5.3. Variations for a single agent. We also consider the case where only a single agent, say agent i, can adjust its utility function, while all other agents data remain fixed. The three scenarios are: 1. the intercept b i can be increased; 2. the slope a i > 0 can be decreased (while remaining non-negative); 3. the area A i can be increased. For each variation, we analyze how the utility u i changes and how the optimal schedule adapts, either to improve u i or the overall objective. We denote these three versions of the problem as 1|u i = ̃ b i − a i C i |u ̄ȷ , 1|u i = b i − ̃a i C i |u ̄ȷ , and 1|u i = ̃ b i − ̃a i C i , ̃ A = A i |u ̄ȷ and study them in Section 5.4. 3.3 Rescheduling from the perspective of a new agent Analogously to the single-agent variations presented in Section 3.2, we consider a third class of problems from the perspective of a new agent. We assume that an initial problem has been solved optimally, yielding a schedule σ F with util- ity values u j (σ F ) for each job j = 1,...,n and a maximum-minimum utility u F := min j u j (σ F ). We then consider a subsequent rescheduling stage, in which a new agent, denoted n + 1, is intro- duced. The goal is to determine a revised schedule σ that (1) maximizes the utility of the new agent u n+1 (σ), and (2) preserves certain fairness conditions for the original agents j = 1,...,n. Formally, given the initial schedule σ F and the original utilities u j (σ F ), the problem is max σ u n+1 (σ) subject to fairness preserving constraints for the remaining agents. To enforce fairness, we allow the possibility of providing a non-negative compensation β j ≥ 0 to each of the original agents, e.g., in the form of monetary or resource adjustments. We specifically consider three types of fairness-preserving constraints on the original agents’ utilities (including their compensation): 1. Individual non-decrease: u j (σ) + β j ≥ u j (σ F ) for all j = 1,...,n; 2. Aggregate non-decrease: P n j=1 u j (σ) + β j ≥ P n j=1 u j (σ F ); 9 3. Schedule optimality preservation: the minimum utility among all n original agents in the new schedule, including compensation, is at least u F . These formulations are general: the same reasoning applies if the rescheduling perspective is taken with respect to one of the original n agents, rather than a newly introduced agent. We denote by δ j = u j (σ) + β j − u j (σ F ) the utility disruption of any job j in the new schedule σ compared to the original solution σ F , including compensations. The three addressed version of the problem are then denoted by 1|resch,δ j ≥ 0|u n+1 , 1|resch, P δ j ≥ 0|u n+1 , and 1|resch,u j ≥ u F |u n+1 . We refer to Section 6 for computational and analytical results for this class of problems. 3.4 Leader-follower utility adjustment Finally, we consider a bi-level optimization setting inspired by a leader-follower scenario. An entity, the leader, aims to enforce a certain schedule σ T , for example, one that minimizes the sum of completion times to optimize throughput or maximizes total utility. In this setting, the follower still solves the resulting problem 1|...|u min to achieve a fair solution for all jobs, but the leader influences the outcome by modifying the utility functions of the jobs. In order to do so, the leader is allowed to control either the intercepts ̃ b j = b j + ∆b j , or the slopes ̃a j = a j − ∆a j , analogous to the modifications described earlier. These changes ∆b j ≥ 0 and 0 ≤ ∆a j ≤ a j affect the sequence determined by the follower when computing the fair solution. We are therefore interested in the following problem: Minimize the total modification cost, i.e., either P j ∆b j or P j ∆a j , subject to the condition that the fair solution σ F produced by the follower (who wants to maximize the minimum utility under the modified utility functions) corresponds to the desired target sequence σ T . We denote these two versions of the problem as 1|σ ∗ = σ T ,u j = ̃ b j − a j C j | P ̃ b j and 1|σ ∗ = σ T ,u j = b j − ̃a j C j | P − ̃a j where σ ∗ can be the fair solution σ F or the system optimum σ SYS , and study them in Section 7. (As it is clarified there, note that problem 1|σ SYS = σ T ,u j = ̃ b j − a j C j | P ̃ b j is not meaningful.) 3.5 Summary of contributions Across the sixteen (plus six, considering the two different objectives of the first six problems) problem variants considered in this work, we conduct a detailed analysis of their computa- tional complexity and provide, whenever possible, efficient solution methods. In particular, for each variant we either establish NP-hardness or design polynomial-time and, in some cases, pseudopolynomial-time algorithms. Table 3 offers an overview of our main contributions, highlighting the complexity classifica- tion and the type of algorithmic results obtained for each problem setting. This summary aims to provide a guide through the diversity of models analyzed and the methodological advances achieved in the present study. Note that all our algorithms in Sections 4 and 6 apply for general non-increasing utility functions (assuming that a function value can be computed in constant time). 10 ProblemComplexity for f = u min Complexity for f = P u j 1|u j |fPolynomial (Thm. 2)Strongly NP-hard (Obs. 1) 1|u j = b j − a j C j |fPolynomial (Thm. 2)Polynomial (Smith, 1956) 1|r j , u j = b j − a j C j |fStrongly NP-hard (Thm. 3)Strongly NP-hard (Thm. 5) 1|p j = 1, r j , u j |fPolynomial (Thm. 7)Polynomial: assignment (Obs. 8) 1|p j = p, r j , u j |fPolynomial (Thm. 9)Polynomial (see Baptiste, 2000, Obs. 10) 1| P U j ≤ k, u j = b j − a j C j |fPolynomial (Thm. 12)Strongly NP-hard (Thm. 13) Table 3: Overview of results for problems 1–6 of Table 2 4 Problems with fixed parameters ProblemComplexity 1|u j = ̃ b j − a j C j |u min Polynomial (Sect. 5.1) 1|u j = b j − ̃a j C j |u min Polynomial (Sect. 5.2) 1|u j = ̃ b j − ̃a j C j , ̃ A j = A j |u min Polynomial (Sect. 5.3) 1| ̃u i |u i Polynomial (Sect. 5.4) 1|resch, δ j ≥ 0|u n+1 Weakly NP-hard (Thm. 14) 1|resch, P δ j ≥ 0|u n+1 Weakly NP-hard (Thm. 15) 1|resch, u j ≥ u F |u n+1 Polynomial (Thm. 16) 1|σ F = σ T ,u j = ̃ b j − a j C j | P ̃ b j Polynomial (Sect. 7) 1|σ F = σ T ,u j = b j − ̃a j C j | P − ̃a j Polynomial (Sect. 7) 1|σ SYS = σ T ,u j = b j − ̃a j C j | P − ̃a j Polynomial (Sect. 7) Table 4: Overview of results for problems 7–16 of Table 2 In this section, we consider the general case of the problem with given and fixed parameters, namely the first six problems of Table 2. In particular, we first propose a general solution approach that can be applied to problem 1|u j |u min , for any continuous utility functions u j and then refine it by introducing a (faster) greedy algorithm suitable for several versions of the problem. Finally, we examine several variants, including the case with release dates, the case with identical processing times, and the case with due dates. For each of these variants, we provide corresponding complexity results and solution algorithms. 4.1 General solution approach We can describe a generic solution approach based on binary search given lower and upper bounds u and ̄u on the optimal solution value u F = u min (σ F ) (assuming continuous utility functions). A general upper bound is given by ̄u := max j u j (0), while a lower bound may depend on additional problem data, such as due dates and release dates. For linear utility functions we can choose the upper bound ̄u := max j b j . We can perform a binary search in log( ̄u− u ) iterations, in each of which we have a target value u T . To check whether u F ≥ u T , the completion time C j of each job j has to fulfill u j (C j )≤ u T , i.e., recalling Equation (1), C j ≤ u −1 j (u T ), which implies a due date d T j = u −1 j (u T )(5) 11 for each job. If the underlying scheduling problem with due dates can be solved by some known algorithm in polynomial time this immediately translates into an optimal polynomial algorithm for our problem. In fact, it is enough to establish the existence of a feasible solution for the problem with due dates without any tardy job. The running time of such an algorithm is polynomial, but not strongly polynomial, as it contains the log-factor of ̄u, which depends on the length of the encoded input. Thus, for several problem variants we will present new and simpler algorithms with strongly polynomial running times, i.e., depending only on the number of input values. 4.2 Greedy-type algorithm Through the binary search approach of Section 4.1, provided that the due dates in Equation (5) can be computed in polynomial time, an optimal solution can likewise be found in polynomial time. In fact, the maximum lateness can be evaluated by sorting the jobs in non-decreasing order of their due dates (EDD rule), which enables an efficient check of whether u F ≥ u T . However, we can avoid binary search by the following strongly polynomial greedy-type algorithm which we will call MaxMinGreedy. For the completion time of all unscheduled jobs T , initially set to P j p j , we pick the job k with highest utility if completed at time T . The procedure iterates by considering at each step time T := T − p k . It works for arbitrary non-increasing utility functions u j . A sketch of MaxMinGreedy applied for an example with three jobs and linear utilities is shown in Figure 1. Note that this approach is quite similar to Lawler’s Algorithm well known for the minimization of the maximum of regular functions under precedence constraints (Lawler, 1973). Note that, as for Lawler’s algorithm, our approach can be easily adapted to the case of precedence relationships among jobs. Algorithm 1 Max-Min Greedy 1: Input: a set of agent-jobs J =J 1 ,J 2 ,...,J n 2: Output: permutation (schedule) π = π 1 ,...,π n (π i is the i-th job in the sequence 3: T := P j p j 4: for i = n downto 1 do 5:pick the remaining job k ∈ J with highest utility at time T and schedule it at position i (i.e. π i := k = arg maxu j (T ) : j ∈ J) 6: T := T − p k 7: J := J \k 8: end for 9: Return: π In conclusion we have the following result whose simple proof is reported in the Appendix. Theorem 2 If, for all j ∈ J , u j is any non-increasing function of the completion time C j of job j, then MaxMinGreedy computes an optimal solution of 1|u j |u min in O(n 2 ) time. 12 P u j C j u 1 (P ) b 1 u 2 (P ) b 2 u 3 (P ) b 3 |z p 1 P − p 1 |z p 3 |z p 2 Figure 1: Algorithm MaxMinGreedy applied to an instance of 1|u j |u min with three jobs and linear utility functions. 4.3 Release dates In this section we consider our problem when release dates are present, namely 1|r j ,u j |f . We explore the case in which each job has an arbitrary given release date and the special case in which all jobs but one have null release dates. Fair solutions. Let us first focus on the fair objective, i.e., f = u min . In what follows, we show that introducing release dates makes the problem strongly NP-hard, even when all utilities are linear. The result is obtained by reducing a utility target value to an equivalent due-date formulation. A detail proof is reported in the Appendix. Theorem 3 Problem 1|r j ,u j |u min is strongly NP-hard, even for linear utility functions. It can furthermore be shown that the problem remains NP-hard even when only a single job has a release date strictly greater than zero. In this restricted setting, the problem is in fact weakly NP-hard. A proof of this statement is given in the Appendix. Theorem 4 Problem 1|r j ,u j |u min is weakly NP-hard, even if the utility functions are linear and only one release date is nonzero. To show that this special case is indeed only weakly NP-hard, we briefly describe a pseu- dopolynomial dynamic programming algorithm. Let job n + 1 be the job with a release date r, while all other jobs are available from the beginning. Let P = P n j=1 p j be the total job processing time not including job n+1. We perform an iteration over all feasible starting times s n+1 of job n + 1, i.e., s n+1 = r,r + 1,...,r +P . For each starting time s n+1 we perform binary search similar to the one described in Section 4.1. For each candidate value u T we obtain, recalling Equation (1), due dates d T j = u −1 j (u T ) for every job j and check if there exists a feasible schedule where all jobs are on time w.r.t. these due dates, i.e., where the maximum lateness is≤ 0. To do so, we have to decide for each job whether it should be scheduled before job n + 1 finishing before s n+1 or after n + 1 starting not before s n+1 +p n+1 . Within each of the two resulting subsets, jobs must be scheduled in EDD (earliest 13 Algorithm 2 Pseudo-polynomial dynamic programming algorithm for the special case of 1|r j ,u j |u min with only one nonzero release date 1: Input: Jobs 1,...,n + 1, processing times p j , release date r for job n+1 2: Output: Maximum minimum utility u ∗ min 3: Let P := P n j=1 p j , u F := 0 4: for s n+1 = r to r + P do 5:Perform binary search on u T 6: while there is a candidate value u T do 7: S ←∅ 8:Compute due dates d T j = u −1 j (u T ) for all jobs j 9:Identify set A of jobs with d T j ≤ s n+1 + p n+1 + p j − 1, set P A := P j∈A p j 10:if P A ≤ s n+1 then 11: S ←(P A , 0) 12:Sort remaining jobs in non-decreasing order of d T j 13:for all jobs j in sorted order do 14:S ′ ←∅ 15:for all states (P 1 ,P 2 )∈S do 16:if P 1 + p j ≤ s n+1 then 17:Add (P 1 + p j ,P 2 ) to S ′ 18:end if 19:if d T j ≥ s n+1 + p n+1 + P 2 + p j then 20:Add (P 1 ,P 2 + p j ) to S ′ 21:end if 22:end for 23:S ←S ′ 24:end for 25:end if 26:if S =∅ then 27:Choose smaller candidate u T 28:else 29:Choose larger candidate u T 30:end if 31: end while 32: u F := maxu F ,u T 33: end for 34: Return u F 14 due date) order to minimize the maximum lateness. All jobs with d T j ≤ s n+1 +p n+1 +p j − 1 must be scheduled before n + 1, and thus can be omitted from further consideration after recording their total processing time P A . For all remaining jobs we perform dynamic programming where each state (P 1 ,P 2 ) consists of jobs with total processing time P 1 , resp. P 2 , scheduled before, resp. after job n + 1. After initializing a single state (P A , 0), we go through the jobs in EDD order. Each job j is added to each existing state (P 1 ,P 2 ) either in the first or the second subset. This replaces (P 1 ,P 2 ) by two new states (P 1 + p j ,P 2 ) and (P 1 ,P 2 + p j ), where the former is generated if P 1 + p j ≤ s n+1 and the latter if d T j ≥ s n+1 + p n+1 + P 2 + p j . Clearly, the total number of states is bounded by P 2 . If we reach a job which cannot be added to any existing state, we have established that there is no solution with starting time s n+1 for job n + 1 reaching the desired utility target and have to lower u T . Otherwise, every state generated by adding the final job is a feasible solution with minimum utility at least u T and we can try to increase u T . The procedure sketched above is further clarified by the pseudo-code provided in Algorithm 2. The overall pseudopolynomial running time is O(P · nP 2 · log(UB − LB)) where UB and LB are, respectively, upper and lower bounds on the objective values. System optimal solution. In the following we consider problem 1|r j ,u j | P j u j with release dates and global objective function, i.e., we consider the maximization of the total utility. It turns out that this problem has the same complexity as the one with maximum fairness objective. Since completion times can be mapped to utilities, a simple reduction from the strongly NP-hard problem 1|r j | P Cj proves the following statement. Theorem 5 Problem 1|r j ,u j | P j u j is strongly NP-hard, even if the utility functions are linear. Theorem 6 Problem 1|r j ,u j | P j u j is weakly NP-hard, even if the utility functions are linear and only one release date is nonzero. Proof.We use a reduction from Partition. We consider an instance I P with integers w 1 ,...,w n and B = 1 2 P n j=1 w j . Correspondingly, we construct an instance I of 1|r j ,u j = b j − a j C j | P j u j with n+1 jobs. For each j = 1,...,n, let p j = a j = w j and r j = 0, and let job n+1 have processing time p n+1 = ̄p, a n+1 = M (for M sufficiently large) and release date r n+1 = B. Since P n j=1 p j = 2B, any feasible schedule has makespan at least 2B + ̄p. A feasible schedule for I such that n + 1 is processed in the interval [B,B + ̄p] and having a makespan equal to 2B + ̄p will be called balanced (see schedule ̃σ in Figure 2). We show that I P is a YES instance if and only if an optimal schedule of I is balanced. Hereafter, for any S ⊆1,...,n, we use p(S) = P j∈S p j = P j∈S w j . Assume that I admits an optimal schedule σ that is balanced. By definition of balanced schedule, there is a set S ⊆ 1,...,n of jobs executed in [0,B], and p(S) = B. Hence I P is a YES instance. Conversely, assume that I P is a YES instance. Then there exist a subset S ⊆ 1,...,n with p(S) = B and a feasible schedule σ where the jobs in S are processed in the interval [0,B], job n+1 in [B,B + ̄p], and the set ̄ S of remaining jobs in [B + ̄p, 2B + ̄p]. Such a schedule is therefore balanced. Note that since a j = p j , any internal permutation of jobs within S or within 15 <latexit sha1_base64="0MXcTmWYxVPWK7hqbuMTzTQR728=">AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBg5RERD0WvHhswX5AG8pmO2nXbjZhdyOU0F/gxYMiXv1J3vw3btsctPXBwOO9GWbmBYng2rjut1NYW9/Y3Cpul3Z29/YPyodHLR2nimGTxSJWnYBqFFxi03AjsJMopFEgsB2M72Z++wmV5rF8MJME/YgOJQ85o8ZKDbdfrrhVdw6ySrycVCBHvV/+6g1ilkYoDRNU667nJsbPqDKcCZyWeqnGhLIxHWLXUkkj1H42P3RKzqwyIGGsbElD5urviYxGWk+iwHZG1Iz0sjcT//O6qQlv/YzLJDUo2WJRmApiYjL7mgy4QmbExBLKFLe3EjaiijJjsynZELzll1dJ67LqXVe9xlWldpHHUYQTOIVz8OAGanAPdWgCA4RneIU359F5cd6dj0VrwclnjuEPnM8fdHOMpA==</latexit> 0 <latexit sha1_base64="J5j5iDARiBJtcD9qO2WBXs5y77c=">AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4kJKIqMeiF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dlZW19Y3Ngtbxe2d3b390sFhU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWju6nfekKleSwfzDhBP6IDyUPOqLFS/bZXKrsVdwayTLyclCFHrVf66vZjlkYoDRNU647nJsbPqDKcCZwUu6nGhLIRHWDHUkkj1H42O3RCTq3SJ2GsbElDZurviYxGWo+jwHZG1Az1ojcV//M6qQlv/IzLJDUo2XxRmApiYjL9mvS5QmbE2BLKFLe3EjakijJjsynaELzFl5dJ86LiXVW8+mW5ep7HUYBjOIEz8OAaqnAPNWgAA4RneIU359F5cd6dj3nripPPHMEfOJ8/j7uMtg==</latexit> B <latexit sha1_base64="Au+CnhuTGkCUOpXsszvMOPMbtQw=">AAAB8HicbVBNSwMxEJ2tX7V+VT16CRZBUMpuEfVY9OKxgv2QdinZNNuGJtklyQpl6a/w4kERr/4cb/4bs+0etPXBwOO9GWbmBTFn2rjut1NYWV1b3yhulra2d3b3yvsHLR0litAmiXikOgHWlDNJm4YZTjuxolgEnLaD8W3mt5+o0iySD2YSU1/goWQhI9hY6bF2c9YLsEJxv1xxq+4MaJl4OalAjka//NUbRCQRVBrCsdZdz42Nn2JlGOF0WuolmsaYjPGQdi2VWFDtp7ODp+jEKgMURsqWNGim/p5IsdB6IgLbKbAZ6UUvE//zuokJr/2UyTgxVJL5ojDhyEQo+x4NmKLE8IklmChmb0VkhBUmxmZUsiF4iy8vk1at6l1WvfuLSv08j6MIR3AMp+DBFdThDhrQBAICnuEV3hzlvDjvzse8teDkM4fwB87nD4gxj4Q=</latexit> 2B+ ̄p <latexit sha1_base64="xnGlZT4Zy6bsv1GKWgULEj7bo2g=">AAAB73icbVBNS8NAEJ34WetX1aOXxSIISklE1GPRi8cK9gPaUDbbSbt0s4m7G6GE/gkvHhTx6t/x5r9x2+agrQ8GHu/NMDMvSATXxnW/naXlldW19cJGcXNre2e3tLff0HGqGNZZLGLVCqhGwSXWDTcCW4lCGgUCm8HwduI3n1BpHssHM0rQj2hf8pAzaqzUujntBFSRpFsquxV3CrJIvJyUIUetW/rq9GKWRigNE1Trtucmxs+oMpwJHBc7qcaEsiHtY9tSSSPUfja9d0yOrdIjYaxsSUOm6u+JjEZaj6LAdkbUDPS8NxH/89qpCa/9jMskNSjZbFGYCmJiMnme9LhCZsTIEsoUt7cSNqCKMmMjKtoQvPmXF0njvOJdVrz7i3L1LI+jAIdwBCfgwRVU4Q5qUAcGAp7hFd6cR+fFeXc+Zq1LTj5zAH/gfP4AFeePSA==</latexit> B+ ̄p <latexit sha1_base64="V1uUlr/I7+Kh1O623OH0ohGi7dE=">AAAB6nicbVBNS8NAEJ3Ur1q/qh69LBZBUEoioh4LXjxWtB/QhrLZTtqlm03Y3Qgl9Cd48aCIV3+RN/+N2zYHbX0w8Hhvhpl5QSK4Nq777RRWVtfWN4qbpa3tnd298v5BU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWj26nfekKleSwfzThBP6IDyUPOqLHSgzzzeuWKW3VnIMvEy0kFctR75a9uP2ZphNIwQbXueG5i/Iwqw5nASambakwoG9EBdiyVNELtZ7NTJ+TEKn0SxsqWNGSm/p7IaKT1OApsZ0TNUC96U/E/r5Oa8MbPuExSg5LNF4WpICYm079JnytkRowtoUxxeythQ6ooMzadkg3BW3x5mTQvqt5V1bu/rNTO8ziKcATHcAoeXEMN7qAODWAwgGd4hTdHOC/Ou/Mxby04+cwh/IHz+QOou41S</latexit> n+1 <latexit sha1_base64="tNABXPOwOSdNPd8d79QpMp3Xaiw=">AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4kJKIqMeCCB5bsB/QhrLZTtq1m03Y3Qgl9Bd48aCIV3+SN/+N2zYHbX0w8Hhvhpl5QSK4Nq777aysrq1vbBa2its7u3v7pYPDpo5TxbDBYhGrdkA1Ci6xYbgR2E4U0igQ2ApGt1O/9YRK81g+mHGCfkQHkoecUWOl+l2vVHYr7gxkmXg5KUOOWq/01e3HLI1QGiao1h3PTYyfUWU4EzgpdlONCWUjOsCOpZJGqP1sduiEnFqlT8JY2ZKGzNTfExmNtB5Hge2MqBnqRW8q/ud1UhPe+BmXSWpQsvmiMBXExGT6NelzhcyIsSWUKW5vJWxIFWXGZlO0IXiLLy+T5kXFu6p49cty9TyPowDHcAJn4ME1VOEeatAABgjP8ApvzqPz4rw7H/PWFSefOYI/cD5/AJRHjLk=</latexit> E <latexit sha1_base64="w4rEuAJPetC0TZdhDcULGp4Bzgw=">AAAB6HicbVA9SwNBEJ3zM8avqKXNYhAsJNyJqGXAxsIiAfMByRH2NnPJmr29Y3dPCEd+gY2FIrb+JDv/jZvkCk18MPB4b4aZeUEiuDau++2srK6tb2wWtorbO7t7+6WDw6aOU8WwwWIRq3ZANQousWG4EdhOFNIoENgKRrdTv/WESvNYPphxgn5EB5KHnFFjpfp9r1R2K+4MZJl4OSlDjlqv9NXtxyyNUBomqNYdz02Mn1FlOBM4KXZTjQllIzrAjqWSRqj9bHbohJxapU/CWNmShszU3xMZjbQeR4HtjKgZ6kVvKv7ndVIT3vgZl0lqULL5ojAVxMRk+jXpc4XMiLEllClubyVsSBVlxmZTtCF4iy8vk+ZFxbuqePXLcvU8j6MAx3ACZ+DBNVThDmrQAAYIz/AKb86j8+K8Ox/z1hUnnzmCP3A+fwCe44zA</latexit> L <latexit sha1_base64="TgFUg7KrQLLJ5AipOICK9naEB5E=">AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4kJKIqMeCF4+t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dlZW19Y3Ngtbxe2d3b390sFhU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWj26nfekKleSwfzDhBP6IDyUPOqLFS/b5XKrsVdwayTLyclCFHrVf66vZjlkYoDRNU647nJsbPqDKcCZwUu6nGhLIRHWDHUkkj1H42O3RCTq3SJ2GsbElDZurviYxGWo+jwHZG1Az1ojcV//M6qQlv/IzLJDUo2XxRmApiYjL9mvS5QmbE2BLKFLe3EjakijJjsynaELzFl5dJ86LiXVW8+mW5ep7HUYBjOIEz8OAaqnAHNWgAA4RneIU359F5cd6dj3nripPPHMEfOJ8/p/uMxg==</latexit> R <latexit sha1_base64="WK6VprQMoimzZJq474cCbc+6/nY=">AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4kJKIqMeKF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dlZW19Y3Ngtbxe2d3b390sFhU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWju6nfekKleSwfzDhBP6IDyUPOqLFS/bZXKrsVdwayTLyclCFHrVf66vZjlkYoDRNU647nJsbPqDKcCZwUu6nGhLIRHWDHUkkj1H42O3RCTq3SJ2GsbElDZurviYxGWo+jwHZG1Az1ojcV//M6qQlv/IzLJDUo2XxRmApiYjL9mvS5QmbE2BLKFLe3EjakijJjsynaELzFl5dJ86LiXVW8+mW5ep7HUYBjOIEz8OAaqnAPNWgAA4RneIU359F5cd6dj3nripPPHMEfOJ8/jjeMtQ==</latexit> A <latexit sha1_base64="nJQWJKuZVMTtI11aG+s9y/OoMVM=">AAAB7XicbVBNSwMxEJ3Ur1q/qh69BIvgQcquiHqsePFYwX5Au5Rsmm1js8mSZIWy9D948aCIV/+PN/+NabsHbX0w8Hhvhpl5YSK4sZ73jQorq2vrG8XN0tb2zu5eef+gaVSqKWtQJZRuh8QwwSVrWG4FayeakTgUrBWObqd+64lpw5V8sOOEBTEZSB5xSqyTmt2QaHzTK1e8qjcDXiZ+TiqQo94rf3X7iqYxk5YKYkzH9xIbZERbTgWblLqpYQmhIzJgHUcliZkJstm1E3zilD6OlHYlLZ6pvycyEhszjkPXGRM7NIveVPzP66Q2ug4yLpPUMknni6JUYKvw9HXc55pRK8aOEKq5uxXTIdGEWhdQyYXgL768TJrnVf+y6t9fVGpneRxFOIJjOAUfrqAGd1CHBlB4hGd4hTek0At6Rx/z1gLKZw7hD9DnD9yrjpg=</latexit> ̄ A <latexit sha1_base64="0MXcTmWYxVPWK7hqbuMTzTQR728=">AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBg5RERD0WvHhswX5AG8pmO2nXbjZhdyOU0F/gxYMiXv1J3vw3btsctPXBwOO9GWbmBYng2rjut1NYW9/Y3Cpul3Z29/YPyodHLR2nimGTxSJWnYBqFFxi03AjsJMopFEgsB2M72Z++wmV5rF8MJME/YgOJQ85o8ZKDbdfrrhVdw6ySrycVCBHvV/+6g1ilkYoDRNU667nJsbPqDKcCZyWeqnGhLIxHWLXUkkj1H42P3RKzqwyIGGsbElD5urviYxGWk+iwHZG1Iz0sjcT//O6qQlv/YzLJDUo2WJRmApiYjL7mgy4QmbExBLKFLe3EjaiijJjsynZELzll1dJ67LqXVe9xlWldpHHUYQTOIVz8OAGanAPdWgCA4RneIU359F5cd6dj0VrwclnjuEPnM8fdHOMpA==</latexit> 0 <latexit sha1_base64="J5j5iDARiBJtcD9qO2WBXs5y77c=">AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4kJKIqMeiF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dlZW19Y3Ngtbxe2d3b390sFhU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWju6nfekKleSwfzDhBP6IDyUPOqLFS/bZXKrsVdwayTLyclCFHrVf66vZjlkYoDRNU647nJsbPqDKcCZwUu6nGhLIRHWDHUkkj1H42O3RCTq3SJ2GsbElDZurviYxGWo+jwHZG1Az1ojcV//M6qQlv/IzLJDUo2XxRmApiYjL9mvS5QmbE2BLKFLe3EjakijJjsynaELzFl5dJ86LiXVW8+mW5ep7HUYBjOIEz8OAaqnAPNWgAA4RneIU359F5cd6dj3nripPPHMEfOJ8/j7uMtg==</latexit> B <latexit sha1_base64="xnGlZT4Zy6bsv1GKWgULEj7bo2g=">AAAB73icbVBNS8NAEJ34WetX1aOXxSIISklE1GPRi8cK9gPaUDbbSbt0s4m7G6GE/gkvHhTx6t/x5r9x2+agrQ8GHu/NMDMvSATXxnW/naXlldW19cJGcXNre2e3tLff0HGqGNZZLGLVCqhGwSXWDTcCW4lCGgUCm8HwduI3n1BpHssHM0rQj2hf8pAzaqzUujntBFSRpFsquxV3CrJIvJyUIUetW/rq9GKWRigNE1Trtucmxs+oMpwJHBc7qcaEsiHtY9tSSSPUfja9d0yOrdIjYaxsSUOm6u+JjEZaj6LAdkbUDPS8NxH/89qpCa/9jMskNSjZbFGYCmJiMnme9LhCZsTIEsoUt7cSNqCKMmMjKtoQvPmXF0njvOJdVrz7i3L1LI+jAIdwBCfgwRVU4Q5qUAcGAp7hFd6cR+fFeXc+Zq1LTj5zAH/gfP4AFeePSA==</latexit> B+ ̄p <latexit sha1_base64="xrBzkgmlLHx5ZBxyaeFAsdKsgKo=">AAAB9XicbVDLSgNBEJyNrxhfUY9eBoMgRMJuEPUY9OIxgnlAdg29k0kyZPbBTK8SlvyHFw+KePVfvPk3TpI9aGJBQ1HVTXeXH0uh0ba/rdzK6tr6Rn6zsLW9s7tX3D9o6ihRjDdYJCPV9kFzKULeQIGSt2PFIfAlb/mjm6nfeuRKiyi8x3HMvQAGoegLBmikh+p12fVB0bjsIiTdYsmu2DPQZeJkpEQy1LvFL7cXsSTgITIJWnccO0YvBYWCST4puInmMbARDHjH0BACrr10dvWEnhilR/uRMhUinam/J1IItB4HvukMAId60ZuK/3mdBPtXXirCOEEesvmifiIpRnQaAe0JxRnKsSHAlDC3UjYEBQxNUAUTgrP48jJpVivORcW5Oy/VzrI48uSIHJNT4pBLUiO3pE4ahBFFnskrebOerBfr3fqYt+asbOaQ/IH1+QMS0pGH</latexit> 2B+ ̄p+⌧ <latexit sha1_base64="LxEApGBb+w58ItdYN+WVmPIdI/4=">AAAB63icbVBNS8NAEJ3Ur1q/qh69LBbBg5RERD0WvHisYD+gDWWz3bRLdzdhdyKU0L/gxYMiXv1D3vw3Jm0O2vpg4PHeDDPzglgKi6777ZTW1jc2t8rblZ3dvf2D6uFR20aJYbzFIhmZbkAtl0LzFgqUvBsbTlUgeSeY3OV+54kbKyL9iNOY+4qOtAgFo5hLfaTJoFpz6+4cZJV4BalBgeag+tUfRixRXCOT1Nqe58bop9SgYJLPKv3E8piyCR3xXkY1Vdz66fzWGTnLlCEJI5OVRjJXf0+kVFk7VUHWqSiO7bKXi/95vQTDWz8VOk6Qa7ZYFCaSYETyx8lQGM5QTjNCmRHZrYSNqaEMs3gqWQje8surpH1Z967r3sNVrXFRxFGGEziFc/DgBhpwD01oAYMxPMMrvDnKeXHenY9Fa8kpZo7hD5zPHxyHjjg=</latexit> ⌧ <latexit sha1_base64="V1uUlr/I7+Kh1O623OH0ohGi7dE=">AAAB6nicbVBNS8NAEJ3Ur1q/qh69LBZBUEoioh4LXjxWtB/QhrLZTtqlm03Y3Qgl9Cd48aCIV3+RN/+N2zYHbX0w8Hhvhpl5QSK4Nq777RRWVtfWN4qbpa3tnd298v5BU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWj26nfekKleSwfzThBP6IDyUPOqLHSgzzzeuWKW3VnIMvEy0kFctR75a9uP2ZphNIwQbXueG5i/Iwqw5nASambakwoG9EBdiyVNELtZ7NTJ+TEKn0SxsqWNGSm/p7IaKT1OApsZ0TNUC96U/E/r5Oa8MbPuExSg5LNF4WpICYm079JnytkRowtoUxxeythQ6ooMzadkg3BW3x5mTQvqt5V1bu/rNTO8ziKcATHcAoeXEMN7qAODWAwgGd4hTdHOC/Ou/Mxby04+cwh/IHz+QOou41S</latexit> n+1 <latexit sha1_base64="OlP1LpHh9RY+qTk0GT7iiZbVd/U=">AAAB83icbVBNS8NAEJ3Ur1q/qh69LBbBg5RERD0WvHisYD+gCWWz2bRLN5uwOxFK6d/w4kERr/4Zb/4bt20O2vpg4PHeDDPzwkwKg6777ZTW1jc2t8rblZ3dvf2D6uFR26S5ZrzFUpnqbkgNl0LxFgqUvJtpTpNQ8k44upv5nSeujUjVI44zHiR0oEQsGEUr+T4KGXHfiEFC+9WaW3fnIKvEK0gNCjT71S8/SlmecIVMUmN6npthMKEaBZN8WvFzwzPKRnTAe5YqmnATTOY3T8mZVSISp9qWQjJXf09MaGLMOAltZ0JxaJa9mfif18sxvg0mQmU5csUWi+JcEkzJLAASCc0ZyrEllGlhbyVsSDVlaGOq2BC85ZdXSfuy7l3XvYerWuOiiKMMJ3AK5+DBDTTgHprQAgYZPMMrvDm58+K8Ox+L1pJTzBzDHzifPzkVkb0=</latexit> ̃ <latexit sha1_base64="gQ5exKmXto7AOER+4M7T5nIIkt4=">AAAB73icbVBNSwMxEJ34WetX1aOXYBFEpOyKqMeCF48V7Ae0a8m2TY0ya5JVihL/4QXD4p49e9489+YtnvQ1gcDj/dmmJkXJoIb63nfaGl5ZXVtvbBR3Nza3tkt7e03TJxqyuo0FrFuhcQwwRWrW24FayWaERkK1gyHNxO/+cS04bG6t6OEBZL0FY84JdZJrY7hfUkeTrulslfxpsCLxM9JGXLUuqWvTi+mqWTKUkGMafteYoOMaMupYONiJzUsIXRI+qztqCKSmSCb3jvGx07p4SjWrpTFU/X3REakMSMZuk5J7MDMexPxP6+d2ug6yLhKUssUnS2KUoFtjCfP4x7XjFoxcoRQzd2tmA6IJtS6iIouBH/+5UXSOK/4lxX/7qJcPcvjKMAhHMEJ+HAFVbiFGtSBgoBneIU39Ihe0Dv6mLUuoXzmAP4Aff4AtP6Prw==</latexit> ⇤ <latexit sha1_base64="tNABXPOwOSdNPd8d79QpMp3Xaiw=">AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4kJKIqMeCCB5bsB/QhrLZTtq1m03Y3Qgl9Bd48aCIV3+SN/+N2zYHbX0w8Hhvhpl5QSK4Nq777aysrq1vbBa2its7u3v7pYPDpo5TxbDBYhGrdkA1Ci6xYbgR2E4U0igQ2ApGt1O/9YRK81g+mHGCfkQHkoecUWOl+l2vVHYr7gxkmXg5KUOOWq/01e3HLI1QGiao1h3PTYyfUWU4EzgpdlONCWUjOsCOpZJGqP1sduiEnFqlT8JY2ZKGzNTfExmNtB5Hge2MqBnqRW8q/ud1UhPe+BmXSWpQsvmiMBXExGT6NelzhcyIsSWUKW5vJWxIFWXGZlO0IXiLLy+T5kXFu6p49cty9TyPowDHcAJn4ME1VOEeatAABgjP8ApvzqPz4rw7H/PWFSefOYI/cD5/AJRHjLk=</latexit> E <latexit sha1_base64="w4rEuAJPetC0TZdhDcULGp4Bzgw=">AAAB6HicbVA9SwNBEJ3zM8avqKXNYhAsJNyJqGXAxsIiAfMByRH2NnPJmr29Y3dPCEd+gY2FIrb+JDv/jZvkCk18MPB4b4aZeUEiuDau++2srK6tb2wWtorbO7t7+6WDw6aOU8WwwWIRq3ZANQousWG4EdhOFNIoENgKRrdTv/WESvNYPphxgn5EB5KHnFFjpfp9r1R2K+4MZJl4OSlDjlqv9NXtxyyNUBomqNYdz02Mn1FlOBM4KXZTjQllIzrAjqWSRqj9bHbohJxapU/CWNmShszU3xMZjbQeR4HtjKgZ6kVvKv7ndVIT3vgZl0lqULL5ojAVxMRk+jXpc4XMiLEllClubyVsSBVlxmZTtCF4iy8vk+ZFxbuqePXLcvU8j6MAx3ACZ+DBNVThDmrQAAYIz/AKb86j8+K8Ox/z1hUnnzmCP3A+fwCe44zA</latexit> L <latexit sha1_base64="TgFUg7KrQLLJ5AipOICK9naEB5E=">AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4kJKIqMeCF4+t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dlZW19Y3Ngtbxe2d3b390sFhU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWj26nfekKleSwfzDhBP6IDyUPOqLFS/b5XKrsVdwayTLyclCFHrVf66vZjlkYoDRNU647nJsbPqDKcCZwUu6nGhLIRHWDHUkkj1H42O3RCTq3SJ2GsbElDZurviYxGWo+jwHZG1Az1ojcV//M6qQlv/IzLJDUo2XxRmApiYjL9mvS5QmbE2BLKFLe3EjakijJjsynaELzFl5dJ86LiXVW8+mW5ep7HUYBjOIEz8OAaqnAHNWgAA4RneIU359F5cd6dj3nripPPHMEfOJ8/p/uMxg==</latexit> R Figure 2: Proof of Theorem 6: Non-balanced schedule σ ∗ and balanced schedule ̃σ obtained by swapping blocks E and L. ̄ S does not alter the overall utility. Moreover, by standard interchange arguments, it is easy to prove that all balanced schedules have identical total utility. We now show that, if a balanced schedule exists then it is optimal for I. Again, under the assumption that I P is a YES instance and hence a balanced schedule σ exists for I, consider an optimal schedule σ ∗ for I which is not balanced. Let A and ̄ A be the sets of jobs process before and, respectively, after job n + 1 in σ ∗ . As a n+1 = M is very large, σ ∗ would schedule n + 1 to start as early as possible, i.e., at its release time r n+1 = B, and there is idle time of length τ ≥ 1 in [0,B]. Since a balanced solution exists, there must be two subsets of jobs E ⊂ A (possibly empty) and ∅̸= L⊂ ̄ A, such that p(L) = p(E) +τ . With no loss of generality (possibly by re-arranging the jobs within A and ̄ A with no loss of utility) we may assume that E and L are scheduled, respectively, as a block of the last consecutive jobs in A and a block of the first consecutive jobs of ̄ A. Let R be the set of remaining jobs processed after L (i.e., R = ̄ A\ L). Now, consider a schedule ̃σ obtained by swapping the blocks E and L and shifting all jobs in R earlier by τ . Then ̃σ has makespan 2B + ̄p and is therefore balanced. Figure 2 illustrates the two schedules σ ∗ and ̃σ. The change in total utility when transforming σ ∗ into ̃σ equals ∆u =−p(E) ̄p + τ + p(E) | z loss for postponing E + p(L) ̄p + p(L) |z gain for advancing L + p(R)τ. | z gain for advancing R Since p(L) = p(E) + τ , simple algebra yields ∆u = p(E) + ̄p + τ + p(R) τ > 0. Hence u( ̃σ) > u(σ ∗ ), contradicting the optimality of σ ∗ . In conclusion, if I P is a YES instance, an optimal schedule for I is balanced and this concludes the proof.□ Similar to the fair-objective case discussed in the previous section, when we focus on the special case in which only one job has a non-zero release date, the problem 1 | r j ,u j | P j u j is weakly NP-hard (in contrast to the general case, which is strongly NP-hard; see Theorem 6). This follows from the fact that one can design a pseudopolynomial dynamic programming algorithm 16 analogous to the one sketched above for 1| r j ,u j | u min . The algorithm iterates over all feasible starting times S of job n + 1, which is the only job with a positive release date r. For each candidate starting time s n+1 , we must decide for every job whether to schedule it before s n+1 or after s n+1 + p n+1 . Within each of the two resulting subsets, jobs must be scheduled in non-increasing order of a j p j , in accordance with Expression (4). A dynamic programming algorithm considers the jobs in this order and proceeds analogously to the case 1 | r j ,u j | u min . Starting from a single initial state (0, 0), the algorithm processes the jobs one by one. For each job j, any existing state (P 1 ,P 2 ) is replaced by the two successor states (P 1 + p j , P 2 ) and/or (P 1 , P 2 + p j ). After all jobs have been processed, the state yielding the maximum total utility is retained as the best solution associated with the candidate value s n+1 . Optimality follows from the prescribed sorting of the jobs. Unit or identical processing times. A well-studied special case in the scheduling literature (Baptiste, 1999, 2000; Chen et al., 2026; Lawler, 1978; Simons, 1978) considers instances in which all processing times are identical, that is, p j = p for all jobs j, or in the even more restricted case, p j = 1. It is important to note that these two assumptions are not equivalent. In what follows, we show that both special cases 1|p j = 1,r j ,u j |u min and 1|p j = p,r j ,u j |u min admit polynomial-time algorithms, although the structural properties of their corresponding optimal solutions differ. When all processing times are unitary, any solution of 1|p j = 1,r j ,u j |u min can be repre- sented solely by the assignment of each job to a unitary time slot corresponding to the com- pletion/starting time of the job. Clearly, this time slot must be feasible, i.e. each job j can be scheduled only in the time slots between its (integer) release date r j and the time slot corre- sponding to the schedule makespan. In searching for an optimal solution of 1|p j = 1,r j ,u j |u min , it is also clear that we may restrict our attention to semi-active schedules in which the makespan is minimum and unnecessary idle times are avoided. Note that the minimum makespan value T can be easily computed—and so are the available time slots for the jobs in any semi-active schedule—as shown below (see Algorithm 3). This property allows for a straightforward algorithmic approach: The solution of the schedul- ing problem corresponds to a bipartite matching between the set of jobs and the time slots identified by the minimum makespan schedule, where each job can only be assigned to time slots not earlier than its release date. The profit of assigning job i to time slot C j is given by u i (C j ). Hence, solving 1|p j = 1,r j ,u j |u min reduces to a linear bottleneck assignment problem, which can be solved in O(n 2.5 / √ logn) time (see Sec. 6.2, Burkard et al., 2012). We can develop a more efficient procedure based on the same principle as Algorithm MaxMinGreedy, introduced in Section 4.2. This procedure is detailed in Algorithm 3. First, the jobs are sorted in non-decreasing order of their release dates, and a semi-active schedule with minimum makespan T is constructed by starting each job as soon as it is released and all its predecessors in the sorted order have been completed (see lines 5–7 of Algorithm 3). Then, starting from the last available time slot and proceeding iteratively (lines 10–18), the algorithm identifies a job j ′ with the highest utility at that time slot among those that can be 17 Algorithm 3 Exact algorithm for 1|p j = 1,r j ,u j |u min 1: Input: set of jobs J = J 1 ,J 2 ,...,J n with release dates r 1 ,r 2 ,...,r n 2: Sort and rename jobs in non-decreasing order of release dates, i.e., r j ≤ r j+1 for j = 1,...,n− 1 This ordering remains valid for all successive subsets 3: pred(j + 1) := j Defines the current job sequence 4: C := 0 5: for j = 1 to n do 6: C := C j := maxr j + 1,C + 1 7: end for 8: T := C n 9: J ′ := J Set of unscheduled jobs 10: Let last denote the index of the last job in J ′ 11: repeat 12: j ′ := j ′ := last j ′ is the candidate job to be scheduled last 13: while C j ′ − 1 > r j ′ do 14:j ′ := pred(j ′ ) 15:if u j ′ (T ) > u j ′ (T ) then 16:j ′ := j ′ 17:end if 18: end while 19:Schedule j ′ at position |J ′ | with C j ′ := T 20: J ′ := J ′ \j ′ 21:Move all jobs ℓ∈ J ′ , ℓ > j ′ , earlier by 1, and update C ℓ , pred, and last 22: T := C last Marks the endpoint of a new block if applicable 23: until |J ′ | = 1 24: Schedule the remaining job in J ′ at position 1 moved to the end of the sequence without increasing the makespan. This relocation is performed only if it is feasible, that is, only if all jobs succeeding j ′ in the current sequence can be moved earlier. Such a shift is possible only when none of these jobs starts exactly at its release date. The while-loop terminates, because the first job is always started at its release date. After identifying such a job j ′ , it is moved to the end of the sequence (line 19), and the set of remaining jobs J ′ and their associated parameters are updated accordingly (lines 20–22). If idle times are present in the original sequence, each resulting block of jobs is implicitly handled; note that such a block always begins with a job starting exactly at its release date. It is straightforward to verify that the running time of Algorithm 3 is O(n 2 ). Hence, we obtain the following result. Theorem 7 The problem with release dates and unit processing times 1|p j = 1,r j ,u j |u min can be solved in O(n 2 ) time. As in the previous case, it is easy to show that determining a system–optimal solution under unit processing times and general utility functions can be straightforwardly reformulated as a linear sum assignment problem. Hence, the following statement holds: Observation 8 The problem with release dates and unit processing times 1|p j = 1,r j ,u j | P u j can be solved in polynomial time. By scaling, the same reasoning also applies to the case p j = p > 1 if p is a common factor of all release dates. However, this does not hold for the case of constant but arbitrary processing times p j = p > 1, which is discussed below. 18 The special case of 1|p j = 1,r j ,u j |u min where u j (C j ) = b j −C j for given constants b j ∈ Z+, j = 1,...,n, is equivalent to the classical scheduling problem 1|p j = 1,r j |L max . For integer- valued release dates, this problem can be efficiently solved in O(n logn) time using the so-called preemptive EDD rule (see Sect. 3.2 in Lenstra and Shmoys, 2020). In the same paper, the authors further observed that the situation where all processing times p j are equal to some arbitrary positive integer p is fundamentally different from the case where p j = 1 for all jobs. Although one can rescale the time to make p = 1, this transformation would generally turn the release dates into rational numbers. This violates the underlying assumption under which it is claimed that the preemptive EDD rule solves the problem 1|p j = 1,r j |L max . A similar situation applies for our problem. Indeed, if all processing times are equal, but not unitary, it may make sense to postpone already released jobs and thereby accrue “unforced” idle times. Thus, the optimal schedule may be a not semi-active schedule. This aspect is illustrated in Figure 3 by an example with two jobs and the following data: r 1 = 0, r 2 = p/2, u 1 = 3p−C 1 , u 2 = 2p− C 2 . The minimum makespan is C max = 2p, reached by assigning first job 1 followed by job 2 starting at time p. For this schedule there is u 1 = 2p and u 2 = 0. Scheduling job 2 first at time r 2 = p/2 and job 1 later, namely at time 3p/2, leaves the machine idle from time 0 to p/2 although job 1 is already released. It gives u 1 = u 2 = p/2 which is a better objective function value. u 1 u 2 C j p 2p3p p/2 p/2 p Figure 3: Example to illustrate that idle times may be useful. Schedule⟨1, 2⟩ without idle times in red, optimal schedule ⟨2, 1⟩ with idle time in blue. Therefore, the iterative greedy approach described above is no longer applicable, as it relies on knowing the total completion time of all jobs. Nevertheless, a polynomial-time solution can still be obtained by performing a binary search over the objective function values and exploiting a result from the literature to solve the resulting subproblem. In particular, Carlier developed an algorithm for the problem of minimizing the total number of late jobs with release dates and equal processing times 1|p j = p,r j | P U j , which runs in O(n 3 logn) time (Baptiste, 1999; Carlier, 1981). Accordingly, for a given target value u T within the feasible range of objective values, we can repeatedly apply Carlier’s algorithm with job due dates defined as in Expression (5), and 19 combine this with the general binary search framework presented in Section 4.1 to address our problem variant. In conclusion, the following result holds. Theorem 9 Problem 1|p j = p,r j ,u j |u min can be solved in polynomial time O(n 3 logn log(UB− LB)) where UB and LB are, respectively, upper and lower bounds on the objective values. Note that the problem under consideration can be reformulated as the standard scheduling problem of minimizing the maximum value of a regular objective function in the presence of release dates and identical processing times. In particular, the above result generalizes the work of Lenstra and Shmoys (2020, Sect. 3.3), who studied the specific case of minimizing maximum lateness, i.e., 1|p j = p,r j |L max . They proposed an algorithm with running time O(n 3 log 2 n), which is tailored to the L max objective only. Their approach relies on a more sophisticated technique, namely an iterative application of the earliest due date (EDD) rule, which allows the problem to be decomposed and solved efficiently under that objective. As for the corresponding system-optimal solution σ SYS , Baptiste (2000) presents a O(n 5 ) dynamic programming algorithm to minimize total weighted completion time for single machine scheduling problems with release dates and equal-length processing times. We may then state: Observation 10 Problem 1|p j = p,r j ,u j = b j − a j C j | P u j can be solved in polynomial time. 4.4 Due dates We now turn our attention to the problem in which each job j is associated also with a due date d j . Hereafter, we use the well-known notation U j to denote whether job j is late or not, where U j = 1 if job j is late (i.e., C j > d j ) and U j = 0 otherwise. We first assume that there exists a schedule in which all jobs can meet their due dates, that is, the EDD rule produces a schedule without late jobs. In this case, the entire schedule contains no idle time. For this setting, a simple variation of algorithm MaxMinGreedy can be applied. We consider all due dates as deadlines and, at each iteration corresponding to a time step T , we restrict attention to the unscheduled jobs with deadlines satisfying d j ≥ T . The correctness of this approach follows from the same arguments used in the proof of Theorem 2, applied to the restricted set of feasible jobs J at each time step. Theorem 11 Problem 1| P U j ≤ k, u j = b j −a j C j |u min , in the special case where all jobs can be completed on time (i.e., k = 0), is polynomially solvable. Moreover, an optimal schedule can be computed in O(n 2 ) time. We now consider the case in which every feasible schedule necessarily contains late jobs. In this situation, we may assume that all late jobs receive a constant utility (strictly smaller than the utility obtainable before the due date, and possibly equal to 0). This setting can be represented by a non-increasing (not necessarily continuous) utility function, and thus the result of Theorem 2 continues to apply. Next, we consider the more standard due-date setting in which all late jobs are discarded, that is, they contribute no utility to the objective function. To prevent an excessive “waste of 20 jobs”, we impose an upper bound k on the number of late jobs (equivalently, a lower bound of n− k on the number of jobs that must be completed on time). Clearly, this requirement is meaningful only if k ≥ U ∗ , where U ∗ denotes the minimum possible number of late jobs as can be obtained using Moore’s algorithm (Moore, 1968). We can now apply a variation of the general approach described in Section 4.1. For a given target utility value u T , we determine, for each job j, the latest completion time at which job j still finishes on time while achieving utility at least u T . Accordingly, we define updated due dates d T j := mind j ,u −1 j (u T ) meaning that any job completed by time d T j is both on time and satisfies the target utility requirement. We then apply Moore’s algorithm (running in O(n logn) time) to the instance with modified due dates d T j , yielding k T late jobs. If k T > k, we decrease the target utility u T , whereas if k T ≤ k, we may increase it. Hence, we obtain the following result for the problem variant with a bounded number of late jobs. Theorem 12 Problem 1| P U j ≤ k, u j = b j − a j C j |u min i.e., determining the minimum utility attained by any on-time job under the constraint that at most k jobs may be tardy, can be solved in O(n logn log(UB− LB)) time, where UB and LB are, respectively, upper and lower bounds on the objective value. Following the previous theorem, it is natural to ask whether an analogous polynomial-time result can be obtained when the objective is to maximize the total utility. Somewhat surpris- ingly, the situation is now fundamentally different from what happens with other versions of the problem. In fact, while the min-utility problem with at most k tardy jobs is solvable in poly- nomial time, the corresponding problem of seeking a system optimum turns out to be strongly NP-hard. This problem is equivalent to minimizing the total weighted completion time subject to deadline constraints. Chen et al. (1998) state that minimizing the weighted sum of completion times with deadlines is strongly NP-hard, and they attribute this to Lenstra et al. (1977). However, the paper by Lenstra et al. establishes only weak NP-hardness via a reduction from the knapsack problem. For the setting considered here, we provide a direct proof showing that the problem is indeed strongly NP-hard. Theorem 13 Problem 1| P U j ≤ k, u j = b j − a j C j | P u j that is, maximizing the total utility of on-time jobs under the constraint that at most k jobs may be tardy, is strongly NP-hard. Proof. In order to prove the thesis, we reduce 3-Partition to our problem. So, given an instance I 3P of 3-Partition, with 3n integers, w 1 ,...,w 3n , such that P 3n j=1 w j = W = nT and T/4 < w j < T/2 for j = 1,..., 3n, we generate an instance I of problem 1| P U j ≤ k,u j = b j − a j C j | P u j as follows. In instance I there are 4n− 1 +k jobs and the maximum number of allowed late jobs is k ≥ 0. The idea, in the reduction, is that the first 3n jobs (“item-jobs”) correspond to the integers of I 3P , the next n− 1 jobs are used for the reduction as “separators” of the schedule, and the last 21 k “long” jobs are those who are late in any feasible schedule. So, in instance I we have p j = w j for j = 1,..., 3n M for j = 3n + 1,..., 4n− 1 Lfor j = 4n,..., 4n− 1 + k where M > 0 and L≥ nT + (n− 1)M =: E are given integers. Moreover, d j = Efor j = 1,..., 3n (j− 3n)(T + M ) for j = 3n + 1,..., 4n− 1 Lfor j = 4n,..., 4n− 1 + k. Note that at most one long job can meet its deadline; however, if this happens it would be the only on-time job in the schedule, since L ≥ E. This would make the solution infeasible, since more than k jobs would then be late. As a consequence, in any feasible solution the k long jobs will be the late ones, while all the other 4n− 1 jobs (item and separation jobs) must be on time. The jobs’ utility functions for instance I are defined as u j (C j ) = ( H − w j C j for j = 1, 2,..., 3n 0for j = 3n + 1,..., 4n− 1 + k with H large enough to guarantee nonnegative utilities of the item-jobs over all the schedule’s span (e.g., H ≥ max j w j · E). Observe that any feasible schedule σ for I can be seen as a sequence of n (possibly empty) blocks B i ⊆1,..., 3n, i = 1,...,n, of item-jobs divided by the n−1 separators 3n+1,..., 4n− 1, followed by the k late long jobs: ⟨B 1 , 3n + 1,B 2 , 3n + 2,..., 4n− 1,B n , 4n,..., 4n− 1 + k⟩. Recalling that the contribution of the late jobs and that of the separators to the total utility is null, the objective function value for schedule σ can be expressed as P 3n j=1 u j (σ) = 3nH − P 3n j=1 w j C j . Hence, an optimal solution for I is obtained minimizing P 3n j=1 w j C j . Let W i = P j∈B i w j denote the total processing time of block i, and let s i denote its starting time. We write i≺ j (respectively, i≼ j) to indicate that job i precedes (respectively, precedes or is equal to) job j in the schedule σ. Then: 3n X j=1 w j C j = n X i=1 X j∈B i w j s i + X ℓ∈B i ℓ≼j w ℓ = n X i=1 X j∈B i w j (i− 1)M + X ℓ∈∪ i−1 r=1 B r w ℓ + w j X ℓ∈B i ℓ≼j w ℓ = (6) = n X i=1 M (i− 1) X j∈B i w j + X j∈B i w j X ℓ∈1,...,3n ℓ≼j w ℓ =(7) = M n X i (i− 1)W i + 3n X j=1 w 2 j + 3n X j=1 3n X ℓ=1 ℓ<j w j w ℓ = M n X i=1 (i− 1)W i + 1 2 3n X j=1 w 2 j + W 2 .(8) Note that the double sum P j P ℓ w j w ℓ in (8) is equal to the sum of the 3n 2 products w i w j 22 with i and j distinct jobs. Moreover, observe that the last term 1 2 (· ) in the same equation is independent of the composition of the blocks and depends only on the specific values of w j . Therefore, for a given instance I with fixed w j values, the decision problem reduces to determining the composition of the blocks B i so as to minimize the term P n i=1 (i− 1)W i . Due to the increasing coefficients in the summation P n i=1 (i − 1)W i , an optimal solution packs as much units of processing time as possible in the earlier blocks, while ensuring that the separators are not late. <latexit sha1_base64="q4EO+q8Nc2FLWGShS0FHvDvVYDI=">AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBahp5KIqMeCCB5bsLXQhrLZTtq1m03Y3Qgl9Bd48aCIV3+SN/+N2zYHbX0w8Hhvhpl5QSK4Nq777RTW1jc2t4rbpZ3dvf2D8uFRW8epYthisYhVJ6AaBZfYMtwI7CQKaRQIfAjGNzP/4QmV5rG8N5ME/YgOJQ85o8ZKzdt+ueLW3DnIKvFyUoEcjX75qzeIWRqhNExQrbuemxg/o8pwJnBa6qUaE8rGdIhdSyWNUPvZ/NApObPKgISxsiUNmau/JzIaaT2JAtsZUTPSy95M/M/rpia89jMuk9SgZItFYSqIicnsazLgCpkRE0soU9zeStiIKsqMzaZkQ/CWX14l7fOad1nzmheVejWPowgncApV8OAK6nAHDWgBA4RneIU359F5cd6dj0VrwclnjuEPnM8fkxOMtQ==</latexit> E <latexit sha1_base64="LvSmUOmmfGl0suFL71j4nQTkiLY=">AAAB6HicbVBNS8NAEJ34WetX1aOXxSL0VBIR9Vjw4rGFfkEbymY7adduNmF3I5TQX+DFgyJe/Une/Ddu2xy09cHA470ZZuYFieDauO63s7G5tb2zW9gr7h8cHh2XTk7bOk4VwxaLRay6AdUouMSW4UZgN1FIo0BgJ5jcz/3OEyrNY9k00wT9iI4kDzmjxkqN5qBUdqvuAmSdeDkpQ476oPTVH8YsjVAaJqjWPc9NjJ9RZTgTOCv2U40JZRM6wp6lkkao/Wxx6IxcWmVIwljZkoYs1N8TGY20nkaB7YyoGetVby7+5/VSE975GZdJalCy5aIwFcTEZP41GXKFzIipJZQpbm8lbEwVZcZmU7QheKsvr5P2VdW7qXqN63KtksdRgHO4gAp4cAs1eIA6tIABwjO8wpvz6Lw4787HsnXDyWfO4A+czx+pz4zE</latexit> T <latexit sha1_base64="YHwQGyBJLDnLyYmxskFP2ba/D8o=">AAAB63icbVBNSwMxEJ2tX7V+VT16CRahIJTdIuqx4MWLUKFf0C4lm2b0CS7JFmhLP0LXjwo4tU/5M1/Y7bdg7Y+GHi8N8PMvCDmTBvX/XYKG5tb2zvF3dLe/sHhUfn4pKOjRBHaJhGPVC/AmnImadsww2kvVhSLgNNuML3L/O4TVZpFsmVmMfUFHksWMoJNJtVblw/DcsWtuQugdeLlpAI5msPy12AUkURQaQjHWvc9NzZ+ipVhhNN5aZBoGmMyxWPat1RiQbWfLm6dowurjFAYKVvSoIX6eyLFQuuZCGynwGaiV71M/M/rJya89VMm48RQSZaLwoQjE6HscTRiihLDZ5Zgopi9FZEJVpgYG0/JhuCtvrxOOvWad13zHq8qjWoeRxHO4Byq4MENNOAemtAGAhN4hld4c4Tz4rw7H8vWgpPPnMIfOJ8/G7CNjA==</latexit> 2T+M <latexit sha1_base64="JNDOlWyVMGcrwrQ/M1v4MZlLT94=">AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBahp5KIqMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1Fip6Q7KFbfmLkDWiZeTCuRoDMpf/WHM0gilYYJq3fPcxPgZVYYzgbNSP9WYUDahI+xZKmmE2s8Wh87IhVWGJIyVLWnIQv09kdFI62kU2M6ImrFe9ebif14vNeGtn3GZpAYlWy4KU0FMTOZfkyFXyIyYWkKZ4vZWwsZUUWZsNiUbgrf68jppX9a865rXvKrUq3kcRTiDc6iCBzdQh3toQAsYIDzDK7w5j86L8+58LFsLTj5zCn/gfP4Acz+MoA==</latexit> 0 <latexit sha1_base64="kRd/9BJOCpol9R0LCjw+p7crYlc=">AAAB8HicbVC7SgNBFJ31GeMramkzJAhWYTeFWgZsLCOYhyRLmJ3MJkPmsczcFcKSr7CxUMTWz7Hzb5xNttDEAwOHc+69c++JEsEt+P63t7G5tb2zW9or7x8cHh1XTk47VqeGsjbVQpteRCwTXLE2cBCslxhGZCRYN5re5n73iRnLtXqAWcJCScaKx5wScNKjZQkxBLQZVmp+3V8Ar5OgIDVUoDWsfA1GmqaSKaCCWNsP/ATCjBjgVLB5eZDms+mUjFnfUUUks2G2WHiOL5wywrE27inAC/V3R0aktTMZuUpJYGJXvVz8z+unEN+EGVdJCkzR5UdxKjBonF+PR9wwCmLmCKGGu10xnbgEKLiMyi6EYPXkddJp1IOrenDfqDWrRRwldI6q6BIF6Bo10R1qoTaiSKJn9IrePOO9eO/ex7J0wyt6ztAfeJ8/J7iQiQ==</latexit> separator <latexit sha1_base64="kRd/9BJOCpol9R0LCjw+p7crYlc=">AAAB8HicbVC7SgNBFJ31GeMramkzJAhWYTeFWgZsLCOYhyRLmJ3MJkPmsczcFcKSr7CxUMTWz7Hzb5xNttDEAwOHc+69c++JEsEt+P63t7G5tb2zW9or7x8cHh1XTk47VqeGsjbVQpteRCwTXLE2cBCslxhGZCRYN5re5n73iRnLtXqAWcJCScaKx5wScNKjZQkxBLQZVmp+3V8Ar5OgIDVUoDWsfA1GmqaSKaCCWNsP/ATCjBjgVLB5eZDms+mUjFnfUUUks2G2WHiOL5wywrE27inAC/V3R0aktTMZuUpJYGJXvVz8z+unEN+EGVdJCkzR5UdxKjBonF+PR9wwCmLmCKGGu10xnbgEKLiMyi6EYPXkddJp1IOrenDfqDWrRRwldI6q6BIF6Bo10R1qoTaiSKJn9IrePOO9eO/ex7J0wyt6ztAfeJ8/J7iQiQ==</latexit> separator <latexit sha1_base64="wCfTMKhd8e2Ga4as30QBP+eTFsQ=">AAAB8HicbVDLSgNBEJyNrxhfUY9ehgTBU9jNQT0GvHiMYB6SLGF20puMmccyMyuEJV/hxYMiXv0cb/6Nk2QPmljQUFR1090VJZwZ6/vfXmFjc2t7p7hb2ts/ODwqH5+0jUo1hRZVXOluRAxwJqFlmeXQTTQQEXHoRJObud95Am2Ykvd2mkAoyEiymFFinfTAiQX8qCIzKFf9mr8AXidBTqooR3NQ/uoPFU0FSEs5MaYX+IkNM6ItoxxmpX5qICF0QkbQc1QSASbMFgfP8LlThjhW2pW0eKH+nsiIMGYqItcpiB2bVW8u/uf1UhtfhxmTSWpB0uWiOOXYKjz/Hg+ZBmr51BFCNXO3YjommlDrMiq5EILVl9dJu14LLmvBXb3aqORxFNEZqqALFKAr1EC3qIlaiCKBntErevO09+K9ex/L1oKXz5yiP/A+fwCZSZAs</latexit> latejobs <latexit sha1_base64="YOLNUNqtJUSTWyZ18xgAz3HgOlA=">AAAB8XicbVBNSwMxEJ31s9avqkcvwSIUhLIrol6EghcvQoV+YbuUbDbbhibZJckKZem/8OJBEa/+G2/+G9N2D9r6YODx3gwz84KEM21c99tZWV1b39gsbBW3d3b39ksHhy0dp4rQJol5rDoB1pQzSZuGGU47iaJYBJy2g9Ht1G8/UaVZLBtmnFBf4IFkESPYWOkx7GeeO7lpnN33S2W36s6AlomXkzLkqPdLX70wJqmg0hCOte56bmL8DCvDCKeTYi/VNMFkhAe0a6nEgmo/m108QadWCVEUK1vSoJn6eyLDQuuxCGynwGaoF72p+J/XTU107WdMJqmhkswXRSlHJkbT91HIFCWGjy3BRDF7KyJDrDAxNqSiDcFbfHmZtM6r3mXVe7go1yp5HAU4hhOogAdXUIM7qEMTCEh4hld4c7Tz4rw7H/PWFSefOYI/cD5/AEqmj+8=</latexit> d 10 =T+M <latexit sha1_base64="it0YVbL64nD6lfRWt3HhhqCg50c=">AAAB9HicbVBNS8NAEJ3Ur1q/qh69LBahIpSkiHoRCl68CBX6BW0om82mXbrZxN1NoYT+Di8eFPHqj/Hmv3Hb5qCtDwYe780wM8+LOVPatr+t3Nr6xuZWfruws7u3f1A8PGqpKJGENknEI9nxsKKcCdrUTHPaiSXFocdp2xvdzfz2mErFItHQk5i6IR4IFjCCtZFcv586zvS2Wm5cPJz3iyW7Ys+BVomTkRJkqPeLXz0/IklIhSYcK9V17Fi7KZaaEU6nhV6iaIzJCA9o11CBQ6rcdH70FJ0ZxUdBJE0Jjebq74kUh0pNQs90hlgP1bI3E//zuokObtyUiTjRVJDFoiDhSEdolgDymaRE84khmEhmbkVkiCUm2uRUMCE4y+vkla14lxVnMfLUq2cxZGHEziFMjhwDTW4hzo0gcATPMMrvFlj68V6tz4WrTkrmzmGP7A+fwCLJpCR</latexit> d 11 =2(T+M) <latexit sha1_base64="q4EO+q8Nc2FLWGShS0FHvDvVYDI=">AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBahp5KIqMeCCB5bsLXQhrLZTtq1m03Y3Qgl9Bd48aCIV3+SN/+N2zYHbX0w8Hhvhpl5QSK4Nq777RTW1jc2t4rbpZ3dvf2D8uFRW8epYthisYhVJ6AaBZfYMtwI7CQKaRQIfAjGNzP/4QmV5rG8N5ME/YgOJQ85o8ZKzdt+ueLW3DnIKvFyUoEcjX75qzeIWRqhNExQrbuemxg/o8pwJnBa6qUaE8rGdIhdSyWNUPvZ/NApObPKgISxsiUNmau/JzIaaT2JAtsZUTPSy95M/M/rpia89jMuk9SgZItFYSqIicnsazLgCpkRE0soU9zeStiIKsqMzaZkQ/CWX14l7fOad1nzmheVejWPowgncApV8OAK6nAHDWgBA4RneIU359F5cd6dj0VrwclnjuEPnM8fkxOMtQ==</latexit> E <latexit sha1_base64="LvSmUOmmfGl0suFL71j4nQTkiLY=">AAAB6HicbVBNS8NAEJ34WetX1aOXxSL0VBIR9Vjw4rGFfkEbymY7adduNmF3I5TQX+DFgyJe/Une/Ddu2xy09cHA470ZZuYFieDauO63s7G5tb2zW9gr7h8cHh2XTk7bOk4VwxaLRay6AdUouMSW4UZgN1FIo0BgJ5jcz/3OEyrNY9k00wT9iI4kDzmjxkqN5qBUdqvuAmSdeDkpQ476oPTVH8YsjVAaJqjWPc9NjJ9RZTgTOCv2U40JZRM6wp6lkkao/Wxx6IxcWmVIwljZkoYs1N8TGY20nkaB7YyoGetVby7+5/VSE975GZdJalCy5aIwFcTEZP41GXKFzIipJZQpbm8lbEwVZcZmU7QheKsvr5P2VdW7qXqN63KtksdRgHO4gAp4cAs1eIA6tIABwjO8wpvz6Lw4787HsnXDyWfO4A+czx+pz4zE</latexit> T <latexit sha1_base64="YHwQGyBJLDnLyYmxskFP2ba/D8o=">AAAB63icbVBNSwMxEJ2tX7V+VT16CRahIJTdIuqx4MWLUKFf0C4lm2b0CS7JFmhLP0LXjwo4tU/5M1/Y7bdg7Y+GHi8N8PMvCDmTBvX/XYKG5tb2zvF3dLe/sHhUfn4pKOjRBHaJhGPVC/AmnImadsww2kvVhSLgNNuML3L/O4TVZpFsmVmMfUFHksWMoJNJtVblw/DcsWtuQugdeLlpAI5msPy12AUkURQaQjHWvc9NzZ+ipVhhNN5aZBoGmMyxWPat1RiQbWfLm6dowurjFAYKVvSoIX6eyLFQuuZCGynwGaiV71M/M/rJya89VMm48RQSZaLwoQjE6HscTRiihLDZ5Zgopi9FZEJVpgYG0/JhuCtvrxOOvWad13zHq8qjWoeRxHO4Byq4MENNOAemtAGAhN4hld4c4Tz4rw7H8vWgpPPnMIfOJ8/G7CNjA==</latexit> 2T+M <latexit sha1_base64="JNDOlWyVMGcrwrQ/M1v4MZlLT94=">AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBahp5KIqMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1Fip6Q7KFbfmLkDWiZeTCuRoDMpf/WHM0gilYYJq3fPcxPgZVYYzgbNSP9WYUDahI+xZKmmE2s8Wh87IhVWGJIyVLWnIQv09kdFI62kU2M6ImrFe9ebif14vNeGtn3GZpAYlWy4KU0FMTOZfkyFXyIyYWkKZ4vZWwsZUUWZsNiUbgrf68jppX9a865rXvKrUq3kcRTiDc6iCBzdQh3toQAsYIDzDK7w5j86L8+58LFsLTj5zCn/gfP4Acz+MoA==</latexit> 0 <latexit sha1_base64="wCfTMKhd8e2Ga4as30QBP+eTFsQ=">AAAB8HicbVDLSgNBEJyNrxhfUY9ehgTBU9jNQT0GvHiMYB6SLGF20puMmccyMyuEJV/hxYMiXv0cb/6Nk2QPmljQUFR1090VJZwZ6/vfXmFjc2t7p7hb2ts/ODwqH5+0jUo1hRZVXOluRAxwJqFlmeXQTTQQEXHoRJObud95Am2Ykvd2mkAoyEiymFFinfTAiQX8qCIzKFf9mr8AXidBTqooR3NQ/uoPFU0FSEs5MaYX+IkNM6ItoxxmpX5qICF0QkbQc1QSASbMFgfP8LlThjhW2pW0eKH+nsiIMGYqItcpiB2bVW8u/uf1UhtfhxmTSWpB0uWiOOXYKjz/Hg+ZBmr51BFCNXO3YjommlDrMiq5EILVl9dJu14LLmvBXb3aqORxFNEZqqALFKAr1EC3qIlaiCKBntErevO09+K9ex/L1oKXz5yiP/A+fwCZSZAs</latexit> latejobs <latexit sha1_base64="YOLNUNqtJUSTWyZ18xgAz3HgOlA=">AAAB8XicbVBNSwMxEJ31s9avqkcvwSIUhLIrol6EghcvQoV+YbuUbDbbhibZJckKZem/8OJBEa/+G2/+G9N2D9r6YODx3gwz84KEM21c99tZWV1b39gsbBW3d3b39ksHhy0dp4rQJol5rDoB1pQzSZuGGU47iaJYBJy2g9Ht1G8/UaVZLBtmnFBf4IFkESPYWOkx7GeeO7lpnN33S2W36s6AlomXkzLkqPdLX70wJqmg0hCOte56bmL8DCvDCKeTYi/VNMFkhAe0a6nEgmo/m108QadWCVEUK1vSoJn6eyLDQuuxCGynwGaoF72p+J/XTU107WdMJqmhkswXRSlHJkbT91HIFCWGjy3BRDF7KyJDrDAxNqSiDcFbfHmZtM6r3mXVe7go1yp5HAU4hhOogAdXUIM7qEMTCEh4hld4c7Tz4rw7H/PWFSefOYI/cD5/AEqmj+8=</latexit> d 10 =T+M <latexit sha1_base64="it0YVbL64nD6lfRWt3HhhqCg50c=">AAAB9HicbVBNS8NAEJ3Ur1q/qh69LBahIpSkiHoRCl68CBX6BW0om82mXbrZxN1NoYT+Di8eFPHqj/Hmv3Hb5qCtDwYe780wM8+LOVPatr+t3Nr6xuZWfruws7u3f1A8PGqpKJGENknEI9nxsKKcCdrUTHPaiSXFocdp2xvdzfz2mErFItHQk5i6IR4IFjCCtZFcv586zvS2Wm5cPJz3iyW7Ys+BVomTkRJkqPeLXz0/IklIhSYcK9V17Fi7KZaaEU6nhV6iaIzJCA9o11CBQ6rcdH70FJ0ZxUdBJE0Jjebq74kUh0pNQs90hlgP1bI3E//zuokObtyUiTjRVJDFoiDhSEdolgDymaRE84khmEhmbkVkiCUm2uRUMCE4y+vkla14lxVnMfLUq2cxZGHEziFMjhwDTW4hzo0gcATPMMrvFlj68V6tz4WrTkrmzmGP7A+fwCLJpCR</latexit> d 11 =2(T+M) <latexit sha1_base64="w+70hOqO90S8ZEEYQWd4N2gbnUY=">AAAB6nicbVBNS8NAEJ3Ur1q/qh69LBahp5KIqMeiF48V7Qe0oWy2k3bpZhN2N0IJ/QlePCji1V/kzX/jts1BWx8MPN6bYWZekAiujet+O4W19Y3NreJ2aWd3b/+gfHjU0nGqGDZZLGLVCahGwSU2DTcCO4lCGgUC28H4dua3n1BpHstHM0nQj+hQ8pAzaqz0cNP3+uWKW3PnIKvEy0kFcjT65a/eIGZphNIwQbXuem5i/Iwqw5nAaamXakwoG9Mhdi2VNELtZ/NTp+TMKgMSxsqWNGSu/p7IaKT1JApsZ0TNSC97M/E/r5ua8NrPuExSg5ItFoWpICYms7/JgCtkRkwsoUxxeythI6ooMzadkg3BW355lbTOa95lzbu/qNSreRxFOIFTqIIHV1CHO2hAExgM4Rle4c0Rzovz7nwsWgtOPnMMf+B8/gCzg41W</latexit> B 1 <latexit sha1_base64="foKhoP5TzokSDl3ND50+SYq2euo=">AAAB6nicbVBNS8NAEJ3Ur1q/qh69LBahp5IUUY9FLx4r2lpoQ9lsN+3SzSbsToQS+hO8eFDEq7/Im//GbZuDtj4YeLw3w8y8IJHCoOt+O4W19Y3NreJ2aWd3b/+gfHjUNnGqGW+xWMa6E1DDpVC8hQIl7ySa0yiQ/DEY38z8xyeujYjVA04S7kd0qEQoGEUr3V/36/1yxa25c5BV4uWkAjma/fJXbxCzNOIKmaTGdD03QT+jGgWTfFrqpYYnlI3pkHctVTTixs/mp07JmVUGJIy1LYVkrv6eyGhkzCQKbGdEcWSWvZn4n9dNMbzyM6GSFLlii0VhKgnGZPY3GQjNGcqJJZRpYW8lbEQ1ZWjTKdkQvOWXV0m7XvMuat7deaVRzeMowgmcQhU8uIQG3EITWsBgCM/wCm+OdF6cd+dj0Vpw8plj+APn8we1B41X</latexit> B 2 <latexit sha1_base64="/zxE8WkyjKAefXdHHxRQ3/2ya5w=">AAAB6nicbVBNS8NAEJ3Ur1q/qh69LBahp5KoqMeiF48V7Qe0oWy2m3bpZhN2J0IJ/QlePCji1V/kzX/jts1Bqw8GHu/NMDMvSKQw6LpfTmFldW19o7hZ2tre2d0r7x+0TJxqxpsslrHuBNRwKRRvokDJO4nmNAokbwfjm5nffuTaiFg94CThfkSHSoSCUbTS/X/rF+uuDV3DvKXeDmpQI5Gv/zZG8QsjbhCJqkxXc9N0M+oRsEkn5Z6qeEJZWM65F1LFY248bP5qVNyYpUBCWNtSyGZqz8nMhoZM4kC2xlRHJllbyb+53VTDK/8TKgkRa7YYlGYSoIxmf1NBkJzhnJiCWVa2FsJG1FNGdp0SjYEb/nlv6R1WvMuat7deaVezeMowhEcQxU8uIQ63EIDmsBgCE/wAq+OdJ6dN+d90Vpw8plD+AXn4xu2i41Y</latexit> B 3 Figure 4: Optimal schedules corresponding to a yes-instance (above) and a no-instance of 3- Partition with n = 3. If I 3P is a yes-instance, then we are in an ideal configuration (illustrated by the upper chart in Figure 4) in which we may set W i = T = W n for all i = 1,...,n. Thus, each block is assigned exactly the length necessary to force every separator job in the sequence to complete exactly at its designated deadline. In this case, by (8), the value u YES of an optimal solution σ SYS to instance I, under the assumption that I 3P is a Yes-instance, is given by: u YES = 3nH − 1 2 3n X j=1 w 2 j + W 2 − M W n n X i=1 (i− 1) = 3nH − 1 2 3n X j=1 w 2 j + W 2 − 1 2 (MW (n− 1)).(9) If I 3P is a no-instance, then there must exist a block i ∈ 1,...,n such that the sequence of blocks consists of W ℓ = T , for ℓ = 1,...,i− 1, and W i < T (see the lower chart in Figure 4 for i = 2). This means that at least one unit of processing time must be shifted from block i to a later block, which is associated with a strictly larger coefficient in P 3n j=1 w j C j . Because of the deadlines assigned to the separator jobs, any increase in P 3n j=1 w j C j cannot be compensated in later blocks: the amount by which a block can exceed T is limited by the slack created when earlier blocks finish before T . Thus, the optimal utility u SYS decreases by at least M compared to u YES in (9). In conclusion, I 3P is a yes-instance if and only if the optimal utility value u SYS of the corresponding instance I of 1| P U j ≤ k| P u j is not larger than u YES .□ 23 5 Adjustable linear utility functions The idea of modifying or adjusting problem parameters in order to improve system performance has been extensively studied in the scheduling and optimization literature under the general framework of controllable processing times or, more broadly, controllable parameters. In these models, one can alter certain job characteristics, typically at some cost or within a given budget, in order to achieve a more desirable schedule or objective value (Biskup, 2008; Gordon et al., 2002; Huang and Wang, 2014; Lu et al., 2015; Gawiejnowicz, 2008; Cheng et al., 2006; Shabtay and Steiner, 2007). Motivated by this line of research, we study how controlled adjustments to the utility func- tions of individual jobs can improve the overall performance criterion. Throughout this section, we restrict attention to linear utility functions of the form u j = b j −a j C j , with a j ≥ 0 for every job j which represent decreasing valuations as completion times increase. We first examine the setting in which a fixed global bound is imposed on the total amount of permissible modifica- tion. We then turn to a complementary framework in which utilities may be adjusted subject to a fixed “area” constraint, reflecting situations where improvements must be distributed in a balanced manner among the agents. Across the next two sections, we consider two natural types of modifications: increasing the intercepts b j , and decreasing the negative slopes a j . Both operations enhance the utilities of on-time jobs, and our goal is to raise the maximum minimum utility achieved across all agents. Since such modifications cannot be made arbitrarily large, we assume a global budget or capacity constraint that limits the total amount of allowed change. Note that the natural analogy of these problems with fairness replaced by efficiency can be solved in a rather straightforward way. 5.1 Modifications of the intercepts b j Problem 1|u j = ̃ b j −a j C j |u min . At first, we consider increasing each b j by some ∆b j such that the total increase is bounded by the given budget bound B, i.e., P j ∆b j ≤ B with ∆b j ≥ 0. There is an iterative algorithm to apply this increase (with the technical assumption that a j > 0) as follows. Starting with ∆b j = 0 for j = 1,...,n, we define J as the set of all jobs attaining the lowest utility value in the current schedule. In the beginning, we will usually have |J| = 1, say J = j ′ . (It is trivial to extend the procedure in the case |J| > 1.) We start by increasing ∆b j ′ until the increased utility of j ′ matches the second largest utility value of some job j ′ , or the increase ∆b j ′ = B, in which case we stop. Otherwise, insert j ′ into J . We proceed by increasing all ∆b ℓ for ℓ∈ J uniformly until the increased utility reaches the lowest utility of any job not in J , which is then added to J , or until P ℓ∈J ∆b ℓ = B. The latter case would end the procedure, in the former case we iterate. Note that this modification process does not change the sequence of jobs as given initially by MaxMinGreedy. To see that consider any job j ′ for which ∆b j ′ is increased. For any job i ̸∈ J with C i < C j ′ the algorithm did not schedule i at time C j ′ since u i (C j ′ ) ≤ u j ′ (C j ′ ). Clearly, increasing ∆b j ′ will only strengthen this condition. For any job k ̸∈ J with C k > C j ′ the increase of ∆b j ′ would stop (at the latest) when u j ′ (C j ′ ) = u k (C k ) is reached. Since utilities are decreasing functions also after this increase we still have u k (C k )≥ u j ′ (C k ) and the decision 24 of MaxMinGreedy remains unchanged. 1 Comparing job j ′ with any job in J it is clear that the utilities of both jobs are increased uniformly and thus their differences in utility remain unchanged for any completion time. This approach works not only for linear utility functions but also for arbitrary utilities, where the increase ∆b j is added to the given utility u j (C). The corresponding procedure will be utilized in the proof of Theorem 16. While the above procedure can be easily performed in O(n 2 ) time, we can also do better. Given a sequence of jobs, the problem actually asks for a break job j b , such that for all jobs j with u j ≤ u j b the intercepts b j are increased to reach a common utility value at least u j b , while all jobs j with u j > u j b remain unchanged. This task can be solved in O(n) by a variant of the linear time median algorithm (proceed in the same way as finding the split item for the knapsack problem in linear time, (Kellerer et al., 2004, Sect. 3.1) It should be noted that if we allow also ∆b j < 0 the problem will always end up with a solution where all utility values are equal. Only the level of this joint utility value depends on B. Assuming otherwise, we could reduce the value ∆b j for any job j with utility larger than the current minimal utility and use the resulting excess in the budget constraint to increase the ∆b ℓ values for all ℓ∈ J , thus improving the minimum utility. Also in this case the sequence of the jobs is not affected by reducing some b j value. This is trivial for jobs completing after job j and also clear for jobs completing earlier than j since j is chosen as the job with highest utility. If its decrease would reach a tie with jobs scheduled earlier, these jobs have a higher utility at their current position due to the nonincreasing utility functions and thus the algorithm would move stopped decreasing j and proceeded with those jobs instead. 5.2 Modifications of the slopes a j Problem 1|u j = b j − ̃a j C j |u min . We apply the same concept to a decrease of the slopes a j by considering values ∆a j ≥ 0 with P j ∆a j ≤ A and modified utilities given by u j = b j − ̃a j C j = b j − (a j − ∆a j )C j . To preserve the property of nonincreasing utilities we will impose ∆a j ≤ a j . We can give an iterative algorithm quite similar to the above case where we chose the ∆b j values. As before, we start with the job j ′ having the lowest utility value in the schedule given by MaxMinGreedy and increase ∆a j ′ until the increased utility of j ′ reaches some j ′ . The same procedure as above applies although the increase for the ∆a ℓ values for ℓ ∈ J is not uniform. To reach any new common lowest utility value ̄u, one has to set ∆a ℓ := a ℓ − b ℓ − ̄u C ℓ for each ℓ∈ J . Note that one can stop the procedure as soon as some job ℓ∈ J reaches ∆a ℓ = a ℓ , since at this point the utility of job ℓ cannot be improved anymore. The above arguments, that the sequence of jobs is not affected by these modifications, still hold. For jobs i this is trivial, for k the above argument holds for b j ′ ≥ u k (C k ), while for b j ′ < u k (C k ), it is clear that job j ′ can never reach the utility of k and thus k will never be included in J . Similar to the case of intercepts, we can also consider the extension of the problem to the case where ∆a j < 0 is allowed. As above, we would expect to reach a solution where all utility 1 In the special case a j ′ = 0 it would be beneficial to change the ordering of j ′ and k. 25 values are equal. However, this situation cannot be reached in all cases, since b j is an upper bound for u j (C) for every j reached for ∆a j = a j . The idea is to first increase all a j until all utilities are equal to u F and increase the budget B by the accrued increases of the slopes. Then all slopes are simultaneously decreased and thereby the common utility value for all jobs are increased (consuming different ∆a j for every job j), until the budget runs out or one job reaches ∆a j = a j . 5.3 Modifications of agent utilities with fixed area If we allow both the intercepts b j and the slopes a j to vary, it makes sense to impose additional restrictions on the shape of the linear utility function. While we enforce that the modified utility ̃u j remains nonnegative for all completion times up to P , we also impose an upper bound on the expected utility for agent j. As mentioned in Section 3.2, the (varied) area ̃ A j = P ( ̃ b j − ̃a j (P/2)) (which forms a trapezoid for every choice of a linear function) can be interpreted as a measure of expected utility return for agent j, under the assumption that the unknown variable C j is uniformly distributed over the interval [0,P ]. Note also that the slope ̃a j can be viewed as a measure of the risk attitude of agent j. Smaller (resp. larger) values of ̃a j indicate an agent which is more risk-averse (resp. risk-tolerant). In our setting, we enforce that ̃ A j cannot exceed the original expected utility return A j . Since every agent will fully exploit the given area A j , i.e., ̃ A j := A j we have that ̃ b j = A j P + ̃a j P 2 while ̃a j ∈ [0, 2 A j P 2 ] to keep u j ≥ 0. It is easy to see that every line of a utility function must pass through the midpoint (P/2,A j /P ). Looking at each job separately, it is clear that for a job j with completion time C j ≥ P/2 it would be the best choice to set ̃a j = 0 and ̃ b j = A j /P . On the other hand, for C j ≤ P/2 a triangular shape maximizes the utility, i.e. setting ̃ b j = 2A j /P as large as possible and ̃a j = 2A j /P 2 , such that ̃u j (P ) = 0. Summarizing, the linear utility function ̃u j (C) chosen for a job j in a schedule σ can be expressed as ̃u j (C j (σ)) = ( 2A j P (1− C j (σ) P ) if C j (σ)≤ P 2 ; A j P if C j (σ) > P 2 . (10) P P/2 A j /P 2A j /P C j ̃u j Figure 5: Function ̃u j (C j (σ)) as defined in (10). 26 Therefore, we can represent each utility function by the maximum of the two cases, constant or triangular, as depicted in Figure 5. Thus, for problem 1|u j = ̃ b j − ̃a j C j , ̃ A j = A j |u min the agents’ utility functions are non-increasing with completion times and we immediately get the optimal solution by applying MaxMinGreedy. In fact, this means that jobs are scheduled in the order of non-decreasing areas A j . 5.4 Modification for a single job Given an instance of 1|u j = b j − a j C j |u min and an optimal solution computed by MaxMin- Greedy we consider the situation where a single job/agent, say i, has the possibility of modifying its utility function, while all other jobs remain unchanged. For every change of u i , the solution of the resulting problem is again computed by MaxMinGreedy. We will first discuss the case where the intercept b i of job i can be increased by ∆b i ≥ 0. Clearly, a marginal increase ∆b i will directly increase u i by the same amount ∆b i . However, at some point the increase of ∆b i will imply a change in the decision of MaxMinGreedy for some job k scheduled later than i in the original schedule. This will happen for the minimal value of ∆b i such that there exists a job k with C k > C i and b i + ∆b i − a i C k = u k (C k ). Clearly, k can be any of the jobs with C k > C i and not necessarily the successor of i. At this point, job i assumes the position of k in the schedule which sets its completion time equal to C k and causes a sudden decrease of utility by a i (C k − C i ). Also the jobs previously scheduled between i and k will be reconsidered by MaxMinGreedy and possibly scheduled differently, but that will not affect i. Proceeding in this way, we can determine the modified utility function ̃u i (∆b i ) giving the utility of job i with intercept b i + ∆b i as it results from MaxMinGreedy 2 . It is a sawtooth function with slope 1 and discontinuous points whenever i reaches a new completion time, having a local maximum at this point, see Figure 6. At some point, i is relegated to the last position in the schedule with C i = P and thus ̃u i (∆b i ) increases infinitely with slope 1. ∆b i ̃ u i Figure 6: Increased utility ̃u i as a function of the increase of the intercept ∆b i . 2 Be aware that ̃u j (∆b j ) expresses the utility as a function of the intercept change, while u j (C j ) gave the utility of a job depending on its completion time. 27 We are interested in an increasing sequence of local maxima. Clearly, an increase of ∆b i only makes sense for job i if it leads to a new local maximum with higher value than all previously determined local maxima. It may also be natural to consider an upper bound B and ask for the best utility achievable for ∆b i ≤ B. This is either the last maximum of this increasing sequence obtained without exhausting B, or it arises for ̃u i (B). A similar approach works for decreasing the negative slope −a i by ∆a i . In this case, the corresponding modified utility function remains a sawtooth function with discontinuous drops whenever the completion time of i changes. Since ̃u i (∆a i ) = b i − a i C i + ∆a i C i , the slope of this function is C i which increases with every new position of i in the schedule as depicted in Figure 7. Clearly, we impose the upper bound ∆a i ≤ a i which also yields the maximum of the modified utility function. ∆a i ̃ u i Figure 7: Increased utility ̃u i as a function of the increase of the slope ∆a i . A third version of modifying the utility function considers the increase of the area of the utility function A i by ∆A i , assuming that all other agents j remain at their areas A j . Recall that MaxMinGreedy results in a simple sorting of the jobs in increasing order of A j . The breakpoint of the utilities at P/2, as discussed in Section 5.3, implies that as soon as C i ≥ P/2, the modified utility function ̃u i (∆A i ) increases linearly with slope 1/P . For C i < P/2 we observe again a sawtooth function, with positive slope 2 P (1− C i P ). As C i increases whenever A i + ∆A i matches one of the other areas A j , the slopes of the linear pieces decrease, converging towards 1/P when C i goes to P/2. A visualization of this behavior is given in Figure 8. 6 Rescheduling to maximize the utility of a new agent In this section we consider a two-stage optimization problem where in the first stage the standard problem 1|u j |u min with n agents is solved by MaxMinGreedy on a set of n jobs. This step yields an optimal schedule σ F with utility values u j (σ F ) for each job j and the maximum minimum utility u F := min j u j (σ F ). In the second stage we consider the arrival of a new agent n + 1 and ask for a new schedule σ comprising the new agent’s job as well as all the original jobs 1,...,n. The new agent has a high priority and should be given a maximal utility (i.e., should be completed as early as possible), 28 ∆A i ̃ u i slope 1 P Figure 8: Increased utility ̃u i as a function of the increase of the area ∆A i . under a certain restriction for the utility of the original jobs. Clearly, scheduling an additional job at a preferred position may worsen the utilities of other jobs. Therefore, we introduce a budget R which can be used to compensate agents (jobs) by increasing (or, more generally, keeping some restrictions on) their utilities. We will identify budget payment with utility increase and assume that each agent j can be given an arbitrary nonnegative apportionment β j ≥ 0 to be added to its utility as long as P n j=1 β j ≤ R. This problem aligns with a few preceding studies about rescheduling, in which a certain sched- ule must be rearranged in order to optimize a given objective function under bounded changes with respect to the original schedule. For papers on single machine rescheduling problems see, e.g., Hall and Potts (2004), Nicosia et al. (2021), and Rener et al. (2025). In these works, the authors define different measures of disruption associated to a job, such as the difference in the positions (or in the completion times) between the original and the reordered schedules. As the agents are pursuing the maximization of their utilities, here we measure disruption of one agent j as the difference among the utilities in the new schedule σ (including possible compensations) and the original solution σ F , i.e., δ j = u j (σ) + β j − u j (σ F ).(11) We consider three reasonable versions of our rescheduling problem with different restrictions on agents’ disruptions: Problem 1|resch,δ j ≥ 0|u n+1 . In this problem, we impose (in some sense) the strongest requirement since after including the new job, each single agent in σ should have a utility (including compensation) at least as large as before in σ F .Recalling Equa- tion (11), we can easily recast the constraints in terms of agents’ disruption, as follows: u j (σ) + β j ≥ u j (σ F )⇔ δ j ≥ 0 and write the problem as max σ u n+1 (σ) : δ j ≥ 0, j = 1,...,n.(12) Problem 1|resch, P δ j ≥ 0|u n+1 . Here, we relax the requirements of the previous problem (12) by bounding the sum of utilities instead of bounds on each individual utility. Again, we can 29 easily recast the constraints in terms of agents’ disruption, as follows: P n j=1 u j (σ) + R ≥ P n j=1 u j (σ F )⇔ P n j=1 δ j ≥ 0 and thus we obtain the following formulation of the problem: max σ u n+1 (σ) : n X j=1 δ j ≥ 0 .(13) In this case, the budget R does not have to be distributed among the agents but can simply be added to the total utility. Problem 1|resch,u j ≥ u F |u n+1 . In this problem, we require that the value of the fairness in the rescheduled solution σ has not worsened with respect to σ F , i.e., all agents would reach a utility not less than u F = minu j (σ F ). Recalling Equation (11), we note that in this case we are bounding agents’ disruptions, as shown by the equivalence u j (σ) +β j ≥ u F ⇔ δ j ≥ u F − u j (σ F ). (Note that u F − u j (σ F ) ≤ 0 for all j.) Eventually we may write the problem as follows: max σ u n+1 (σ) : δ j ≥ u F − u j (σ F ), j = 1,...,n .(14) We start by showing that our first two versions of the problem, 1|resch,δ j ≥ 0|u n+1 and 1|resch, P δ j ≥ 0|u n+1 , are hard. Theorem 14 Problem 1|resch,δ j ≥ 0|u n+1 is weakly NP-hard, even for linear utility functions. Proof. We consider an instance I P of Partition defined by n integers w 1 ,...,w n and let B = 1 2 P n i=1 w i . The problem asks for a subset S of numbers summing up to B. Now we construct an instance of the decision version of Problem (12) with n + 2 original jobs with linear utility functions, a new job n + 3 and a budget R. The large constant M will be set later. The n + 2 jobs are scheduled by MaxMinGreedy yielding a schedule σ F with utilities u j (σ F ). Then we ask, whether a new schedule σ exists where job n + 3 completes at time 2B (at the latest) while all the other jobs receive a utility and a payment β j fulfilling u j (σ) + β j ≥ u j (σ F ). The data for the jobs are reported in the following table and we set R = MB + 3B 2 . jp j a j b j 1,...,n w j w j 4B(M + 2B) n + 1 M M 2 5 2 M 3 n + 2 B ε2M 3 − 3M 2 B n + 3 B-- We choose M large enough so that the schedule produced by MaxMinGreedy consists of jobs 1 to n in some unspecified order followed by jobs n + 1 and n + 2, see the upper schedule depicted in Figure 9. To see that, we evaluate the utilities at time P = 2B + M + B which is the overall 30 <latexit sha1_base64="V1uUlr/I7+Kh1O623OH0ohGi7dE=">AAAB6nicbVBNS8NAEJ3Ur1q/qh69LBZBUEoioh4LXjxWtB/QhrLZTtqlm03Y3Qgl9Cd48aCIV3+RN/+N2zYHbX0w8Hhvhpl5QSK4Nq777RRWVtfWN4qbpa3tnd298v5BU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWj26nfekKleSwfzThBP6IDyUPOqLHSgzzzeuWKW3VnIMvEy0kFctR75a9uP2ZphNIwQbXueG5i/Iwqw5nASambakwoG9EBdiyVNELtZ7NTJ+TEKn0SxsqWNGSm/p7IaKT1OApsZ0TNUC96U/E/r5Oa8MbPuExSg5LNF4WpICYm079JnytkRowtoUxxeythQ6ooMzadkg3BW3x5mTQvqt5V1bu/rNTO8ziKcATHcAoeXEMN7qAODWAwgGd4hTdHOC/Ou/Mxby04+cwh/IHz+QOou41S</latexit> n+1 <latexit sha1_base64="vjXNQvGeqcoq8kAmQ7gInpo8sek=">AAAB6nicbVBNS8NAEJ34WetX1aOXxSIISkmKqMeCF48V7Qe0oWy2m3bpZhN2J0IJ/QlePCji1V/kzX/jts1BWx8MPN6bYWZekEhh0HW/nZXVtfWNzcJWcXtnd2+/dHDYNHGqGW+wWMa6HVDDpVC8gQIlbyea0yiQvBWMbqd+64lrI2L1iOOE+xEdKBEKRtFKD+q82iuV3Yo7A1kmXk7KkKPeK311+zFLI66QSWpMx3MT9DOqUTDJJ8VuanhC2YgOeMdSRSNu/Gx26oScWqVPwljbUkhm6u+JjEbGjKPAdkYUh2bRm4r/eZ0Uwxs/EypJkSs2XxSmkmBMpn+TvtCcoRxbQpkW9lbChlRThjadog3BW3x5mTSrFe+q4t1flmsXeRwFOIYTOAMPrqEGd1CHBjAYwDO8wpsjnRfn3fmYt644+cwR/IHz+QOqP41T</latexit> n+2 <latexit sha1_base64="pq7hpM1V0R8Rzzdloat48J51yeM=">AAACBHicbVC7SgNBFJ2NrxhfUcs0g0GwCGFXRC0DNpYRzAOyS5idnU3GzGOZmRXDksLGX7GxUMTWj7Dzb5wkW2jigQuHc+7l3nvChFFtXPfbKaysrq1vFDdLW9s7u3vl/YO2lqnCpIUlk6obIk0YFaRlqGGkmyiCeMhIJxxdTf3OPVGaSnFrxgkJOBoIGlOMjJX65YrPQ/mQwTsZajiBPvRqPouk0TVo3apbd2eAy8TLSRXkaPbLX34kccqJMJghrXuem5ggQ8pQzMik5KeaJAiP0ID0LBWIEx1ksycm8NgqEYylsiUMnKm/JzLEtR7z0HZyZIZ60ZuK/3m91MSXQUZFkhoi8HxRnDJoJJwmAiOqCDZsbAnCitpbIR4ihbCxuZVsCN7iy8ukfVr3zuvezVm1UcvjKIIKOAInwAMXoAGuQRO0AAaP4Bm8gjfnyXlx3p2PeWvByWcOwR84nz/Mr5bW</latexit> jobs 1,...,n <latexit sha1_base64="0MXcTmWYxVPWK7hqbuMTzTQR728=">AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBg5RERD0WvHhswX5AG8pmO2nXbjZhdyOU0F/gxYMiXv1J3vw3btsctPXBwOO9GWbmBYng2rjut1NYW9/Y3Cpul3Z29/YPyodHLR2nimGTxSJWnYBqFFxi03AjsJMopFEgsB2M72Z++wmV5rF8MJME/YgOJQ85o8ZKDbdfrrhVdw6ySrycVCBHvV/+6g1ilkYoDRNU667nJsbPqDKcCZyWeqnGhLIxHWLXUkkj1H42P3RKzqwyIGGsbElD5urviYxGWk+iwHZG1Iz0sjcT//O6qQlv/YzLJDUo2WJRmApiYjL7mgy4QmbExBLKFLe3EjaiijJjsynZELzll1dJ67LqXVe9xlWldpHHUYQTOIVz8OAGanAPdWgCA4RneIU359F5cd6dj0VrwclnjuEPnM8fdHOMpA==</latexit> 0 <latexit sha1_base64="J5j5iDARiBJtcD9qO2WBXs5y77c=">AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4kJKIqMeiF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dlZW19Y3Ngtbxe2d3b390sFhU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWju6nfekKleSwfzDhBP6IDyUPOqLFS/bZXKrsVdwayTLyclCFHrVf66vZjlkYoDRNU647nJsbPqDKcCZwUu6nGhLIRHWDHUkkj1H42O3RCTq3SJ2GsbElDZurviYxGWo+jwHZG1Az1ojcV//M6qQlv/IzLJDUo2XxRmApiYjL9mvS5QmbE2BLKFLe3EjakijJjsynaELzFl5dJ86LiXVW8+mW5ep7HUYBjOIEz8OAaqnAPNWgAA4RneIU359F5cd6dj3nripPPHMEfOJ8/j7uMtg==</latexit> B <latexit sha1_base64="KwpTvMUI9eZF9SdYY89uJGCTxUs=">AAAB6XicbVBNS8NAEJ34WetX1aOXxSJ4kJIUUY9FLx6r2A9oQ9lsJ+3SzSbsboQS+g+8eFDEq//Im//GbZuDtj4YeLw3w8y8IBFcG9f9dlZW19Y3Ngtbxe2d3b390sFhU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWj26nfekKleSwfzThBP6IDyUPOqLHSQ/WmVyq7FXcGsky8nJQhR71X+ur2Y5ZGKA0TVOuO5ybGz6gynAmcFLupxoSyER1gx1JJI9R+Nrt0Qk6t0idhrGxJQ2bq74mMRlqPo8B2RtQM9aI3Ff/zOqkJr/2MyyQ1KNl8UZgKYmIyfZv0uUJmxNgSyhS3txI2pIoyY8Mp2hC8xZeXSbNa8S4r3v1FuXaex1GAYziBM/DgCmpwB3VoAIMQnuEV3pyR8+K8Ox/z1hUnnzmCP3A+fwAAqIzy</latexit> 2B <latexit sha1_base64="TB9+ai9TPgJww6LSNT5ORXQML2I=">AAAB63icbVBNSwMxEJ2tX7V+VT16CRZBUMpuEfVY9OJFqGA/oF1KNs22oUl2SbJCWfoXvHhQxKt/yJv/xmy7B219MPB4b4aZeUHMmTau++0UVlbX1jeKm6Wt7Z3dvfL+QUtHiSK0SSIeqU6ANeVM0qZhhtNOrCgWAaftYHyb+e0nqjSL5KOZxNQXeChZyAg2mVS7Obvvlytu1Z0BLRMvJxXI0eiXv3qDiCSCSkM41rrrubHxU6wMI5xOS71E0xiTMR7SrqUSC6r9dHbrFJ1YZYDCSNmSBs3U3xMpFlpPRGA7BTYjvehl4n9eNzHhtZ8yGSeGSjJfFCYcmQhlj6MBU5QYPrEEE8XsrYiMsMLE2HhKNgRv8eVl0qpVvcuq93BRqZ/ncRThCI7hFDy4gjrcQQOaQGAEz/AKb45wXpx352PeWnDymUP4A+fzBwF4jX4=</latexit> 2B+M <latexit sha1_base64="jVVDk00HJGRL4AGF2f5/7BiFKy8=">AAAB63icbVBNSwMxEJ2tX7V+VT16CRZBUMquinosevEiVLAf0C4lm2b0CS7JFmhLP0LXjwo4tU/5M1/Y7bdg7Y+GHi8N8PMvCDmTBvX/XYKS8srq2vF9dLG5tb2Tnl3r6mjRBHaIBGPVDvAmnImacMww2k7VhSLgNNWMLrN/NYTVZpF8tGMY+oLPJAsZASbTDq/ObnvlStu1Z0CLRIvJxXIUe+Vv7r9iCSCSkM41rrjubHxU6wMI5xOSt1E0xiTER7QjqUSC6r9dHrrBB1ZpY/CSNmSBk3V3xMpFlqPRWA7BTZDPe9l4n9eJzHhtZ8yGSeGSjJbFCYcmQhlj6M+U5QYPrYEE8XsrYgMscLE2HhKNgRv/uVF0jyrepdV7+GiUjvN4yjCARzCMXhwBTW4gzo0gMAQnuEV3hzhvDjvzsesteDkM/vwB87nDwL/jX8=</latexit> 3B+M <latexit sha1_base64="0MXcTmWYxVPWK7hqbuMTzTQR728=">AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBg5RERD0WvHhswX5AG8pmO2nXbjZhdyOU0F/gxYMiXv1J3vw3btsctPXBwOO9GWbmBYng2rjut1NYW9/Y3Cpul3Z29/YPyodHLR2nimGTxSJWnYBqFFxi03AjsJMopFEgsB2M72Z++wmV5rF8MJME/YgOJQ85o8ZKDbdfrrhVdw6ySrycVCBHvV/+6g1ilkYoDRNU667nJsbPqDKcCZyWeqnGhLIxHWLXUkkj1H42P3RKzqwyIGGsbElD5urviYxGWk+iwHZG1Iz0sjcT//O6qQlv/YzLJDUo2WJRmApiYjL7mgy4QmbExBLKFLe3EjaiijJjsynZELzll1dJ67LqXVe9xlWldpHHUYQTOIVz8OAGanAPdWgCA4RneIU359F5cd6dj0VrwclnjuEPnM8fdHOMpA==</latexit> 0 <latexit sha1_base64="J5j5iDARiBJtcD9qO2WBXs5y77c=">AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4kJKIqMeiF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dlZW19Y3Ngtbxe2d3b390sFhU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWju6nfekKleSwfzDhBP6IDyUPOqLFS/bZXKrsVdwayTLyclCFHrVf66vZjlkYoDRNU647nJsbPqDKcCZwUu6nGhLIRHWDHUkkj1H42O3RCTq3SJ2GsbElDZurviYxGWo+jwHZG1Az1ojcV//M6qQlv/IzLJDUo2XxRmApiYjL9mvS5QmbE2BLKFLe3EjakijJjsynaELzFl5dJ86LiXVW8+mW5ep7HUYBjOIEz8OAaqnAPNWgAA4RneIU359F5cd6dj3nripPPHMEfOJ8/j7uMtg==</latexit> B <latexit sha1_base64="KwpTvMUI9eZF9SdYY89uJGCTxUs=">AAAB6XicbVBNS8NAEJ34WetX1aOXxSJ4kJIUUY9FLx6r2A9oQ9lsJ+3SzSbsboQS+g+8eFDEq//Im//GbZuDtj4YeLw3w8y8IBFcG9f9dlZW19Y3Ngtbxe2d3b390sFhU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWj26nfekKleSwfzThBP6IDyUPOqLHSQ/WmVyq7FXcGsky8nJQhR71X+ur2Y5ZGKA0TVOuO5ybGz6gynAmcFLupxoSyER1gx1JJI9R+Nrt0Qk6t0idhrGxJQ2bq74mMRlqPo8B2RtQM9aI3Ff/zOqkJr/2MyyQ1KNl8UZgKYmIyfZv0uUJmxNgSyhS3txI2pIoyY8Mp2hC8xZeXSbNa8S4r3v1FuXaex1GAYziBM/DgCmpwB3VoAIMQnuEV3pyR8+K8Ox/z1hUnnzmCP3A+fwAAqIzy</latexit> 2B <latexit sha1_base64="TB9+ai9TPgJww6LSNT5ORXQML2I=">AAAB63icbVBNSwMxEJ2tX7V+VT16CRZBUMpuEfVY9OJFqGA/oF1KNs22oUl2SbJCWfoXvHhQxKt/yJv/xmy7B219MPB4b4aZeUHMmTau++0UVlbX1jeKm6Wt7Z3dvfL+QUtHiSK0SSIeqU6ANeVM0qZhhtNOrCgWAaftYHyb+e0nqjSL5KOZxNQXeChZyAg2mVS7Obvvlytu1Z0BLRMvJxXI0eiXv3qDiCSCSkM41rrrubHxU6wMI5xOS71E0xiTMR7SrqUSC6r9dHbrFJ1YZYDCSNmSBs3U3xMpFlpPRGA7BTYjvehl4n9eNzHhtZ8yGSeGSjJfFCYcmQhlj6MBU5QYPrEEE8XsrYiMsMLE2HhKNgRv8eVl0qpVvcuq93BRqZ/ncRThCI7hFDy4gjrcQQOaQGAEz/AKb45wXpx352PeWnDymUP4A+fzBwF4jX4=</latexit> 2B+M <latexit sha1_base64="jVVDk00HJGRL4AGF2f5/7BiFKy8=">AAAB63icbVBNSwMxEJ2tX7V+VT16CRZBUMquinosevEiVLAf0C4lm2b0CS7JFmhLP0LXjwo4tU/5M1/Y7bdg7Y+GHi8N8PMvCDmTBvX/XYKS8srq2vF9dLG5tb2Tnl3r6mjRBHaIBGPVDvAmnImacMww2k7VhSLgNNWMLrN/NYTVZpF8tGMY+oLPJAsZASbTDq/ObnvlStu1Z0CLRIvJxXIUe+Vv7r9iCSCSkM41rrjubHxU6wMI5xOSt1E0xiTER7QjqUSC6r9dHrrBB1ZpY/CSNmSBk3V3xMpFlqPRWA7BTZDPe9l4n9eJzHhtZ8yGSeGSjJbFCYcmQhlj6M+U5QYPrYEE8XsrYgMscLE2HhKNgRv/uVF0jyrepdV7+GiUjvN4yjCARzCMXhwBTW4gzo0gMAQnuEV3hzhvDjvzsesteDkM/vwB87nDwL/jX8=</latexit> 3B+M <latexit sha1_base64="V1uUlr/I7+Kh1O623OH0ohGi7dE=">AAAB6nicbVBNS8NAEJ3Ur1q/qh69LBZBUEoioh4LXjxWtB/QhrLZTtqlm03Y3Qgl9Cd48aCIV3+RN/+N2zYHbX0w8Hhvhpl5QSK4Nq777RRWVtfWN4qbpa3tnd298v5BU8epYthgsYhVO6AaBZfYMNwIbCcKaRQIbAWj26nfekKleSwfzThBP6IDyUPOqLHSgzzzeuWKW3VnIMvEy0kFctR75a9uP2ZphNIwQbXueG5i/Iwqw5nASambakwoG9EBdiyVNELtZ7NTJ+TEKn0SxsqWNGSm/p7IaKT1OApsZ0TNUC96U/E/r5Oa8MbPuExSg5LNF4WpICYm079JnytkRowtoUxxeythQ6ooMzadkg3BW3x5mTQvqt5V1bu/rNTO8ziKcATHcAoeXEMN7qAODWAwgGd4hTdHOC/Ou/Mxby04+cwh/IHz+QOou41S</latexit> n+1 <latexit sha1_base64="vjXNQvGeqcoq8kAmQ7gInpo8sek=">AAAB6nicbVBNS8NAEJ34WetX1aOXxSIISkmKqMeCF48V7Qe0oWy2m3bpZhN2J0IJ/QlePCji1V/kzX/jts1BWx8MPN6bYWZekEhh0HW/nZXVtfWNzcJWcXtnd2+/dHDYNHGqGW+wWMa6HVDDpVC8gQIlbyea0yiQvBWMbqd+64lrI2L1iOOE+xEdKBEKRtFKD+q82iuV3Yo7A1kmXk7KkKPeK311+zFLI66QSWpMx3MT9DOqUTDJJ8VuanhC2YgOeMdSRSNu/Gx26oScWqVPwljbUkhm6u+JjEbGjKPAdkYUh2bRm4r/eZ0Uwxs/EypJkSs2XxSmkmBMpn+TvtCcoRxbQpkW9lbChlRThjadog3BW3x5mTSrFe+q4t1flmsXeRwFOIYTOAMPrqEGd1CHBjAYwDO8wpsjnRfn3fmYt644+cwR/IHz+QOqP41T</latexit> n+2 <latexit sha1_base64="Oi9Q2KgatvOuoGRk4dTaoBbe35E=">AAAB6nicbVBNS8NAEJ34WetX1aOXxSIISklU1GPBi8eK9gPaUDbbTbt0swm7E6GE/gQvHhTx6i/y5r9x2+agrQ8GHu/NMDMvSKQw6LrfztLyyuraemGjuLm1vbNb2ttvmDjVjNdZLGPdCqjhUiheR4GStxLNaRRI3gyGtxO/+cS1EbF6xFHC/Yj2lQgFo2ilB3V60S2V3Yo7BVkkXk7KkKPWLX11ejFLI66QSWpM23MT9DOqUTDJx8VOanhC2ZD2edtSRSNu/Gx66pgcW6VHwljbUkim6u+JjEbGjKLAdkYUB2bem4j/e0Uwxs/EypJkSs2WxSmkmBMJn+TntCcoRxZQpkW9lbCBlRThjadog3Bm395kTTOK95Vxbu/LFfP8jgKcAhHcAIeXEMV7qAGdWDQh2d4hTdHOi/Ou/Mxa11y8pkD+APn8werw41U</latexit> n+3 <latexit sha1_base64="4Kzs2ZZlkTfJRMFdXH4S8/Tll4=">AAAB+nicbVDLSsNAFJ3UV62vVJduBovgQkoioi4LblxWtA9oQplMJ+3YeYSZiVpiP8WNC0Xc+iXu/BunbRbaeuDC4Zx7ufeeKGFUG8/7dgpLyyura8X10sbm1vaOW95tapkqTBpYMqnaEdKEUUEahhpG2okiiEeMtKLh5cRv3ROlqRS3ZpSQkKO+oDHFyFip65YDHsnHDN7JSMMxDOBN1614VW8KuEj8nFRAjnrX/Qp6EqecCIMZ0rrje4kJM6QMxYyMS0GqSYLwEPVJx1KBONFhNj19DA+t0oOxVLaEgVP190SGuNYjHtlOjsxAz3sT8T+vk5r4IsyoSFJDBJ4tilMGjYSTHGCPKoING1mCsKL2VogHSCFsbFolG4I///IiaZ5U/bOqf31aqR3ncRTBPjgAR8AH56AGrkAdNAAGD+AZvII358l5cd6dj1lrwcln9sAfOJ8/GU+TLA==</latexit> jobsS <latexit sha1_base64="SvyRgxd22YB9UaM6G5Q9GJq/KmM=">AAAB/3icbVDLSsNAFJ3UV62vqODGzWARXEhJRNRlwY3LivYBTSiT6aQdO48wMxFL7MJfceNCEbf+hjv/xmmbhbYeuHA4517uvSdKGNXG876dwsLi0vJKcbW0tr6xueVu7zS0TBUmdSyZVK0IacKoIHVDDSOtRBHEI0a0eBy7DfvidJUilszTEjIUU/QmGJkrNRx9wIeyYcM3slIwxEMYBAhBW86btmreBPAeeLnpAxy1DruV9CVOOVEGMyQ1m3fS0yYIWUoZmRUClJNEoQHqEfalgrEiQ6zyf0jeGiVLoylsiUMnKi/JzLEtR7yyHZyZPp61huL/3nt1MQXYUZFkhoi8HRRnDJoJByHAbtUEWzY0BKEFbW3QtxHCmFjIyvZEPzZl+dJ46Tin1X869Ny9TiPowj2wQE4Aj44B1VwBWqgDjB4BM/gFbw5T86L8+58TFsLTj6zC/7A+fwBhOKVDw==</latexit> jobs ̄ S Figure 9: Original schedule σ F output by MaxMinGreedy (above) and the schedule after inserting job n + 3 (below). makespan. We set M := 5B 2 and obtain: u j (P ) = 4B(M + 2B)− a j P ≤ 20B 3 + 8B 2 j = 1,...,n, u n+1 (P ) = 5 2 M 3 − M 2 (3B + M ) = 3 2 (5 3 B 6 )− 75B 5 , u n+2 (P ) = 2M 3 − 3M 2 B− ε(3B + M ) = 2(5 3 B 6 )− 75B 5 − ε(5B 2 + 3B). Hence n + 2, which has the largest utility at P , is scheduled last. Before n+2, at time 2B+M , we have u n+1 (2B+M ) = 5 2 M 3 −M 2 (2B+M ) = 3 2 (5 3 B 6 )−50B 5 , which is clearly larger than u j (2B + M ) = 4B(M + 2B) − a j (2b + M ) ≤ 20B 3 + 8B 2 for j = 1,...,n. So n + 1 is scheduled directly before n + 2. The argument for placing the new job n + 3 works as follows. Inserting job n + 3 to start not later than at time B requires to postpone a subset S of the jobs 1 to n with total processing time at least B. We will see that postponing job n + 1 would cause excessive payments, while job n + 2 can be deferred to the end of the schedule with minimal loss of utility. Thus, we want to find a set S of total length exactly B and move these jobs in the gap left by job n + 2. Clearly, jobs which complete in σ not later than before will not decrease their utility. How- ever, every job j with a later completion time loses a j units of utility for each unit of time that it completes later than in the original schedule. Increasing the completion time of job n + 1 by only one unit of time would require a com- pensation payment of M 2 = 25B 4 , which exceeds the budget R = 5B 3 + 3B 2 . Therefore, in σ this job can not finish later than before. On the other hand, job n + 2 can be moved to the end of the new schedule with minimal loss of utility. To place job n + 3 somewhere in the interval [0, 2B] it does not make sense to schedule jobs from 1,...,n between jobs n + 3 and n + 1. Since n + 1 starts at time 2B (or earlier) in schedule σ, we can always move n + 3 to complete at the start of n + 1. Therefore, some of the jobs from 1,...,n, denoted by subset S, have to be moved to start after jobs n + 3 and n + 1 with an earliest starting time of M +B. The other jobs in the set ̄ S =1,...,n will be scheduled at the beginning of σ in the same sequence as before without reducing their utilities, see the lower schedule in Figure 9. The payment required for moving some job j ∈ S is at least its minimal loss of utility, namely a j (M + B− (2B− a j )) = a j (M − B + a j ) (earliest new starting time minus latest old starting 31 time). On the other hand, the maximum loss of utility for j ∈ S is reached by moving the first job to the last position completing just before job n + 2 at time M + 3B which is a j (M + 3B−a j ). Clearly, P j∈S p j must be at least B to accommodate job n + 3. For every subset S with P j∈S p j = B, the total required payment is at most P j∈S a j (M +3B−a j )≤ P j∈S a j (M +3B) = MB + 3B 2 = R, which is a feasible solution. However, for every subset S with P j∈S p j ≥ B + 1, the required payment is at least P j∈S a j (M−B +a j )≥ P j∈S a j (M−B)≥ (B + 1)(M−B) = 5B 3 + 4B 2 − B which is greater than R. Thus, the completion time 2B can be reached for the new job n + 3 if and only if there is a subset S with P j∈S w j = B.□ Theorem 15 Problem 1|resch, P δ j ≥ 0|u n+1 is weakly NP-hard, even for linear utility func- tions. Proof. To show NP-hardness of Problem 1|resch, P δ j ≥ 0|u n+1 , we employ a scheduling problem discussed by Strusevich and Rustogi (2016), who introduced the problem of scheduling jobs on a single machine where a break of length Γ has to be included in the schedule to allow some maintenance operation. The start time τ of the non-availability period can be chosen freely as long as it is not later than a given deadline D MP . For the objective of total weighted completion time the problem is denoted as 1|τ ≤ D MP , Γ| P w j C j with the decision version asking for a schedule with P w j C j ≤ ̄ W . It is shown by Strusevich and Rustogi (2016) that this problem is weakly NP-hard. Given an instance I MP of the decision version of 1|τ ≤ D MP , Γ| P w j C j ≤ ̄ W , we construct an instance I of the decision version of our problem with target value C T (for the new agent n + 1) as follows. Jobs 1 to n have the same processing times of the n jobs in I MP , while p n+1 = Γ and C T = D MP + Γ. Linear utility functions are given with a j = w j and arbitrary b j . For convenience, let ̄ f := u SYS (σ F ) = P n j=1 u j (σ F ). Finally, the budget in I is set to R := ̄ W + ̄ f− P j b j . (Note that we may have R < 0, but this can be accommodated representing a required increase of total utility.) We will consider identical schedules of jobs 1,...,n for both problems. If I is a yes-instance with schedule σ and completion times C j , then C n+1 ≤ C T , which means that job n + 1, corresponding to the maintenance operation of I MP , starts at C T − p n+1 = D MP at the latest, thus guaranteeing feasibility for I MP . Moreover, the restriction on the utility compensation P n j=1 δ j ≥ 0 yields: n X j=1 u j (σ) + β j − u j (σ F ) ≥ 0⇔ n X j=1 b j − n X j=1 a j C j + n X j=1 β j − ̄ f ≥ 0. Since the budget R is clearly fully exhausted, this is equivalent to P n j=1 b j − P n j=1 a j C j + ̄ W + ̄ f − P n j=1 b j − ̄ f ≥ 0 and therefore we have P n j=1 a j C j = P n j=1 w j C j ≤ ̄ W . Thus, I MP is a yes-instance. The equivalence of the inequalities between the two problems completes the reduction.□ 32 Note that the same argument applies if the initial schedule is σ SYS instead of σ F . In fact, the specific initial schedule plays no role in the reduction; what matters is only its total utility value, P j u j (σ F ). As a consequence, we can state that 1|resch, P δ j ≥ 0|u n+1 remains weakly NP-hard, even when the initial solution is the system-optimal schedule σ SYS and the utility functions are linear. We now turn to the last of the three versions of our single-agent problem—namely, 1|resch, u j ≥ u F |u n+1 —and show that this one can be solved efficiently. Theorem 16 Problem (14) 1|resch,u j ≥ u F |u n+1 can be solved in O(n 2 logP ) time. Also for Problem (14), starting from an initial system-optimal solution σ SYS and hence replacing the lower bound u F by u SYS , does non change the validity of the procedure described in the proof of Theorem 16, which works for an arbitrary lower bound on the individual utility values. Therefore we may conclude that 1|resch,u j ≥ u SYS |u n+1 , i.e., Problem (14) with initial solution σ SYS and linear utility functions, is weakly NP-hard. We close this section with a few additional observations about the latter result. • If no compensations are intended for agents 1,...,n, i.e., R = 0, Problem (14) can be solved (again in O(n 2 ) log( P n+1 j=1 p j ) time), with a simplified procedure. As in the proof of Theorem 14, we perform a binary search over the completion time C n+1 of job n + 1. For each target value C T in the binary search we obtain a corresponding due date d T n+1 of job n + 1 (while all other jobs have no due date). Thus, the decision problem arising in each iteration can be solved in O(n 2 ) time by Theorem 11. If the maximum minimum utility value of the resulting schedule is smaller than u F , we have to consider a larger target value, otherwise we can test a smaller target value. • Clearly, the process described in the proof of Theorem 16 could be recast to the case in which we want to maximize the utility of one job i among the original jobs 1,...,n. In this case the binary search is restricted in the interval between p i and the completion time C i (σ F ) determined by MaxMinGreedy. • It is also possible to extend the procedure by considering more than one job which should have a utility as high as possible (and thus a minimal completion time). For instance, we may maximize the utilities of an ordered list of jobs j 1 ,...,j k , k ≤ n, in a lexicographic order. After determining the earliest completion time C ∗ j 1 for the first job j 1 in the list (by the binary search process sketched above) we fix this value as due date d j 1 := C ∗ j 1 and iterate with minimizing the completion time of the next job in the list. The implied decision problems can still be solved by Theorem 11. 7 Enforcing a target sequence in a bi-level setting Like in a leader-follower scenario, an external party (the leader) might be interested to enforce a certain schedule σ T , e.g., minimizing sum of completion times to optimize throughput, or maximizing total utility. In such a bi-level setting, the follower would still be solving Problem 1|u j = b j − a j C j |u min to reach a fair solution σ F for all jobs, but the leader influences the outcome of this process by modifying the utility functions of jobs. 33 Suppose first that—in analogy to Section 5.2—the leader is allowed to either modify the intercept values by increasing b j by adding ∆b j to it, or to decrease the slopes by subtracting ∆a j from a j . Hence, it is required that ∆b j ≥ 0, resp. 0≤ ∆a j ≤ a j . In this way, the leader influences the sequence determined by the follower for the modified utility functions. Our problem asks for minimizing P j ∆b j , resp. P j ∆a j , such that the fair solution σ F generated by the follower, i.e., the maximization of the minimum utility, corresponds to the desired target sequence σ T . This setting is not enough for a meaningful problem definition, since the maximization of minimum utility leaves a wide range of different sequences with identical minimum utility. The leader would have no possibility to influence the sequence chosen by the follower among all the solutions tied for fairness. Thus, we will make the action taken by the follower more precise and assume that it uses MaxMinGreedy for determining the fair solution. According to the Graham-like notation introduced above we are denoting the above two problems respectively 1|σ F = σ T ,u j = ̃ b j − a j C j | P ̃ b j and 1|σ F = σ T ,u j = b j − ̃a j C j | P ̃a j . These problems can be solved as follows. Consider jobs numbered in increasing order of completion times as given by the target sequence σ T , i.e., C j (σ T )≥ C j−1 (σ T ), j = 2,...,n. The key idea is that, for MaxMinGreedy to schedule job j ≥ 2 at time C j , it suffices to choose the parameters ∆b j or ∆a j so that u j (C j ) ≥ u ℓ (C j ) for all ℓ = 1,...,j − 1. All jobs ℓ with earlier completion times C ℓ < C j will not change their values anymore. Conversely, all jobs with larger completion times than C j will take the new utility value of j into account when their values are determined. At any point in time T , MaxMinGreedy considers only the jobs to be placed before T . Thus, the later jobs in the sequence do not have to be considered in the choice of ∆b j resp. ∆a j . Formally, we start by choosing ∆b 1 := 0 (resp., ∆a 1 = 0) and, for j ≥ 2, we increase the b j values by setting ∆b j := max0, ̃ b ℓ − a ℓ C j − b j + a j C j ,ℓ = 1,...,j− 1. Note that any desired target sequence can be imposed by increasing the b j values. For the decrease of a j we set ∆a j := maxa j − ̃a ℓ + b ℓ −b j C j ,ℓ = 1,...,j − 1. If this choice yields ∆a j > a j , this would yield an increasing utility function violating the general assumption of nonincreasing utilities. Thus, not every desired target sequence can be obtained by reducing the a j values (although this changes when an increase of a j is also allowed, see below). If the follower aims at the maximization of global utility, it will schedule the jobs in non- increasing order of a j /p j . Obviously, the modification of intercepts b j is useless for this case. As for the slopes a j , they are modified such that this ordering corresponds to the schedule σ T desired by the leader. In the resulting problem 1|σ SYS = σ T ,u j = b j − ̃a j C j | P ∆a j we have to choose ∆a j such that ̃a j /p j ≤ ̃a ℓ /p ℓ for all ℓ < j. This yields ∆a j := max0,a j − p j · min 1≤ℓ<j ̃a ℓ p ℓ . We can also extend the model and allow the modification of b j in both direction, meaning 34 that ∆b j could be positive or negative, where the objective function asks for the minimization of the sum of absolute values of all ∆b j . Note that in this case it is not clear whether it would be beneficial from a global perspective to increase the intercept of the currently considered job j, or rather decrease the intercepts of all the other jobs, which so far prevent j from being chosen by MaxMinGreedy. Such a decrease of other jobs might be beneficial for future decisions of the algorithm. A similar extension can be considered for the slope where we allow negative ∆a j , i.e., an increase of the negative slope. Clearly, the above approach does not work anymore for this general case and we are not aware of a combinatorial algorithm for the resulting optimization problem. However, we can give an LP-formulation, which implies that the problem remains polynomially solvable. For convenience, we denote by P j := p 1 +... +p j the desired completion time of job j. min X j∈N |∆b j |(15) s.t. ∆b j − ∆b i ≥ b i − b j − (a i − a j )P j 1≤ i < j ≤ n(16) ∆b j ∈ R j = 1,...,n(17) Conditions (16) are derived from the selection criterion of MaxMinGreedy for job j at time P j , i.e., ∆b j + u j (P j ) ≥ ∆b i + u i (P j ). The absolute values in the objective function can be handled by standard methods of LP-modeling. An analogous model works for the modification of the slopes. min X j∈N |∆a j |(18) s.t. (∆a j − ∆a i )P j ≥ b i − b j − (a i − a j )P j 1≤ i < j ≤ n(19) ∆a j ≤ a j ,∆a j ∈ R j = 1,...,n(20) Note that contrary to the case ∆a j ≥ 0, in the general case every target sequence can be attained by a suitable choice of ∆a j . For the corresponding case of 1|σ T := σ SYS ,u j = b j − ̃a j C j | P ∆a j with possibly negative ∆a j , we replace (19) by ∆a j − p j p i ∆a i ≤ a j − p j p i a i 1≤ i < j ≤ n.(21) For this case we can also derive a simple combinatorial algorithm based on dynamic pro- gramming. It is based on the following observation. When we choose ∆a j to reach an ordering of jobs in non-increasing order of ̃a j /p j , the new slopes will always be set in such a way that the new ratios ̃a j /p j attain one of the n original values a i /p i . Let R := a i /p i | 1 ≤ i ≤ n be this set of all relevant ratio values. Otherwise, let J r be the set of all jobs j with ̃a j /p j = r and r ̸∈ R. A marginal increase of r for all jobs in J r to r + ε would allow a decrease of the slope reduction for jobs with positive ∆a j by εp j (say these are jobs J + r ), but require a further reduction of all negative ∆a j by εp j (for jobs J − r ). The same applies with exchanged signs for a marginal decrease of r to r− ε. Therefore, the total increase of the objective function (18) 35 is P j∈J − r εp j − P j∈J + r εp j for reaching r + ε, while it is − P j∈J − r εp j + P j∈J + r εp j for reaching r− ε. Clearly, one of the two contributions has to be negative and thus improves the objective function. The value of ε in this direction can be extended until the nearest value in R is reached. We introduce a dynamic programming array representing the cost of setting the ratio of job j to r ∈R. Formally we define: c j [r] = cost of setting ̃a j /p j = r plus the minimum cost such that the ratios ̃a i /p i of all jobs i = j + 1,...,n are sorted in non-increasing order. The computation of c j [r] is performed in decreasing order of j, i.e. j = n,n− 1,..., 1 for every r ∈ R. To reach ̃a j /p j = (a j − ∆a j )/p j = r, we have costs of ∆a j = a j − p j · r. Including the cost for the correct ordering of jobs j + 1,...,n, which is already collected in c j+1 [r], we get c j [r] :=|a j − p j · r| + min ρ∈R c j+1 [ρ] : ρ≤ r.(22) Going through the values of r in increasing order, we can compute c j [r] in linear time so that the total running time for solving 1|σ T := σ SYS ,u j = b j − ̃a j C j | P ∆a j with arbitrary ∆a j is O(n 2 ). 8 Conclusions In this work, we have investigated a broad family of multi-agent scheduling problems with the aim of reaching a fair solution (in a maximin sense) for agents which may differ in their utility functions, temporal constraints, and degrees of flexibility in adjusting their parameters. Our analysis clarifies how release dates, due dates, and agent-specific utility models shape the underlying difficulty of the problem, and how controlled modifications of the input parameters can be leveraged to attain desirable schedules. Building on these insights, we have developed exact approaches that enable the computation of fair schedules, and – whenever this seems meaningful for the considered problem setting – we also treated the efficient version, where the sum of utilities is maximized. Furthermore, our exploration of adjustable utility functions and leader–follower scenarios highlights how external interventions, such as budget-bounded modifications of utilities, can influence the resulting schedules, revealing connections between fairness, incentives, and strategic control in multi-agent environments. It is worth to mention here that our study extends to more general notions of fairness, such as the Kalai-Smorodinsky fair solution, in which the minimum of the normalized utility across the agents is maximized (Kalai and Smorodinsky, 1975). More precisely, looking at the range I j = max σ∈S u j (σ)− min σ∈S u j (σ) of utility values that j may obtain among any semi-active schedule, the normalized utility ̄u j of agent j is defined as the ratio ̄u j (σ) = u j /I j . For instance, recalling Definition 2, in the case of linear utility functions and no release dates, if P = P j p j , then I j = a j (P−p j ) and hence the normalized utilities for all j are known for any given schedule. If this range can be computed in advance for every agent, any algorithm that computes u F can also be applied to obtain a Kalai-Smorodinsky fair solution (although the resulting schedules may be different). 36 For future research one can consider the case of m parallel machines, possibly with different specifications. Looking at the special case with m = 2 parallel identical machines, one can easily show that our problem is weakly NP-hard, even if all jobs have the same linear utility function. In a similar flavor as in Section 4.3, a pseudopolynomial algorithm based on dynamic program can be devised for the latter problem. References Agnetis, A., Benini, M., Nicosia, G., and Pacifici, A. (2025). Trade-off between utility and fairness in two-agent single-machine scheduling. European Journal of Operational Research, 323(3):767–779. Agnetis, A., Chen, B., Nicosia, G., and Pacifici, A. (2019). Price of fairness in two-agent single- machine scheduling problems. European Journal of Operational Research, 276(1):79–87. Agnetis, A., Mirchandani, P. B., Pacciarelli, D., and Pacifici, A. (2004). Scheduling problems with two competing agents. Operations Research, 52(2):229–242. Agnetis, A., Nicosia, G., Pacifici, A., and Pferschy, U. (2015). Scheduling two agent task chains with a central selection mechanism. Journal of Scheduling, 18(3):243–261. Agnetis, A., Pacciarelli, D., and Pacifici, A. (2007). Multi-agent single machine scheduling. Annals of Operations Research, 150(1):3–15. Baker, K. R. and Smith, J. C. (2003). A multiple-criterion model for machine scheduling. Journal of Scheduling, 6(1):7–16. Baptiste, P. (1999). Polynomial time algorithms for minimizing the weighted number of late jobs on a single machine with equal processing times. Journal of Scheduling, 2(6):245–252. Baptiste, P. (2000). Scheduling equal-length jobs on identical parallel machines. Discrete Applied Mathematics, 103(1):21–32. Bertsimas, D., Farias, V., and Trichakis, N. (2011). The price of fairness. Operations Research, 59(1):17–31. Biskup, D. (2008). A state-of-the-art review on scheduling with learning effects. European Journal of Operational Research, 188(2):315–329. Burkard, R., Dell’Amico, M., and Martello, S. (2012). Assignment Problems. Society for Indus- trial and Applied Mathematics. Carlier, J. (1981). Probl`eme `a une machine et algorithmes polynˆomiaux. QUESTIO, 5(4):219– 228. Chen, B., Potts, C. N., and Woeginger, G. J. (1998). A review of machine scheduling: Com- plexity, algorithms and approximability. In Du, D.-Z. and Pardalos, P. M., editors, Handbook of Combinatorial Optimization: Volume1–3, pages 1493–1641. Springer US, Boston, MA. 37 Chen, R., Li, S.-S., Yuan, J., and Zhao, Q. (2026). Competing multi-agent scheduling of equal- length jobs on a single machine or uniform parallel machines. European Journal of Operational Research. in press. Cheng, T. E., Kovalyov, M. Y., and Shakhlevich, N. V. (2006). Scheduling with controllable release dates and processing times: Total completion time minimization. European Journal of Operational Research, 175(2):769–781. Correa, J. R. and Queyranne, M. (2012). Efficiency of equilibria in restricted uniform machine scheduling with total weighted completion time as social cost. Naval Research Logistics, 59(5):384 – 395. Curiel, I., Pederzoli, G., and Tijs, S. (1989). Sequencing games. European Journal of Operational Research, 40(3):344–351. Dedehayir, O. and Steinert, M. (2016). The hype cycle model: A review and future directions. Technological Forecasting and Social Change, 108:28–41. Gawiejnowicz, S. (2008). Time-dependent scheduling. Monographs in Theoretical Computer Science. An EATCS Series. Springer. Gordon, V. S., Proth, J.-M., and Chu, C. (2002). Due date assignment and scheduling: SLK, TWK and other due date assignment models. Production Planning and Control, 13(2):117 – 132. Hall, N. G. and Potts, C. N. (2004). Rescheduling for new orders. Operations Research, 52(3):440–453. Hermelin, D., Molter, H., Niedermeier, R., Pinedo, M., and Shabtay, D. (2025). Fairness in repetitive scheduling. European Journal of Operational Research, 323(3):724–738. Hoeksma, R. and Uetz, M. (2019). The price of anarchy for utilitarian scheduling games on related machines. Discrete Optimization, 31:29–39. H ̈ohn, W. and Jacobs, T. (2015). On the performance of Smith’s rule in single-machine schedul- ing with nonlinear cost. ACM Transactions on Algorithms, 11(4). Huang, X. and Wang, M. (2014). Single machine group scheduling with time and position dependent processing times. Optimization Letters, 8:1475–1485. Kalai, E. and Smorodinsky, M. (1975). Other Solutions to Nash’s Bargaining Problem. Econo- metrica, 43(3):513–518. K ̈ampke, T. and Radermacher, F. J. (2015). The generalized inverse of distribution functions. Lecture Notes in Economics and Mathematical Systems, 679:9–28. Kellerer, H., Pferschy, U., and Pisinger, D. (2004). Knapsack Problems. Springer. 38 Lawler, E. (1978). Sequencing jobs to minimize total weighted completion time subject to precedence constraints. Annals of Discrete Mathematics, 2:75–90. Lawler, E. L. (1973). Optimal sequencing of a single machine subject to precedence constraints. Management Science, 19(5):544–546. Lenstra, J., Rinnooy Kan, A., and Brucker, P. (1977). Complexity of machine scheduling prob- lems. In Hammer, P., Johnson, E., Korte, B., and Nemhauser, G., editors, Studies in Integer Programming, volume 1 of Annals of Discrete Mathematics, pages 343–362. Elsevier. Lenstra, J. K. and Shmoys, D. B. (2020). Elements of scheduling. CoRR, abs/2001.06005. Li, S.-S. and Yuan, J.-J. (2020). Single-machine scheduling with multi-agents to minimize total weighted late work. Journal of Scheduling, 23:497–512. Lu, Y.-Y., Wang, J.-J., and Huang, X. (2015). Scheduling jobs with position and sum-of- processing-time based processing times. Applied Mathematical Modelling, 39(14):4013–4021. Moore, J. M. (1968). An n job, one machine sequencing algorithm for minimizing the number of late jobs. Management Science, 15(1):102–109. Nicosia, G., Pacifici, A., and Pferschy, U. (2017). Price of fairness for allocating a bounded resource. European Journal of Operational Research, 257(3):933–943. Nicosia, G., Pacifici, A., Pferschy, U., Resch, J., and Righini, G. (2021). Optimally rescheduling jobs with a last-in-first-out buffer. Journal of Scheduling, 24(6):663–680. Niu, A., Totschnig, A., and Vetta, A. (2023). Fair algorithm design: Fair and efficacious machine scheduling. In Deligkas, A. and Filos-Ratsikas, A., editors, Algorithmic Game Theory, pages 239–256. Springer. Raut, S., Gupta, J. N. D., and Swami, S. (2008a). Single machine scheduling with time deteri- orating job values. Journal of the Operational Research Society, 59(1):105–118. Raut, S., Swami, S., and Gupta, J. N. (2008b). Scheduling a capacitated single machine with time deteriorating job values. International Journal of Production Economics, 114(2):769–780. Rener, E., Salassa, F., and T’kindt, V. (2025). Single machine rescheduling for new orders with maximum and total time disruption constraints. Journal of Scheduling, 28:469–482. Shabtay, D. and Steiner, G. (2007). A survey of scheduling with controllable processing times. Discrete Applied Mathematics, 155(13):1643–1666. Simons, B. (1978). A fast algorithm for single processor scheduling. In 19th Annual Symposium on Foundations of Computer Science, pages 246–252. Smith, W. E. (1956). Various optimizers for single-stage production. Naval Research Logistics Quarterly, 3(1–2):59–66. 39 Strusevich, V. A. and Rustogi, K. (2016). Scheduling with flexible maintenance. In Scheduling with Time-Changing Effects and Rate-Modifying Activities, volume 243 of International Series in Operations Research & Management Science, pages 291–315. Springer. Townsend, W. (1978). The single machine problem with quadratic penalty function of completion times: A branch-and-bound solution. Management Science, 24(5):530–534. Vardi, S. and Haskell, W. (2025). The price of fairness of scheduling a scarce resource. Operations Research, 73(6):3104–3117. Wang, D., Yu, Y., Yin, Y., and Cheng, T. C. E. (2021). Multi-agent scheduling problems under multitasking. International Journal of Production Research, 59(12):3633–3663. Wellman, M. P., Walsh, W. E., Wurman, P. R., and MacKie-Mason, J. K. (2001). Auction protocols for decentralized scheduling. Games and Economic Behavior, 35(1):271–303. Yuan, J. (2017). Multi-agent scheduling on a single machine with a fixed number of competing agents to minimize the weighted sum of number of tardy jobs and makespans. Journal of Combinatorial Optimization, 34(2):433–440. Zhang, Y., Zhang, Z., and Liu, Z. (2020). The price of fairness for a two-agent scheduling game minimizing total completion time. Journal of Combinatorial Optimization, 44:2104–2122. 40 Appendix Proof of Theorem 2 If, for all j ∈ J , u j is any non-increasing function of the completion time C j of job j, then MaxMinGreedy computes an optimal solution of 1|u j |u min in O(n 2 ) time. For a given schedule σ, let z(σ) = min j∈J u j (C j ) indicate its corresponding solution value. Let σ F be an optimal schedule in which i∈ J is the last job: Since we may assume w.l.o.g. that σ F has no idle times, i completes at C i (σ F ) = P = P j∈J p j . Let i∈ J be the job selected by the algorithm, i.e., i = arg max h∈J u h (P ) and assume, by contradiction, that u i (P ) < u i (P ). Consider a schedule ̃σ obtained from σ F by just postponing job i and sequencing it as the last job, immediately after i. In ̃σ all jobs, but i, have not increased their completion times and hence, recalling our objective function definition: z(σ F )≤ u h (C h (σ F ) ≤ u h (C h ( ̃σ)) for all h ∈ J \i. On the other hand z(σ F ) ≤ u i (C i (σ F )) = u i (P ) < u i (P ) = u i (C i ( ̃σ)). In conclusion z(σ F ) ≤ min h∈J u h (C h ( ̃σ)) = z( ̃σ), so ̃σ is optimal as well. This argument can be recursively iterated at time P − p i , showing the correctness of MaxMinGreedy. □ Proof of Theorem 3 Problem 1|r j ,u j |u min is strongly NP-hard, even for linear utility functions. Consider an instance I L of the scheduling problem with due dates and release dates where maximum lateness L max is minimized, i.e., 1|r j |L max , which was shown to be strongly NP-hard by Lenstra et al. (1977). We can construct an instance of our problem with the same release dates and utility functions u j = d j − C j + M , where M > 0 is large enough to guarantee that u j ≥ 0 for any reasonable value of C j . Considering the solution of our problem as a solution for I L , it is easy to see that the lateness L j := C j − d j = −u j + M . If there is a solution with u F ≥ K + M , then for I L there is a solution with L max ≤−K, and vice versa.□ Proof of Theorem 4 Problem 1|r j ,u j |u min is weakly NP-hard, even if the utility functions are linear and only one release date is nonzero. For only one release date r n+1 ̸= 0, 1|r j ,u j |u min can be reduced from Partition. Let the instance I P of Partition be defined by n integers w 1 ,...,w n and let B = 1 2 P n i=1 w i . The problem asks for a subset S of numbers summing up to B. The corresponding instance I of our scheduling problem is the following. We have n + 1 jobs, where the first n jobs correspond to the items in I P . The data are: p j = ( w j for j = 1, 2,...,n Bfor j = n + 1 41 r j = ( 0for j = 1, 2,...,n B for j = n + 1 u j (C j ) = ( 2B− 1 3 C j for j = 1, 2,...,n 5B− 2C j j = n + 1 If I P is a yes-instance, then in I one can schedule the jobs of S between time 0 and B, then start job n + 1 at time B and append the remaining jobs 1,...,n\ S between time 2B and 3B. This yields utility 5B − 2· 2B = B for job n + 1 and utility 2B − 1 3 3B = B for the job scheduled last among 1,...,n, i.e. the job reaching the lowest utility, which gives u F = B. If I P is a no-instance, one can either schedule job n + 1 at time B, reaching again utility B. Since the total length of jobs scheduled before time B must be strictly less than B (no-instance), the remaining jobs to be scheduled after job n + 1 from time 2B must have total length at least B + 1. Thus, the utility of the last job is at most 2B− 1 3 (2B + B + 1) ≤ B− 1 3 . Otherwise, if job n + 1 is scheduled later than B, its utility is at most 5B− 2(B + 1 + B) = B− 2. In both cases there is u F < B, which means that the optimal solution of I would decide Partition. □ Proof of Theorem 16 Problem (14) 1|resch,u j ≥ u F |u n+1 can be solved in O(n 2 logP ) time. Problem 1|resch,u j ≥ u F |u n+1 can be solved by combining two results of this paper (namely, Theorem 1 and the procedure given in Section 5.1). First of all, we perform a binary search for the minimum completion time C n+1 of job n + 1, taking O(logP ) iterations. Clearly, C n+1 must be between p n+1 and P = P n+1 j=1 p j . Each target value C T n+1 of the binary search implies a utility function u n+1 (C) = M for C ≤ C T n+1 and u n+1 (C) = 0 otherwise. Then we can run MaxMinGreedy to obtain a feasible schedule σ T with maximum minimum utility u min (σ T ) in O(n 2 ) time. For this schedule we apply the linear time procedure given in Section 5.1 to increase the utility functions by constant shifts ∆b j representing the payments β j with a given budget bound B = R (which applies also for arbitrary utility functions). Note that during this increase the (auxiliary) utility function u n+1 (C) of job n + 1 will never be modified. If the resulting improved maximum minimum is at least u F we can continue the binary search with a target value greater than C T , otherwise a smaller target value is chosen.□ 42