Given @math intervals on a line @math , we consider the problem of moving these intervals on @math such that no two intervals overlap and the maximum moving distance of the intervals is minimized. The difficulty for solving the problem lies in determining the order of the intervals in an optimal solution. By interesting observations, we show that it is sufficient to consider at most @math "candidate" lists of ordered intervals. Further, although explicitly maintaining these lists takes @math time and space, by more observations and a pruning technique, we present an algorithm that can compute an optimal solution in @math time and @math space. We also prove an @math time lower bound for solving the problem, which implies the optimality of our algorithm.
The main aim of this note is to show that a polynomial-time algorithm for the scheduling problem 1|r j ; p j = p| ∑ Uj given by Carlier in (1981) is incorrect. In this problem we are given n jobs with release times and deadlines. All jobs have the same processing time p. The objective is to find a non-preemptive schedule that maximizes the number of jobs completed by their deadlines. The feasibility version of this problem, where we ask whether all jobs can meet their deadlines, has been studied thoroughly. Polynomial-time algorithms for this version were first found, independently, by Simons (1978) and Carlier (1981). A faster algorithm, with running time O(n log n), was subsequently given by (1981). The elegant feasibility algorithm of Carlier (1981) is based on dynamic programming and it processes jobs from left to right on the time-axis. For each time t, it constructs a partial schedule with jobs that complete at or before time t. Carlier also attempted to apply the same technique to design a polynomial-time algorithm for the maximization version, 1|r j ; p j = p| ∑ Uj , and claimed an O(n3 log n)-time algorithm. His result is now widely cited in the literature. We show, however, that this algorithm is not correct, by giving an instance on which it produces a sub-optimal schedule. Our counter-example can be, in fact, extended to support a broader claim, namely that even the general approach from Carlier (1981) cannot yield a polynomial-time algorithm. By this general approach we mean a class of algorithms that processes the input from left to right and make decisions based on the deadline ordering, and not their exact values. The question remains as to how efficiently can we solve the scheduling problem 1|r j ; p j = p| ∑ Uj . Baptiste (1999) gave an O(n7)-time algorithm for the more general version of this problem where jobs have weights. We show how to modify his algorithm to obtain a faster, O(n5)-time algorithm for the non-weighted case. These last two results are discussed only briefly in this note. The complete proofs can be found in the full version of this paper, see (2004). We consider the problem of scheduling jobs with given release times and due dates on a single machine to minimize the maximum job lateness. It is NP-hard and remains such if the maximal job processing time is unrestricted and there is no constant bound on the difference between any job release times. We give a polynomial-time solution of the version in which the maximal job processing time and the differences between the job release times are bounded by a constant, which are restrictions that naturally arise in practice. Our algorithm reveals the inherent structure of the problem and also gives conditions when it is able to find an optimal solution unconditionally.   The basic problem considered is that of scheduling n unit-time tasks, with arbitrary release times and deadlines, so as to minimize the maximum task completion time. Previous work has shown that this problem can be solved rather easily when all release times are integers. We are concerned with the general case in which noninteger release times are allowed, a generalization that considerably increases the difficulty of the problem even for only a single processor. Our results are for the one-processor case, where we provide an @math algorithm based on the concept of “forbidden regions”.  The flameproof styrene polymer foam in accordance with this invention is obtained by melting a granular mixture of styrene polymer and aluminum hydroxide having a grain size of 20-100 mu m and a specific surface of below 1 m2 g in an extruder, incorporating a physical expanding agent, and homogenizing and extruding the mixture. We consider the following scheduling problem. The input is a set of jobs with equal processing times, where each job is specified by its release time and deadline. The goal is to determine a single-processor nonpreemptive schedule that maximizes the number of completed jobs. In the online version, each job arrives at its release time. We give two online algorithms with competitive ratios below @math and show several lower bounds on the competitive ratios. First, we give a barely random @math -competitive algorithm that uses only one random bit. We also show a lower bound of @math on the competitive ratio of barely random algorithms that randomly choose one of two deterministic algorithms. If the two algorithms are selected with equal probability, we can further improve the bound to @math . Second, we give a deterministic @math -competitive algorithm in the model that allows restarts, and we show that in this model the ratio @math is optimal. For randomized algorithms with restarts we show a lower bound of @math . We study inherent structural properties of a strongly NP-hard problem of scheduling @math jobs with release times and due dates on a single machine to minimize the number of late jobs. Our study leads to two polynomial-time algorithms. The first algorithm with the time complexity @math solves the problem if during its execution no job with some special property occurs. The second algorithm solves the version of the problem when all jobs have the same length. The time complexity of the latter algorithm is @math , which is an improvement over the earlier known algorithm with the time complexity @math .