Approximation Algorithms for Replenishment Problems with Fixed Turnover Times

We introduce and study a class of optimization problems we coin replenishment problems with fixed turnover times: a very natural model that has received little attention in the literature. Nodes with capacity for storing a certain commodity are located at various places; at each node the commodity depletes within a certain time, the turnover time, which is constant but can vary between locations. Nodes should never run empty, and to prevent this we may schedule nodes for replenishment every day. The natural feature that makes this problem interesting is that we may schedule a replenishment (well) before a node becomes empty, but then the next replenishment will be due earlier also. This added workload needs to be balanced against the cost of routing vehicles to do the replenishments. In this paper, we focus on the aspect of minimizing routing costs. However, the framework of recurring tasks, in which the next job of a task must be done within a fixed amount of time after the previous one is much more general and gives an adequate model for many practical situations. Note that our problem has an infinite time horizon. However, it can be fully characterized by a compact input, containing only the location of each store and a turnover time. This makes determining its computational complexity highly challenging and indeed it remains essentially unresolved. We study the problem for two objectives: min-avg minimizes the average tour length and min-max minimizes the maximum tour length over all days. For min-max we derive a logarithmic factor approximation for the problem on general metrics and a 6-approximation for the problem on trees, for which we have a proof of NP-hardness. For min-avg we present a logarithmic approximation on general metrics, 2-approximation for trees, and a pseudopolynomial time algorithm for the line. Many intriguing problems remain open.


Introduction
Imagine the following particular inventory-routing problem.A set of automatic vendor machines are spread over a country or a city.They have a certain turnover time: the number of days in which a full machine will be sold out.Replenishment is done by vehicles.Let us assume that turnover times are machine dependent but not time dependent, and that it is highly undesirable to have an empty machine.However, the holding costs of the machine are negligible, so that we will always fill the machine to capacity.There is nothing against replenishing a machine before it has become empty, but then the next replenishment will due earlier as well.That is, the deadline of the next replenishment is always within the turnover time after the last replenishment.Equivalently, in any consecutive number of days equal to the turnover time, at least one replenishment has to take place.Replenishing a machine earlier to combine it with the replenishment of another machine that is due earlier may lead to cost savings.The feature that makes this problem so special w.r.t.existing literature, is that it can be compactly modeled by only specifying for every machine its location and the turnover time.The feature is very natural but has hardly been studied in the existing literature.There are intriguing basic open complexity questions, and some highly non-trivial results.
The motivation for studying this problem comes linea recta from a business project for the replenishment of ATMs in the Netherlands, in which some of the co-authors are involved.The replenishment of the ATMs of all the large banks in the Netherlands has been outsourced to a single company: Geld Service Nederland.Of course the real-life ATM replenishment problem is not as stylized as described above; the turnover time is not strictly the same over time but subject to variability, there are restrictions on the routes for the vehicles, etc.But the feature that is least understood in the ATM-problem is exactly the problem of how to deal with the trade-off between replenishing an ATM earlier than its due date leading to a higher frequency of replenishments and the savings on vehicle routing costs.
Formally, an instance of the problem that we study in this paper, which we baptize the replenishment problem with fixed turnover times (rftt), consists of a pair (G, τ ), where G = (V ∪ {s}, E, c) is a weighted graph with a designated depot vertex s and weights on the edges c : E → R + , and turnover times τ ∈ N |V | , indicating that v j ∈ V should be visited at least once in every interval of τ j days.
A solution consists, for each day k, of a tour T k in G starting in and returning to the depot s and visiting a subset of the vertices J k ⊆ V .It is feasible if v j ∈ t+τj k=t+1 J k , ∀t and ∀v j ∈ V .We will focus on solutions that repeat themselves after a finite amount of time, that is, in which (T k , ..., T k+ ) = (T k+ +1 , ..., T k+2 ) for some , and all k.Since all turnover times are finite, this is no real restriction.
We consider two versions of rftt.In the first version, called min-avg, the goal is to find a feasible solution that minimizes the average tour length.In the min-max problem, we want to find a feasible solution that minimizes the maximum tour length over all days.
We emphasize that the particular feature of this model, that jobs or visits to clients recur and need to be done within each job-specific consecutive time interval occurs naturally in many problem settings.It allows any job of a recurring task to be done before its deadline, but then the next job of the task comes earlier and hence its deadline.This is a feature that, despite its natural applicability, has hardly been studied in the literature from a theoretical point of view.
Related work.As mentioned before, our problem can be seen as a special case of the Inventory Routing Problem (IRP) [8].Here, clients (vertices) have their own storage with a certain capacity and for each day a demand is specified.The clients pay holding cost over their inventory.However, omitting inventory cost, we can interpret our problem as such an inventory routing problem in which the demand at any given location is the same every day, leading to a very small input description of our problem consisting only of a location and a turnover time (storage capacity divided by daily demand), which makes it incomparable to the inventory routing problem from a complexity point of view.Indeed it is unclear if the decision version of our problem is in NP or in co-NP.
Another closely related problem is the Periodic Latency Problem [9], which features the recurring visits requirement of rftt.We are given recurrence length q i for each client i and travel distances between clients.Client i is considered served if it is visited every q i time units.The server does not return to the depot at the end of each time unit (e.g.day), but keeps moving continuously between clients at uniform speed.Another difference between Periodic Latency Problem and rftt is the objective function.Coene et.al. [9] study two versions of the problem: one that maximizes the number of served clients by one server, and one that minimizes the number of servers needed to serve all clients.They resolve the complexity of these problems on lines, circles, stars, trees, and general metrics.
A problem that does share the compact input size and is in fact a very special case of our problem is known under the guise of Pinwheel Scheduling.It has been introduced to model the scheduling of a ground station to receive information from a set of satellites without data loss.In terms of our problem no more than one vertex can be replenished per day and all distances to the depot are the same; the interesting question here is if there exists a feasible schedule for replenishing the vertices.Formally, a set of jobs {1, ..., n} with periods p 1 , ..., p n is given, and the question is whether there exists a schedule σ : N → {1, .., n} such that j ∈ t+pj k=t+1 σ k , ∀t ≥ 0 and ∀j.Pinwheel Scheduling was introduced by Holte et al. [18], who showed that it is contained in PSPACE.The problem is in NP if the schedule σ is restricted to one in which for each job the time between two consecutive executions remains constant throughout the schedule.In particular this holds for instances with density ρ = j 1/p j = 1 [18].They also observed that the problem is easily solvable when ρ ≤ 1 and the periods are harmonic, i.e. p i is a divisor of p j or vice versa for all i and j.As a corollary, every instance with ρ ≤ 1 2 is feasible.Chan and Chin [7] improved the latter result by giving an algorithm that produces a feasible schedule for Pinwheel Scheduling whenever ρ ≤ 2 3 .In [6], they improved this factor to 7  10 .Later, Fishburn and Lagarias [14] showed that every instance with ρ ≤ 3 4 has a feasible schedule.All these papers work towards the conjecture that there is a feasible schedule if ρ ≤ 5  6 .That this bound is tight can be seen by the instance with p 1 = 2, p 2 = 3 and p 3 = M , with M large.This instance cannot be scheduled, but has a density of 5  6 + 1 M .The complexity of Pinwheel Scheduling has been open since it was introduced.It was only recently shown by Jacobs and Longo [19] that there is no pseudopolynomial time algorithm solving the problem unless SAT has an exact algorithm running in expected time n O(log n log log n) , implying for example that the randomized exponential time hypothesis fails to hold [5,10].Since the latter is unlikely, one could conclude that Pinwheel Scheduling is not solvable in pseudopolynomial time.It remains open whether the problem is PSPACEcomplete.
Similar to Pinwheel Scheduling, the k-server Periodic Maintenance Problem [21,2,11] has n jobs, each with a specified periodicity and a processing time.Each server may serve at most one job per time unit.However, job i is required to be served exactly every m i days apart rather than within every m i days.The case k = 1, c j = 1 for all j is analogous to Pinwheel Scheduling, except for the exact periodicity constraint.For any k ≥ 1, Mok et.al. [21] have shown it is NP-complete in the strong sense.For the special case when m i are multiples of each other or when there are at most 2 different periodicities, they have shown it is in P. It was shown that even in the case of a single server and c j = 1 for all j the problem remains coNP-hard [3].
d Other related problems with a compact input representation include realtime scheduling of sporadic tasks [1,4], where we are given a set of recurrent tasks.On a single machine, EDF (Earliest Deadline First) is optimal.However, we remark that the complexity of deciding whether a given set of tasks is feasible has been open for a long time and only recently proved showing that it is coNP-hard to decide whether a task system is feasible on a single processor even if the utilization is bounded [12].
Another related problem is the Bamboo Garden Trimming Problem introduced by Gasieniec et.al. [17].There are n bamboos, each having a given growth rate, which may be viewed as inducing a periodicity.On each day, a robot may trim at most one bamboo back to height 0. The goal is to minimize the maximum height of the bamboos.Gasieniec et.al. provide a 4-approximation for the general case and a 2-approximation for balanced growth rates.This paper.We investigate the computational complexity of both the min-max and the min-avg version of rftt.Mostly we will relate their complexity to the complexity of Pinwheel Scheduling.Some interesting inapproximability results follow from this relation.After that, we will start with some special cases.In Section 3, we give our most remarkable result, a constant factor approximation for min-max on a tree, next to a less remarkable constant approximation for the min-avg version on the tree.In the same section, we show for min-avg that the problem can be solved to optimality in pseudopolynomial time on line metrics.Finally, in Section 4, we present logarithmic factor approximations for both problem versions on general metrics.
In this section, we investigate the computational complexity for both objectives.Since our problem requires finding a shortest tour visiting some subset of vertices for every day, it is at least as hard as the Traveling Salesman Problem (tsp).However it is also interesting to note that the problems are at least as hard as Pinwheel Scheduling as well.For the min-max objective there is a direct reduction showing that a factor 2 approximation is at least as hard as Pinwheel Scheduling: construct an unweighted star with the depot at the center and each leaf corresponding to a job in the pinwheel instance.This instance has value 2 only if there exists a pinwheel schedule and at least 4 otherwise.
For the min-avg rftt the reduction is a bit more involved, and given in the appendix.
Theorem 1.On series-parallel graphs, min-avg rftt is at least as hard as Pinwheel scheduling.
We note that this hardness result is incomparable to the tsp reduction.Pinwheel is neither known to be NP-hard nor in NP, although it is conjectured to be PSPACE-complete.
Lastly, as Theorem 2 shows, the min-max rftt remains hard even on star graphs (where TSP is trivial).A reduction can be found in the appendix.
Theorem 2. min-max rftt is NP-hard on star graphs.

Approximation on trees
In this section we give a 2-approximation for min-avg and a 6-approximation for min-max on trees.
We start out with a simplifying result, which will also be of use in the next sections.The proof of Lemma 1, which is not hard to derive, can be found in the appendix.
Lemma 1.Given an instance (G, τ ) of rftt, let τ be found by rounding every turnover time in τ down to a power of 2. Then OP T (G, τ ) ≤ 2OP T (G, τ ) for both min-avg and min-max objectives.
In the remainder we assume w.l.o.g. that G is rooted at s and that turnover times are increasing on any path from the depot to a leaf node in G. Furthermore, for an edge e in E we define D(e) to be the set of vertices that are a descendant of e.We also need the following definition.
Definition 1 (tt-weight of an edge).For any edge in G we define: We call this quantity the tt-weight (turnover time-weight) of e.
This definition allows us to express the lowerbound in Lemma 2.
Lemma 2 (tt-weighted tree).For an instance (G, τ ) of the rftt on trees it holds that the average tour length is at least: .
Proof.This follows immediately from the fact that 2 q(e) lower bounds the number of times edge e must be traversed on average in any feasible solution.
Since the maximum tour length is at least the average tour length, Lemma 2 also provides a lower bound for the min-max objective.
An approximation for min-avg rftt is thus found by rounding all turnover times to powers of 2 and then visit each client j on every day that is a multiple of τ j .Since in that case the lower bound of Lemma 2 is exactly attained on the rounded instance, Lemma 1 implies the following theorem.
Theorem 3.There is a 2-approximation for min-avg rftt on trees.

MIN-MAX
We will now show that we can achieve a 6-approximation for min-max rftt on trees by providing a 3-approximation algorithm if all turnover times are powers of 2 and then applying Lemma 1.
The main idea is to take a TSP-tour and recursively split it to obtain a schedule for the clients with increasing turnover times.During the splitting process, we assign each client j on that tour to a congruence classes āτj = {k ∈ N|k ≡ a (mod τ j )} for some a ≤ τ j , to indicate we want to visit j on each day in āτj .Similarly, we distribute all edges e to a congruence class āq(e) .We do this ensuring that on any given day, we can create a tour through all clients associated with that day, using the edges associated with that day plus a small set of extra edges.
Let us define some further notation.For a given congruence class ām ⊆ N, we denote g(ā m ) ⊆ V the set of vertices and f (ā m ) ⊆ E the set of edges assigned to that class.Note that ām and (a + m) m define the same congruence class, so f (ā m ) = f ((a + m) m ).Then, for any k ∈ N we have that J k , the set of clients we need to visit on day k, is The assignment of vertices and edges to classes is guided by the recursive splitting of a TSP-tour in G.The full procedure for constructing f (•) and g(•) is shown in Algorithm 1.The algorithm is initially called with d, a TSP-tour visiting all vertices in G, and a = m = 1 and will determine the set of vertices to be visited on every day (i.e., those congruent to ā1 ).Then the first (second) recursive call determines the sets of vertices with turnover time 2 that will be visited on odd Algorithm 1 Algorithm for recursively constructing f (•) and g(•) function RecurseTreeSchedule(d, a, m) Require: d, a connected sequence of edges in G, powers of 2 turnover times τ ; a, m, (even) days.Analougously, RecurseTreeSchedule(d 1 , a, m) will return the set of vertices with turnover time m to be visited on days in the congruence class ām and the two recursive calls will return the set of vertices with turnover time 2m that are visited on days a, a + 2m, a + 4m, . . .and a + m, a + 3m, a + 5m, . .., respectively.
In the remainder we assume that any call to f (•) and g(•) returns the empty set for any argument that is not explicitly handled in Algorithm 1.Note that we use the notation V (A) to denote the vertices incident to edges in A ⊆ E. Lemma 3.After Algorithm 1 terminates, each vertex j appears in some set g(ā τj ) for some a.
Therefore no vertex is skipped in the construction of g(•).
In order to find a tour on day k through the vertices in J k we use edges in h=1,2,...,m f (ā h ); as we already observed this set of edges does not necessarily connect vertices in g(ā m ) to the depot.The next lemma shows that a tree that connects all vertices in g(ā m ) to the root can be found by considering ∪ h=1,2,...,m f (ā h ) and adding a shortest path from some vertex in g(ā m ) to the depot.
Lemma 4. Let a, m be such that f (ā m ) is nonempty.Let P be the set of edges on the shortest path connecting some arbitrary edge in f (ā m ) to the root of G. Then the following edge set forms a connected component: Proof.To prove our first claim, we first show that for k ≤ m, f (ā k ) either induces at most one connected component, or each component it induces is incident to a component induced by h=1,2,..,k/2 f (ā h ).Then, we will show that if f (ā k ) induces at most one connected component, it is incident to P ∪ ( h=1,2,..,k/2 f (ā h )).
Suppose f (ā k ) does not induce at most one component.Note that f (ā k ) is the subset of edges in some connected edge sequence d through G that have tt-weight k.But by the way tt-weight is defined and the fact that G is a tree, a simple path connecting disjoint edges with tt-weight k, can only consist of edges with tt-weight at most k.So every two components in f (ā k ) are connected through a path of edges with tt-weight of at most k.Moreover since the sequence d used to construct f (ā k ) is a subset of the sequence used to construct f (ā k/2 ), by induction these connecting paths must be contained in h=1,2,...,k/2 f (ā h ), as required.
Next we show that for any k ≤ m such that f Let d be the sequence that was used to construct f (ā k ).Since d contains all edges in f (ā m ) and P contains at least one such edge, there exists a minimal path Q that contains some edge e in f (ā k ) such that Q is connected to P .Moreover since Q is minimal and P contains the root, e must be the edge furthest away from the root on Q.This implies that all edges on Q have tt-weight k or less.Now suppose that Q contains edges with tt-weight strictly less than k.Then those edges are necessarily in h=1,...,k/2 f (ā h ) and therefore The first claim of our lemma now follows by induction.
is either empty or is connected to P or to h=1,2,...,k/2 f (ā h ), and the result follows.
To prove our second claim, suppose that for some k and j ∈ g(ā k ) it holds that no edge incident to j, is in h=1,2,...,k f (ā h ).We will show that that j appears on P , from which our claim immediately follows.
Let d be the sequence used to construct g(ā k ).The edge e incident to j that is closest to the root, satisfies q(e) ≤ k.So, it cannot be in d otherwise it would be contained in h=1,2,...,k f (ā h ).But this implies that e cuts off every edge in d from the root, and therefore e appears on P , as claimed, concluding the proof.
The next lemma allows us to bound the cost of edges included in f (ā h ).Proof.The proof is by induction on m.Since we initially call the algorithm with d a TSP-tour in G, which visits each edge twice, it clearly holds for m = 1.Now for m > 1, suppose it holds for all smaller m.Without loss of generality, suppose we have a call to the function with input d 1 , a, m, such that d, a, m/2 are the input parameters for its parent in the call stack.For the first equality, we split the second sum into an h = m/2 part and an h = 1, . . ., m/4 part.In the first inequality we used the way d 1 and d 2 are determined in Algorithm 1, in the second inequality we used that f (ā m ) ⊆ d and in the last inequality we used the inductive hypothesis, concluding the proof.
We are now ready for the main theorem.
Theorem 4.There is a 6-approximation for min-max rftt on trees.
Proof.We first round all turnover times down to powers of 2, which loses a factor of 2 in the optimal solution.We then use Algorithm 1 to construct f (•) and g(•) thus determining the set of vertices J k to be visited on day k.By Lemma 3 this defines a feasible schedule.
If we then take T ( kτmax ) as in Lemma 4, we get a tree that spans J k .Moreover the weight of T ( kτmax ) is at most 3  2 OP T : the contribution of P is at most 1 2 OP T , since we need to reach any client at least on some day (and drive back), while the contribution of h=1,..τmax f ( kh ) is at most L(G, τ ) ≤ OP T , which can be seen by applying Lemma 5 for m = 2τ max .Lastly, since we need a tour around T ( kτmax ), we lose another factor 2. This gives the approximation factor of 6.
It remains to show that Algorithm 1 runs in polynomial time, and that we can find a polynomial representation for the schedule.For the first claim, note that in each recursive call to the algorithm, the following equality holds |d 1 ∪ d 2 | = |d| − 1; hence the algorithm terminates after at most 2|E(G)| calls.
For the second claim, the crucial observation is that we only need to store the entries of g for a and m such that g(ā m ) is nonempty.Since at most one entry is defined in every call to the algorithm, and we can simply check if k ≡ a (mod m) for all stored entries, the claim, and the theorem, follow.

MIN-AVG on the line
As an even more special underlying metric, we might consider the min-avg problem on the line (on a path).For the min-max version this case is trivial, but for the min-avg version its complexity is unclear: we do not know whether it is in NP, although we expect it to be NP-hard.
On the positive side we can show that the problem is not strongly NP-hard.
Theorem 5. min-avg on the line can be solved in pseudopolynomial time.
The proof of Theorem 5 is deferred to the appendix, where we give a DP that finds an optimal schedule in polynomial time for any instance with polynomially bounded turnover times.

Approximation on general graphs
We will now present logarithmic approximations for both objectives.Note that an O(log τ max )-approximation is readily achieved; simply treat the sets of clients with equal turnover time as independent instances.For min-avg, the problem with equal turnover times is simply tsp, for the min-max we get a problem sometimes called the k-tsp, for which a 5 2 approximation is known [15].Since by rounding to powers of 2, we ensure there are O(log(τ max ) different turnover times, we get Theorem 6 (a formal proof can be found in the appendix).Theorem 6. min-max and min-avg rftt have an O(log τ max )-approximation.
In the case of min-max it is relatively simple to adapt this idea for an O(log n)-approximation by appropriately reassigning clients to lower turnover times, as per Theorem 7.
Proof.We start by assuming that every turnover time is a power of 2. Next, we split up the instance into two new instances.To this end we first define a turnover time k to be saturated if |{j ∈ V |τ j = k}| ≥ k.In the first instance we retain the set of vertices V 1 with saturated turnover times, and in the second all vertices V 2 with unsaturated turnover times.Now if all turnover times are saturated, then τ max = O(n) and we can find a O(log n)-approximation using Theorem 6.So what remains is to find a O(log n)-approximation for the second instance.
Since no turnover time is saturated, it is easy to see that we can partition the vertices in V 2 into log n sets W 1 , W 2 , W 4 , . . ., W 2 log n , such that |W i | ≤ i, and such that τ j ≥ i for all j ∈ W i .For example we could first add all vertices j with τ j = i to W i for i ≤ log n , and then arbitrarily distribute vertices j with τ j > log n among the sets that have space.We now produce a schedule by visiting all clients in any set W k on different days.This is feasible and implies that at most log n clients are visited on a given day, which leads to O(log n)-approximation factor, as required.
The approach of Theorem 6 does not trivially extend to the min-avg case.However, we may combine our result on trees with the FRT tree embeddings [13], to get a randomized O(log n)-approximation.
A more direct, and deterministic O(log n)-approximation is possible as well.
In particular, we use the simple heuristic of visiting each client on every day that is a multiple of its turnover time, when turnover times are powers of 2. We call such a schedule a synchronized solution, and show that gives a logarithmic approximation.
The proof of this approximation factor, which is not trivial, works by show that a synchronized schedule is no more costly than a non-decreasing schedule, in which all tours are routed along a tree with turnover times non-decreasing from the root.We then show how to transform any schedule to a non-decreasing one, losing a logarithmic factor in the process.As a byproduct we show that the analysis is tight, an that a non-decreasing schedule must be Ω(log n) times more costly than OPT in the worst case.The proof of Theorem 8 can be found in the appendix.
It is an open question whether there exists a constant factor approximation algorithm for the general case.We observe that the approach of first finding a tree spanning all vertices and then using the algorithm of Section 3 is unsuccessful.In fact there exist instances of the problem on a graph G with n vertices, such that if we limit our attention to tours that for each day use only edges of a spanning tree of G then the obtained solution is Ω(log n) approximated.This implies that we need some new ideas, in order to improve the O(log n) approximation of the previous theorem.

Conclusion
In this paper, we considered replenishment problems with fixed turnover times, a natural inventory-routing problem that has not been studied before.We formally defined the rftt problem and considered the objectives min-avg and min-max.For the min-avg rftt, we showed that it is at least as hard as the intractable Pinwheel Scheduling Problem on series-parallel graphs and we gave a 2approximation for trees.For the min-max objective we showed NP-hardness on stars and gave a 6-approximation for tree metrics.We also presented a DP that solved the min-avg rftt in pseudopolynomial time on line graphs.Finally, we gave a O(log n)-approximation for the min-max objective on general metrics.
The results that we present should be considered as a first step in this area and many problems remain open.An intriguing open problem is the complexity of the of rftt on a tree.Namely, for min-avg variant we conjecture that the problem is hard, and we ask whether the simple 2-approximation we provide can be improved.For the min-max variant it is open whether the problem is APX-hard and whether we can improve the 6-approximation, Next to replenishing locations with routing aspects as we studied in this paper, scheduling problems modeling maintenance or security control of systems, form a class of problems to which this model naturally applies.It would be interesting to study such fixed turnover time problems in combination with scheduling.Would this combination allow for more definitive results?

A Proof of Theorem 1
Proof.Given an instance p 1 , ..., p n of Pinwheel Scheduling, create an instance (G, τ ) of min-avg rftt.We define and All edge weights are 1.See Figure 1 for an illustration.
We claim that the instance (G, τ ) has a solution of cost 6 if and only if p 1 , ..., p n is a feasible Pinwheel Scheduling instance.
For the 'if'-direction, suppose we have a feasible pinwheel schedule.Then we create a replenishment schedule as follows: we take the set of jobs visited on day k, J k = {v 1 j , w 1 , w, w 2 , v 2 j }, where job j is the job scheduled on day k in the pinwheel solution (when no job is visited, pick one arbitrarily).The pinwheel schedule then guarantees that the periods of jobs in V 1 ∪ V 2 are satisfied, while jobs w 1 , w, w 2 are visited every day, as required.Now since any tour (s, v 1 j , w 1 , w, w 2 , v 2 j , s) has length 6, we can do this within the claimed cost.
For the 'only if'-direction, note that any replenishment schedule must have cost 6 at least, since no tour that visits w 1 , w, w 2 costs less than that.Moreover, any tour visiting those three vertices that is not of the form (s, v 1 j , w 1 , w, w 2 , v 2 j , s), will cost strictly more than 6.It follows that if the cost of the replenishment schedule is 6, every tour visits at most one job from V 1 (and the same for V 2 ).Since τ v 1 j = p j for all j, this directly implies that the Pinwheel Scheduling instance is feasible.

B Proof of Theorem 2
In 3-Partition, we are given 3m integers a 1 , . . ., a 3m and an integer B = 1 The question is whether we can partition the integers into m sets of three integers that add up to B [16].
Proof.Given an instance of 3-Partition, create a weighted star graph G with the depot at the center and for every integer a i a leaf vertex attached with an edge of weight a i /2.Finally set the turnover time to m for every leaf.We will show that the rftt instance has value B if and only if we have a YES-instance for 3-Partition.
Given a valid partition of the integers, clearly one can assign every set of 3 integers a unique day in 1, . . ., m and visit the associated leaf on every multiple of that day for a valid rftt solution.That the opposite direction works as well hinges on the fact that B 4 < a i for all i, so we cannot visit more than 3 clients on one day.Since after m days all clients must have been visited due to the turnover times, it follows that the first m days of the schedule corresponds to a valid partition.

C Proof of Lemma 1
Proof.Let (G, τ ) denote the instance found from (G, τ ) by rounding every turnover time up to a power of 2. Since any schedule remains feasible if we round up the turnover times, we have that OP T (G, τ ) ≤ OP T (G, τ ) ≤ OP T (G, τ ).
Suppose we have an optimal solution for (G, τ ) in which Tk is scheduled on day k.We can construct a feasible schedule for (G, τ ) by scheduling the concatenation of T2k−1 and T2k on day k.The maximum tour length in this schedule is at most twice that of the optimal solution for (G, τ ) and every tour from the original schedule is visited exactly twice in the new schedule, so this yields a factor 2 increase in both the min-max and the min-avg objective.

D A dynamic program that proves Theorem 5
In this section we will show how to solve the min-avg problem on the line in pseudopolynomial time.Since we are minimizing the average, it is easy to see that we can reduce this problem to two times the min-avg problem on the half-line (a path with the depot in one of the leaves).On the half-line each vertex i has a distance d i ∈ N from the origin.Suppose vertices are numbered such that d 1 ≤ . . .≤ d n .We present a pseudopolynomial time dynamic programming agorithm for this problem, based on the following observations.First of all, we note that on any tour visiting vertex j automatically visits every vertex i < j.As in the tree case, we therefore assume that τ i ≤ τ j for i < j.Thus, after visiting j, all i ≤ j have a remaining turnover time of τ i .For the dynamic program to work, we guess L, the day on which vertex n is visited for the first time and try all guesses between 1 and τ n .
The dynamic program now works as follows.Suppose we are given the optimal solution for vertices 1, . . ., i − 1 when only considering the days 1, . . ., k.Now we want to include i in the optimal solution for the first k days.If k < min{τ i , L}, it is not necessary to visit i during the first k days, and hence it is optimal to take the optimal solution for the first i − 1 vertices and k days.Otherwise, we need to visit i on some day in {1, . . ., min{τ i , L}}.Before day , we only need to visit the vertices 1, . . ., i − 1.Thus, we take the optimal − 1 tours for visiting the first i − 1 vertices in the first − 1 days.After day , all vertices have the same remaining turnover time as they had at time zero.Hence, we can take the optimal tours for the first i vertices and k − days.
Let φ L (i, k) := the minimum cost of the first k tours visiting vertices 1, ..., i.We initialize φ L (0, k) = φ L (i, 0) = 0 and we use the recursion: The optimal solution is the schedule that corresponds to the value L ∈ {1, . . ., τ n } minimizing φ L (n, L)/L.Note that the algorithm runs in time O(nτ 3 n ), implying the following.Theorem 9. min-avg on the line can be solved in pseudopolynomial time.

E Proof of Theorem 6
Proof.By Lemma 1 we may assume every τ i is a power of 2 so that there are at most log τ max different turnover times.We simply treat the sets of vertices with the same turnover time as separate instances and concatenate the solutions.Our result then follows from the fact that for all these instances a constant factor approximation is available.In the case of the min-max objective we get the k-tsp problem, where k is equal to the turnover time of the vertices in the instance.In the case of min-avg, we need to minimize the sum over all k tours.But since all turnover times are equal there is no advantage to visiting vertices on different days, hence we recover a simple tsp problem.

F Proof of Theorem 8 and tightness of analysis
This section provides two proofs of Theorem 8, which shows that we can get a O(log n)-approximation for the min-avg objective as well.The first proof is a direct application of metric tree embeddings.
Proof (Proof of Theorem 8).We will apply the FRT tree embedding [13] of the initial instance and then use the 2-approximation for tree metrics to obtain the final solution.Given the instance (G, τ ), let T be a random tree produced by the tree metric approximation with O(log n) distortion.Then Let S be the solution produced by the 2-approximation for min-avg rftt on the tree metric T .Then ] by linearity of expectation on the sum over the edges.
The second proof arises from a more natural algorithm given by a simple greedy strategy.We round all periods to powers of 2 and delay visiting any client for as long as possible.Next, for every day we use any constant factor approximation for TSP to calculate a tour on the clients whose visit can no longer be delayed.We call this a synchronized solution.It takes some work to show this does indeed provide a logarithmic approximation though.We do this by showing that any synchronized solution is no more costly than a non-decreasing solution, in which every tour is based on a tree that has the clients ordered by ascending turnover times from root to leaves.We then show that such a non-decreasing solution costs at most O(log n) times the optimal solution , and provide an example showing this analysis is tight.Moreover, we show that the optimal non-decreasing solution is at most twice as costly as the optimal synchronized solution.This implies that that any sub-logarithmic approximation algorithm must avoid finding such solutions.
As always we will assume that turnover times are rounded to powers of 2. Let us define a synchronized solution, as one where a client with turnover time 2 i is visited on each day that is a multiple of 2 i , for all i.We define a non-decreasing tree as a tree on the depot and subset of clients, such that the turnover times on every path from the depot to the leafs are non-decreasing.A non-decreasing solution is a solution in which for each day the tour is given by visiting the clients of a non-decreasing tree in depth first order.
The following two lemmas show that optimal synchronized and non-decreasing solutions differ in cost by at most a constant factor.Lemma 6.The optimal synchronized solution costs at most two times the optimal non-decreasing solution.
Proof.Suppose we have a non-decreasing solution.Let T i be the non-decreasing tree associated with day i, for i ∈ N. We will show that we can find a set of trees T i for i ∈ N that cost at most as much as T i on average, and such that any client v appears in tree T i if i is a multiple of τ v .A synchronized solution can then be found by taking the tour on day i to be a tour depth first search in T i , losing a factor 2.
Iteratively, from j = 0, . . ., log τ max , we build the new trees.In iteration j and for all i, select all unmarked edges in T i that are used on a path from the depot to a client v with τ v = 2 j , and mark them.Then insert these edges in the tree T k for the earliest following day k that is a multiple of 2 j , so k = i 2 j 2 j .We now show by induction that after iteration j, for each day k that is a multiple of 2 j , T k is a tree connecting the depot to all clients v with turnover time 2 j .The base case j = 0 follows from the fact that the trees T i are non-decreasing and must contain every client with turnover time 1.For higher j, it is easy to see that T k must contain a path from v to w for all clients v with τ v = 2 j and some w with τ w < 2 j .But T k already contains w by our inductive hypothesis and the result follows.
We remark that we have corresponding converse result, as per Lemma 7.
Lemma 7. The optimal non-decreasing solutions costs at most two times the optimal synchronized solution.
Proof.We may assume that any synchronized solution uses at most log(τ max ) + 1 distinct tours, lets label them T 0 , . . ., T log(τmax) , where T j visits all clients with turnover time at most 2 j .Furthermore define ∆ 0 = c(T 0 ) and ∆ j = c(T j ) − c(T j−1 ), for j = 1, . . ., log(τ max ).Then it holds that the cost of the synchronized solution is Now note that we can create a non-decreasing tree for any day with 2 j as its largest power of 2 factor from the synchronized solution, by taking the union of T 0 , . . ., T j where we shortcut every client v with τ v < 2 j in tour T j .But the cost of such a solution is Our main result follows from showing that we can always find a non-decreasing solution of cost O(log n) times OP T .We use the following tree pairing Lemma by Klein and Ravi [20].Lemma 8. Given any tree T and an even subset S of its vertices, there is a pairing of vertices covering S such that the tree-path induced by the pairs are edge-disjoint.
Using the tree pairing Lemma 8, we will construct non-decreasing trees to approximate arbitrary trees.First we define the notations needed for the algorithm.
A non-decreasing arc a({u, v}) of {u, v} is the arc between u and v that points from the client with lower turnover time to the one with higher turnover time (ties are broken arbitrarily).The client with the lower (higher) turnover time is denoted by L({u, v}) (H({u, v})).We denote by U the unpaired clients and A the arcs of the non-decreasing tree being constructed, and require that all arcs must eventually point away from the depot.Lemma 9. Given an arbitrary tree T of cost c(T ), there is a non-decreasing tree of cost at most log n c(T ).
Algorithm 2 Algorithm to create non-decreasing tree from arbitrary tree 1: Initialize U ← V and A ← ∅. 2: while |U | > 0 do: 3: Find an edge-disjoint pairing P of a largest even subset of U .4: for {u, v} ∈ P do: 5: A ← A ∪ a({u, v}).

7:
end for 8: end while Proof.Let T be a tree.We will construct a non-decreasing tree T by iteratively pairing off the vertices and directing each pair in a non-decreasing manner.
In the algorithm, we apply the pairing procedure log n times to get a nondecreasing tree of the desired cost.In each round, we pair a largest subset of V such that the pairs induce edge disjoint paths in T .Then we direct each pair {u, v} in ascending order of turnover times and delete the client with higher turnover time from consideration.These arcs are added to the arc set of T .We can think of each pair as a connected component represented by the client with the smallest turnover time.In the end, T is finalized when no unpaired vertices remain.Note that picking the vertex of minimum turnover time as the representative per connected component ensures that the final tree is indeed directed away from the depot.
In each round, we used each edge of T at most once since all pair-induced paths were edge-disjoint.Let κ(t) be the number of vertices at the beginning of round t.Since each round paired off either all vertices or all but one vertex, we have κ(t) = κ(t − 1)/2 .So the total number of rounds is log n .Hence c(T ) ≤ log n c(T ).
Proof (Proof of Theorem 8).Given an optimal solution, let T i be the minimum Steiner tree on the set of clients visited on day i, which costs no more than the tour of that day.Using Lemma 9 we can find non-decreasing trees T i of cost at most O(log n)c(T i ).Turning the trees into tours loses only a constant factor, which gives us a non-decreasing solution of cost O(log n) times OP T .By Lemma 6 we may then turn this solution into a synchronized one as required, concluding the proof.
The bound in the proof of Theorem 8 is tight; as there exists a class of instances where requiring a solution to be non-decreasing introduces a logarithmic optimality gap.Together with Lemma 7, this implies that our algorithm does no better than O(log n) as well.
Proposition 1.There exists a class of instances in which there is a logarithmic optimality gap between the optimal and the optimal non-decreasing solution.
To show that the bound in the proof of Theorem 8 is tight, we first show that Lemma 9 is tight.Consider the following sequence of sequences (a 0 , a 1 , . ..) were a 0 = (1) and a i+1 is generated by alternatingly taking an element from a i and then from the sequence b i = (2 i + 1, 2 i + 2, . . ., 2 i+1 ).For example: a 0 = 1 a 1 = 1, 2 a 2 = 1, 3, 2, 4 a 3 = 1, 5, 3, 6, 2, 7, 4, 8 -• • • Then define the (unweighted) graph G i as the path graph with 2 i vertices, where the jth vertex has turnover time 2 a i j −1 .See Figure 2 for an example.The minimum spanning tree in G i costs 2 i − 1.It is easy to check that the decreasing spanning tree produced by Algorithm 2 costs i2 i−1 .Moreover, since the solution produced attaches every vertex to a nearest vertex with lower turnover time, it must be optimal.
To show tightness of our main theorem, we will define another class of graphs H i for i ≥ 1 that are constructed from {G i }.The idea is to make τ j copies of each terminal j, and then connect them in a regular way, for example like in Figure 3. Formally H i is constructed as follows.For simplicity of description, we assume that G i is planarly embedded from left to right, and we that we keep a planar embedding of H i during construction.
We first copy node 1 to H i .Now we work from left to right, starting from the second node.When we are at node j, we put τ j copies of j vertically above each other and to the right of the copies of j − 1 in H i .Then we connect them to the copies of j − 1 in H i such that the graph remains planar and all copies of j − 1 have the same degree, and all copies of j have the same degree.This can be done in only one way.Furthermore we identify vertex 1 with the depot.Proposition 2. The instance induced by H i has a logarithmic optimality gap between the optimal and the optimal non-decreasing solution.
Proof.There exists an obvious solution that visits exactly one client of each turnover time per day, that costs 2(2 i − 1).Now suppose we impose non-decreasing constraints.In this case we need to use (on average) at least one edge pointing from a client with a lower turnover time to one with a higher turnover time per day.But from our reasoning on the decreasing minimum spanning tree in G i , we find that the cheapest set of edges that contains at least one edge pointing from a client with turnover time 2 i to one with lower turnover time for all i, costs at least i2 i−1 .Therefore the optimal solution under non-decreasing constraints is at least a logarithmic factor more expensive than the optimal solution.

Fig. 1 .
Fig. 1.Instance created in the proof of Theorem 1. s