Dynamic Maintenance of Monotone Dynamic Programs and Applications

Dynamic programming (DP) is one of the fundamental paradigms in algorithm design. However, many DP algorithms have to fill in large DP tables, represented by two-dimensional arrays, which causes at least quadratic running times and space usages. This has led to the development of improved algorithms for special cases when the DPs satisfy additional properties like, e.g., the Monge property or total monotonicity. In this paper, we consider a new condition which assumes (among some other technical assumptions) that the rows of the DP table are monotone. Under this assumption, we introduce a novel data structure for computing (1+?)-approximate DP solutions in near-linear time and space in the static setting, and with polylogarithmic update times when the DP entries change dynamically. To the best of our knowledge, our new condition is incomparable to previous conditions and is the first which allows to derive dynamic algorithms based on existing DPs. Instead of using two-dimensional arrays to store the DP tables, we store the rows of the DP tables using monotone piecewise constant functions. This allows us to store length-n DP table rows with entries in [0,W] using only polylog(n,W) bits, and to perform operations, such as (min,+)-convolution or rounding, on these functions in polylogarithmic time. We further present several applications of our data structure. For bicriteria versions of k-balanced graph partitioning and simultaneous source location, we obtain the first dynamic algorithms with subpolynomial update times, as well as the first static algorithms using only near-linear time and space. Additionally, we obtain the currently fastest algorithm for fully dynamic knapsack

Batching Problems with Constraints

There is an increasing demand for a phenomenon that can manifest benefits gained from grouping similar jobs together and then scheduling these groups efficiently. Batching is the decision of whether or not to put the jobs into same group based on certain criteria. Batching plays a major role in job scheduling in Information Technology, traffic controlling systems, and goods-flow management. A list batching problem refers to batching a list of jobs in the same order or priority as given in the problem. In this thesis we consider a one-machine list batching problem under weighted average completion. Given sequence of jobs are scheduled on single machine into distinct batches. Constraint is to batch these jobs into a fixed but arbitrary number ‘k’ of batches. Each batch can have any number of jobs (within the given list) grouped without changing the order of jobs. We call it a k-Batch problem. This is offline form of the batching problems, and is solved by reducing to a shortest path problem. We give an improved and faster version of the algorithm to solve k-Batch problem in O(n2) time

Approximation for Batching via Priorities

We consider here the one-machine serial batching problem under weighted average completion. This problem is known to be $cal Ncal P$-hard and no good approximation algorithms are known. Batching has wide application in manufacturing, decision management, and scheduling in information technology. We give an approximation algorithm with approximation ratio of $2$; the algorithm is a priority algorithm, which batches jobs in decreasing order of priority. We also give a lower bound of $frac{2 +sqrt{6}}{4} approx 1.1124$ on the approximation ratio of any priority algorithm and conjecture that there is a priority algorithm which matches this bound. Adaptive algorithm experiments are used to support the conjecture. An easier problem is the list version of the problem where the order of the jobs is given. We give a new linear time algorithm for the list batching problem

Optimal competitiveness for the Rectilinear Steiner Arborescence problem

We present optimal online algorithms for two related known problems involving Steiner Arborescence, improving both the lower and the upper bounds. One of them is the well studied continuous problem of the {\em Rectilinear Steiner Arborescence} ($RSA$). We improve the lower bound and the upper bound on the competitive ratio for $RSA$ from $O(\log N)$ and $\Omega(\sqrt{\log N})$ to $\Theta(\frac{\log N}{\log \log N})$, where $N$ is the number of Steiner points. This separates the competitive ratios of $RSA$ and the Symetric-$RSA$, two problems for which the bounds of Berman and Coulston is STOC 1997 were identical. The second problem is one of the Multimedia Content Distribution problems presented by Papadimitriou et al. in several papers and Charikar et al. SODA 1998. It can be viewed as the discrete counterparts (or a network counterpart) of $RSA$. For this second problem we present tight bounds also in terms of the network size, in addition to presenting tight bounds in terms of the number of Steiner points (the latter are similar to those we derived for $RSA$)

The Monge array--an abstraction and its applications

Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1991.Includes bibliographical references (p. 211-219).by James KIimbrough Park.Ph.D

The Knuth-Yao quadrangle-inequality speedup is a consequence of total-monotonicity

There exist several general techniques in the literature for speeding up naive implementations of dynamic programming. Two of the best known are the Knuth-Yao quadrangle inequality speedup and the SMAWK algorithm for finding the row-minima of totally monotone matrices. Although both of these techniques use a quadrangle inequality and seem similar they are actually quite different and have been used differently in the literature. In this paper we show that the Knuth-Yao technique is actually a direct consequence of total monotonicity. As well as providing new derivations of the Knuth-Yao result, this also permits showing how to solve the Knuth-Yao problem directly using the SMAWK algorithm. Another consequence of this approach is a method for solving online versions of problems with the Knuth-Yao property. The online algorithms given here are asymptotically as fast as the best previously known static ones. For example the Knuth-Yao technique speeds up the standard dynamic program for finding the optimal binary search tree of n elements from ⊖(n 3) down to O(n 2), and the results in this paper allow construction of an optimal binary search tree in an online fashion (adding a node to the left or right of the current nodes at each step) in O(n) time per step. We conclude by discussing how the general technique described here is also applicable to later extensions of the Knuth-Yao result, such as those devel oped by Borchers and Gupta

The Knuth-Yao Quadrangle-Inequality Speedup is a Consequence of Total-Monotonicity ∗

There exist several general techniques in the literature for speeding up naive implementations of dynamic programming. Two of the best known are the Knuth-Yao quadrangle inequality speedup and the SMAWK algorithm for finding the row-minima of totally monotone matrices. Although both of these techniques use a quadrangle inequality and seem similar they are actually quite different and have been used differently in the literature. In this paper we show that the Knuth-Yao technique is actually a direct consequence of total monotonicity. As well as providing new derivations of the Knuth-Yao result, this also permits to solve the Knuth-Yao problem directly using the SMAWK algorithm. Another consequence of this approach is a method for solving online versions of problems with the Knuth-Yao property. The online algorithms given here are asymptotically as fast as the best previously known static ones. For example, the Knuth-Yao technique speeds up the standard dynamic program for finding the optimal binary search tree of n elements from Θ(n 3) down to O(n 2), and the results in this paper allow construction of an optimal binary search tree in an online fashion (adding a node to the left or the right of the current nodes at each step) in O(n) time per step