Single-machine scheduling

The problem 1||${\displaystyle \sum C_{j}}$ aims to minimize the sum of completion times. It can be solved optimally by the Shortest Processing Time First rule (SPT): the jobs are scheduled by ascending order of their processing time ${\displaystyle p_{j}}$.

The problem 1||${\displaystyle \sum w_{j}C_{j}}$ aims to minimize the weighted sum of completion times. It can be solved optimally by the Weighted Shortest Processing Time First rule (WSPT): the jobs are scheduled by ascending order of the ratio ${\displaystyle p_{j}/w_{j}}$.[2]^{: lecture 1, part 2}

The problem 1|chains|${\displaystyle \sum w_{j}C_{j}}$ is a generalization of the above problem for jobs with dependencies in the form of chains. It can also be solved optimally by a suitable generalization of WSPT.[2]^{: lecture 1, part 3}

The problem 1||${\displaystyle L_{\max }}$ aims to minimize the maximum lateness. For each job j, there is a due date ${\displaystyle d_{j}}$. If it is completed after its due date, it suffers lateness defined as ${\displaystyle L_{j}:=C_{j}-d_{j}}$. 1||${\displaystyle L_{\max }}$ can be solved optimally by the Earliest Due Date First rule (EDD): the jobs are scheduled by ascending order of their deadline ${\displaystyle d_{j}}$.[2]^{: lecture 2, part 2}

The problem 1|prec|${\displaystyle h_{\max }}$ generalizes the 1||${\displaystyle L_{\max }}$ in two ways: first, it allows arbitrary precedence constraints on the jobs; second, it allows each job to have an arbitrary cost function h_j, which is a function of its completion time (lateness is a special case of a cost function). The maximum cost can be minimized by a greedy algorithm known as Lawler's algorithm.[2]^{: lecture 2, part 1}

The problem 1|${\displaystyle r_{j}}$|${\displaystyle L_{\max }}$ generalizes 1||${\displaystyle L_{\max }}$ by allowing each job to have a different release time by which it becomes available for processing. The presence of release times means that, in some cases, it may be optimal to leave the machine idle, in order to wait for an important job that is not released yet. Minimizing maximum lateness in this setting is NP-hard. But in practice, it can be solved using a branch-and-bound algorithm.[2]^{: lecture 2, part 3}

In settings with deadlines, it is possible that, if the job is completed by the deadline, there is a profit p_j. Otherwise, there is no profit. The goal is to maximize the profit. Single-machine scheduling with deadlines is NP-hard; Sahni[3] presents both exact exponential-time algorithms and a polynomial-time approximation algorithm.

The problem 1||${\displaystyle \sum U_{j}}$ aims to minimize the number of late jobs, regardless of the amount of lateness. It can be solved optimally by the Hodgson-Moore algorithm.[4][2]^{: lecture 3, part 1} It can also be interpreted as maximizing the number of jobs that complete on time; this number is called the throughput.

The problem 1||${\displaystyle \sum w_{j}U_{j}}$ aims to minimize the weight of late jobs. It is NP-hard, since the special case in which all jobs have the same deadline (denoted by 1|${\displaystyle d_{j}=d}$|${\displaystyle \sum w_{j}U_{j}}$ ) is equivalent to the Knapsack problem.[2]^{: lecture 3, part 2}

The problem 1|${\displaystyle r_{j}}$|${\displaystyle \sum U_{j}}$ generalizes 1||${\displaystyle \sum U_{j}}$ by allowing different jobs to have different release times. The problem is NP-hard. However, when all job lengths are equal, the problem can be solved in polynomial time. It has several variants:

• The weighted optimization variant, 1|${\displaystyle r_{j},p_{j}=p}$|${\displaystyle \sum w_{j}U_{j}}$, can be solved in time ${\displaystyle O(n^{7})}$.[5]
• The unweighted optimization variant, maximizing the number of jobs that finish on time,denoted 1|${\displaystyle r_{j},p_{j}=p}$|${\displaystyle \sum U_{j}}$, can be solved in time ${\displaystyle O(n^{5})}$ using dynamic programming, when all release times and deadlines are integers.[6][7]
• The decision variant - deciding whether it is possible that all given jobs complete on time - can be solved by several algorithms,[8] the fastest of them runs in time ${\displaystyle O(n\log n)}$.[9]

Jobs can have execution intervals. For each job j, there is a processing time t_j and a start-time s_j, so it must be executed in the interval [s_j, s_j+t_j]. Since some of the intervals overlap, not all jobs can be completed. The goal is to maximize the number of completed jobs, that is, the throughput. More generally, each job may have several possible intervals, and each interval may be associated with a different profit. The goal is to choose at most one interval for each job, such that the total profit is maximized. For more details, see the page on interval scheduling.

More generally, jobs can have time-windows, with both start-times and deadlines, which may be larger than the job length. Each job can be scheduled anywhere within its time-window. Bar-Noy, Bar-Yehuda, Freund, Naor and Schieber[10] present a (1-ε)/2 approximation.

• Interval scheduling

Many solution techniques have been applied to solving single machine scheduling problems. Some of them are listed below.

• Genetic algorithms
• Neural networks
• Simulated annealing
• Ant colony optimization
• Tabu search