Scheduling machine-dependent jobs to minimize lateness on machines with identical speed under availability constraints

In this paper we consider the problem of scheduling n$n$ preemptive jobs on m$m$ machines with identical speed under machine availability and eligibility constraints when minimizing maximum lateness (_Lmax$(L_{\max }$). The lateness of a job is defined to be its completion time minus its due date, and _Lmax$L_{\max }$ is the maximum value of lateness among all jobs. We assume that each machine is not continuously available at all time throughout the planning horizon and each job is only allowed to be processed on specific machines. Network flow technique is used to formulate this scheduling problem into a series of maximum flow problems. We propose a polynomial time two-phase binary search algorithm to verify the feasibility of the problem and to solve the scheduling problem optimally if a feasible schedule exists. Finally, we show that the time complexity of the algorithm is O((n+(2n+2x))³log(UB-LB))$O((n+(2n+2x){)}^3\log (\text{<italic>UB</italic>}-\text{<italic>LB</italic>}))$. Most literature in parallel machine scheduling assume that all machines are continuously available for processing and all jobs can be processed at any available machine throughout the planning horizon. But both assumptions might not be true in some practical environment, such as machine preventive maintenance and machines that have different capabilities to process jobs. This type of scheduling problem is seldom studied in the literature. The purpose of this paper is to examine the scheduling problem with machines with identical speed under machine availability and eligibility constraints. The objective is to minimize maximum lateness. We formulate this scheduling problem into a series of maximum flow problems with different values of _Lmax$L_{\max }$. A polynomial time two-phase binary search algorithm is proposed to verify the feasibility of the problem and to determine the optimal _Lmax$L_{\max }$.     

A memetic algorithm for the job-shop with time-lags

The job-shop with time-lags (JS|t)$(\text{<italic>JS</italic>}|t)$ is defined as a job-shop problem with minimal and maximal delays between starting times of operations. In this article, time-lags between successive operations of the same job (JS|_ti,si)$(\text{<italic>JS</italic>}|t_{i,s_i})$ are studied. This problem is a generalization of the job-shop problem (null minimal time-lags and infinite maximal time-lags) and the no-wait job-shop problem (null minimal and maximal time-lags). This article introduced a framework based on a disjunctive graph to modelize the problem and on a memetic algorithm for job sequence generation on machines.     

Erlang loss queueing system with batch arrivals operating in a random environment

We consider the BMAP/PH/N/0$\text{<italic>BMAP</italic>}/\text{<italic>PH</italic>}/N/0$ queueing system operating in a finite state space Markovian random environment. Disciplines of partial admission, complete rejection and complete admission are analyzed. The stationary distribution of the system states is calculated. The loss probability and other main performance measures of the system are derived. The Laplace–Stieltjes transform of the sojourn time distribution of accepted customers is obtained. Illustrative numerical examples are presented. They show effect of an admission strategy, a correlation in an arrival process, a variation of a service process. Poor quality of the loss probability approximation by means of more simple models utilization is illustrated.     

A hybrid algorithm for the single-machine total tardiness problem

We propose a hybrid algorithm based on the ant colony optimization (ACO) meta-heuristic, in conjunction with four well-known elimination rules, to tackle the NP$\mathit{NP}$-hard single-machine scheduling problem to minimize the total job tardiness. The hybrid algorithm has the same running time as that of ACO. We conducted extensive computational experiments to test the performance of the hybrid algorithm and ACO. The computational results show that the hybrid algorithm can produce optimal or near-optimal solutions quickly, and its performance compares favourably with that of ACO for handling standard instances of the problem.     

Fast deterministic broadcast and gossiping algorithms for mobile ad hoc networks

We present a mobility resilient deterministic broadcast algorithm with worst-case time complexity of O(nlogn)$O(nlogn)$ for ad hoc networks where the nodes possess collision detection capabilities; n$n$ is the total number of nodes in the network. The algorithm is based on a breadth-first traversal of the network and allows multiple simultaneous transmissions by the nodes. The idea of this broadcast algorithm is then extended to develop a mobility resilient deterministic gossiping algorithm having O(Dnlogn)$O(Dnlogn)$ worst-case run time (D$D$ is the diameter of the network graph), which is an improvement over the existing algorithms. Simulation results show that on an average, the time for completing the broadcast or gossiping is significantly lower than the theoretical worst-case time requirement.     

On the connectivity preserving minimum cut problem

In this paper, we study a generalization of the classical minimum cut problem, called Connectivity Preserving Minimum Cut (CPMC) problem, which seeks a minimum cut to separate a pair (or pairs) of source and destination nodes and meanwhile ensure the connectivity between the source and its partner node(s). For this problem, we consider two variants, connectivity preserving minimum node cut (CPMNC) and connectivity preserving minimum edge cut (CPMEC). For CPMNC, we show that it cannot be approximated within α logn for some constant α   unless P=NP$P=\mathit{NP}$, and cannot be approximated within any poly(logn)$\mathit{poly}(\mathit{logn})$ unless NP has quasi-polynomial time algorithms. The hardness results hold even for graphs with unit weight and bipartite graphs. For CPMEC, we show that it is in P for planar graphs.     

Sampling methods for shortest vectors,closest vectors and successive minima

We study four problems from the geometry of numbers, the shortest vector problem  (Svp)$\left(\text{<small-caps>Svp</small-caps>}\right)$, the closest vector problem  (Cvp)$\left(\text{<small-caps>Cvp</small-caps>}\right)$, the successive minima problem  (Smp)$\left(\text{<small-caps>Smp</small-caps>}\right)$, and the shortest independent vectors problem   (Sivp$\text{<small-caps>Sivp</small-caps>}$). Extending and generalizing results of Ajtai, Kumar, and Sivakumar we present probabilistic single exponential time algorithms for all four problems for all _?p${?}_p$ norms. The results on Smp$\text{<small-caps>Smp</small-caps>}$ and Sivp$\text{<small-caps>Sivp</small-caps>}$ are new for all norms. The results on Svp$\text{<small-caps>Svp</small-caps>}$ and Cvp$\text{<small-caps>Cvp</small-caps>}$ generalize previous results of Ajtai et al. for the Euclidean _?2${?}_2$ norm to arbitrary _?p${?}_p$ norms. We achieve our results by introducing a new lattice problem, the generalized shortest vector problem   (GSvp$\text{<small-caps>GSvp</small-caps>}$). ¹ We describe a single exponential time algorithm for GSvp$\text{<small-caps>GSvp</small-caps>}$. We also describe polynomial time reductions from Svp,Cvp,Smp$\text{<small-caps>Svp</small-caps>},\text{<small-caps>Cvp</small-caps>},\text{<small-caps>Smp</small-caps>}$, and Sivp$\text{<small-caps>Sivp</small-caps>}$ to GSvp$\text{<small-caps>GSvp</small-caps>}$, establishing single exponential time algorithms for the four classical lattice problems. This approach leads to a unified algorithmic treatment of the lattice problems Svp,Cvp,Smp$\text{<small-caps>Svp</small-caps>},\text{<small-caps>Cvp</small-caps>},\text{<small-caps>Smp</small-caps>}$, and Sivp$\text{<small-caps>Sivp</small-caps>}$.     

Efficient detection of a locally stable predicate in a distributed system

We present an efficient approach to detect a locally stable predicate in a distributed computation. Examples of properties that can be formulated as locally stable predicates include termination and deadlock of a subset of processes. Our algorithm does not require application messages to be modified to carry control information (e.g., vector timestamps), nor does it inhibit events (or actions) of the underlying computation. The worst-case message complexity of our algorithm is O(n(m+1))$O(n(m+1))$, where n$n$ is the number of processes in the system and m$m$ is the number of events executed by the underlying computation. We show that, in practice, its message complexity should be much lower than its worst-case message complexity. The detection latency of our algorithm is O(d)$O(d)$ time units, where d$d$ is the diameter of communication topology. Our approach also unifies several known algorithms for detecting termination and deadlock. We also show that our algorithm for detecting a locally stable predicate can be used to efficiently detect a stable predicate that is a monotonic function of other locally stable predicates.     

Scheduling light-trails on WDM rings

We consider the problem of scheduling communication on optical WDM (wavelength division multiplexing) networks using the light-trails technology. We seek to design scheduling algorithms such that the given transmission requests can be scheduled using a minimum number of wavelengths (optical channels). We provide algorithms and close lower bounds for two versions of the problem on an n$n$ processor linear array/ring network. In the stationary   version, the pattern of transmissions (given) is assumed to not change over time. For this, a simple lower bound is c$c$, the congestion or the maximum total traffic required to pass through any link. We give an algorithm that schedules the transmissions using O(c+logn)$O(c+logn)$ wavelengths. We also show a pattern for which Ω(c+logn/loglogn)$\Omega (c+logn/loglogn)$ wavelengths are needed. In the on-line   version, the transmissions arrive and depart dynamically, and must be scheduled without upsetting the previously scheduled transmissions. For this case we give an on-line algorithm which has competitive ratio Θ(logn)$\Theta (logn)$. We show that this is optimal in the sense that every on-line algorithm must have competitive ratio Ω(logn)$\Omega (logn)$. We also give an algorithm that appears to do well in simulations (for the classes of traffic we consider), but which has competitive ratio between Ω(log²n/loglogn)$\Omega ({log}^{2}n/loglogn)$ and O(log²n)$O\left({log}^{2}n\right)$. We present detailed simulations of both our algorithms.     

Minimizing the earliness–tardiness costs on a single machine

In this paper the one-machine scheduling problem with linear earliness and tardiness costs is considered. The cost functions are job dependent and asymmetric. The problem consists of two sub-problems. The first one is to find a sequence of jobs and the second one is to find the job completion times that are optimal for the given sequence. We consider the second sub-problem and propose an algorithm solving the problem in O(nlogn)$\mathrm{O}(n\log n)$ time.