Serving Requests with On-line Routing? - Semantic Scholar

Serving Requests with On-line Routing?

Giorgio Ausiello1, Esteban Feuerstein1 , Stefano Leonardi1, Leen Stougie2 and Maurizio Talamo1 1

Dipartimento di Informatica e Sistemistica, Universita di Roma \La Sapienza", via Salaria 113, 00198-Roma, Italia. e-mail: fausiello,esteban,leonardi,[email protected]. 2 Department of Operations Research, University of Amsterdam, Roetersstraat 11, 1018WB Amsterdam, The Netherlands. e-mail: [email protected].

Abstract. In this paper we consider the on-line version of the routing problem with release times. Formally, it consists in a metric space M with a distinguished point o (the origin), plus a sequence of triples < ti ; pi ; ri > where pi is a point of M , ri speci es the rst moment in which the request is ready to be served, and ti represents the moment in which the request is known. A server located at point o at time 0 that moves at constant unit speed must serve the sequence of requests trying to minimize the total time till all the requests are served. An on-line server follows a solution computed on the basis of the set of requests presented in the past; this solution may be updated each time some new piece of information is known. We show that no on-line algorithm, neither deterministic nor randomized, can achieve a competitive factor lower than 2. We give a 5/2-competitive exponential algorithm and a 3-competitive polynomial algorithm for the plane, and a 7=3-competitive algorithm for the line.

1 Introduction The problem of routing and scheduling a server in a network has a great quantity of applications from robotics to several transportation problems. The most general problem considers a server that must serve a set of requests in some prescribed locations of a metric space, minimizing some objective function, typically the total distance traveled or the completion time. Several versions of the problem have been studied, in which additional constraints are imposed and particular metric spaces are considered. For example in [11] each request can be served only after a certain release time. In that work it has been shown that if the metric space is a line the optimal solution may be found in quadratic time, while it was conjectured to be NP-hard for some other simple metric spaces. In [8] the metric space is restricted to be a tree and each ?

This work was partly supported by ESPRIT BRA Alcom II under contract No.7141, and by Italian Ministry of Scienti c Research Project 40% \Algoritmi, Modelli di Calcolo e Strutture Informative".

request has, besides a release time, an associated handling time that is the time needed to serve it. The problem is shown to be NP-hard in that context, and a 2-approximate solution is given. In general these problems are called routing and scheduling with time window constraints. Sometimes more than one server are considered, and other restrictions are given by imposing that requests must be served before a speci ed deadline (see for example [14, 15]). In general metric spaces all these problems are at least NP-complete, since they contain the Hamiltonian Path problem as a particular case. Other related works are [1, 4, 5, 6]. All the previously cited works consider o-line problems, in the sense that the entire input of the problem must be available before the server starts its work and hence, the solution (whether optimal or approximated) can be computed once and be accomplished by the server. In many applications the requests are not known in advance, but are presented in an on-line fashion possibly by independent sources. In this context it would be necessary to wait till the last request is presented to compute a solution; but this could not be feasible if we do not know which request is the last one. Besides, the time spent till the last request is presented could be used to do part of the work. The lack of knowledge about the future introduces an additional source of diculty that cannot be overcome even using a non-polynomial algorithm. This means that in many cases an optimal solution on any instance cannot be obtained also disregarding computational complexity. Examples of applications of this problem are given by a robot that must provide a service to a set of independent clients located in a metric space, a repairman with a cellular phone that must decide his route, and allocation of shared resources in a distributed network. To the best of our knowledge, there are not previous references concerned with the on-line version of the problem, even if it is very natural and realistic. In this paper we consider the on-line version of the routing problem with release times. Formally, it consists in a metric space M with a distinguished point o (the origin), plus a sequence of triples < ti; pi; ri > where pi is a point of M and ti and ri are real numbers, 0  ti  tj for every i < j . The ri are called the release times of the requests, and specify the rst moment in which the request is ready to be served, while ti represents the moment in which the request is known. The relation ti  ri holds for every i, with the meaning that requests may be presented at any moment not later than their release times. A server located at point o at time 0 that moves at constant unit speed must serve the sequence of requests trying to minimize the total time till all the requests are served. An on-line algorithm for this problem determines the behavior of the server in a certain moment t as a function of all requests < ti ; pi; ri > such that ti  t. The server follows a solution computed on the basis of the set of requests presented in the past; this solution may be updated each time some new piece of information (as for example a new request or simply the passing of time) is known. We suppose that there is no way of knowing if a certain request is the last one of the sequence.

One of the most widely studied on-line problems is the k-server problem ([10]) in which it must be decided which one of k servers moves to cover a request in a metric space, with the goal of minimizing the total distance traveled by the k servers. Our problem diers from the trivial 1-server problem because our task is to decide the order in which the requests are served, while in the 1-server problem the order must be precisely the order in which the requests are presented. Another related work ([9]) considers the problem of visiting the whole set of vertices of an unknown graph, when the set of edges leaving a node is revealed only once the node is visited. In our case, the metric space is completely known from the beginning, but what is revealed in an on-line way is the set of locations that must be visited. An on-line algorithm will in general produce a non optimal solution. The quality of a certain on-line strategy is measured by the worst-case ratio between the time needed by the on-line algorithm for a sequence of requests and the optimal time needed to serve it by an algorithm who knows the entire sequence in advance. In the case of on-line algorithms that approximation ratio is called the competitive ratio of the algorithm. Competitive analysis provides a more appropriate analysis tool for on-line algorithms than, for example, worst-case or average-case analysis. It has been introduced in [12], and has been widely used for analyzing the performance of on-line strategies for a great variety of on-line algorithms, ranging from scheduling to nancial decision taking, and for many data structure problems (among the wide literature on the subject, see for example [3, 10, 13]). As we do not know which request will be the last one, the simple idea of waiting till the last request is presented and then serving all the requests in an optimal way can not be applied. Had this been possible, we would have a 2-competitive algorithm, and we will see later that such a result is the best one can expect, even if we allow the strategies the capability of computing optimal hamiltonian paths. As a result of this fact, we will see that \good" strategies must start working even if the work done may happen to reveal as \wasted" in front of future requests. In this work we study the on-line routing and scheduling problem in the cases in which the metric space is the euclidean plane or the real line. We provide lower and upper bounds for the competitiveness of on-line algorithms. In particular we show that no on-line algorithm, neither deterministic nor randomized, can achieve a competitive factor lower than 2. We give a 5/2-competitive exponential algorithm and a 3-competitive polynomial algorithm for the plane, and a 7=3competitive algorithm for the line. The remainder of this paper is organized as follows: Section 2 is dedicated to the case in which the metric space is the euclidean space. In Section 3 we study the particular case of the real line, and we provide an algorithm achieving a competitiveness ratio nearer to the lower bound. Finally, Section 4 depicts conclusions and open problems.

2 The on-line routing problem in the plane As was stated above, we restrict our attention to the case in which the metric space is the euclidean plane. In this section we show a lower bound on the competitiveness of any on-line algorithm for this problem as well as some strategies with their respective competitive ratio. For simplicity of notation, we will say for a triple < t; p; r > that \a request in point p with release time r is presented at time t". When the release time is not mentioned, we mean that t = r. All the algorithms presented in this paper ignore every request with release time greater than the moment in which it is presented till its release time. Hence we can consider all requests as presented exactly at their release time. Given an on-line algorithm and a sequence of requests  we denote as T the time required by the algorithm to serve the sequence of requests. Conversely, t  denotes the optimal o-line time needed if the sequence is completely known before time 0. An algorithm is said to be c-competitive if for every sequence , T  ct  + d, where d is a constant that does not depend on . The subscript  will be omitted each time this does not cause confusion. As it is usually done in competitive analysis, we compare the behavior of an on-line algorithm with that of an adversary that starts at the same time as the on-line algorithm and who knows (in fact, who chooses) the sequence of requests and, hence, serves it optimally.

2.1 Lower bounds We show that no on-line algorithm can achieve a competitive ratio smaller than 2. With this aim, we provide a family of sequences of requests for which no algorithm can nish within less than twice the optimal o-line time. The lower bound we show is constructed on the real line. In fact, we use real numbers to denote the points p of the metric space and the initial position o is at point 0.

Theorem 2.1 No deterministic algorithm for the on-line routing problem in the plane can be c-competitive with c < 2. Proof. We consider a family of sequences de ned in the following way: Let t0 = 0

and ti = 3i?1; i = 1; 2; : : : Let n be the sequence consisting in making two requests in points ?ti ; ti at time ti , for i = 1; : : : ; n. Intuitively, each sequence n is obtained from n?1 by adding two new symmetric requests at a distance from the origin equal to the optimal time needed to serve n?1. Assume the position of the on-line server at each time tj with j  i is 0 and suppose the on-line server is at point p at time ti+1 = 3ti; without loss of generality we suppose p  0. It is easy to see that if p > 0 the server has not been to ?ti yet, while if p = 0 without loss of generality we assume that it has not been in ?ti since he could not have visited both the extremes. At time

ti+1, the adversary may be in point ti , having served all the requests, so, to be 2competitive, the on-line algorithm must nish serving all the requests before time 2ti+1 = 6ti . It is clear that at a certain moment the on-line server will have to move left towards ?ti . Hence, the adversary can continue moving rightward until the position of the on-line server is exactly the center of the interval de ned by ?ti and the adversary's position ti + x. If at that moment a request is presented in position ti + x, the total time required by the adversary will be exactly ti + x, while the on-line algorithm will have still to travel three halves of an interval of =2(2t +x)  2. Note that if length 2ti + x, the competitive ratio being (3t +x)+3 3t +x p = 0 then x = 0 and the ratio is exactly 2. i

i

i

Note that the lower bound tends asymptotically to 2 even if the time passed between 0 and the moment in which the rst request is presented is not charged to the on-line algorithm. Otherwise, the much simpler sequence that we use in the proof of the next theorem could be used also for deterministic algorithms, obtaining the same lower bound of 2. Next theorem refers to randomized algorithms for this problem. The competitive ratio of a randomized algorithm is de ned in terms of the expected value of the ratio T  =t (see [2]).

Theorem 2.2 No randomized algorithm for the on-line routing problem in the plane is c-competitive, with c < 2. Proof. Suppose there are no requests till time 1, then the expected position of

the server must be the origin, as if that is not the case and its expected position is point p 6= 0, then the adversary may make a request in point ?jpj=p (that is in -1 if p > 0 and 1 if p < 0). The cost for serving that sequence of requests is clearly 1 for the adversary, while the on-line algorithm will have an expected cost of 1 + jpj + 1 = 2 + p and hence the algorithm is not 2-competitive. But if at time 1 the expected position of the on-line algorithm is the origin, then the expected cost for the sequence in which a request is given in point 1 at time 1 will be greater or equal than 2, and hence, as the cost for the adversary is exactly 1, the algorithm is at most 2-competitive.

2.2 The greedy algorithm The greedy algorithm basically follows at every moment the shortest Hamiltonian path starting from the current position of the server and visiting all points where there are requests not yet served. A request such that its release time is greater than the moment in which it is presented is simply ignored by the algorithm till its release time. Hence, we may suppose that requests are presented exactly at their release times. The route is re-computed each time a new request arrives. Note that each computation of a Hamiltonian path may take exponential time. The greedy algorithm achieves a competitive ratio of 5=2, as we show in the following. Let S be the set of points where requests have been posed and not

yet served by the algorithm, let p be the current position of the algorithm. Let be the optimal path that visits S starting from p. Let T be the optimal path on the set S of requests presented until now, and C be the convex hull built on S and the starting point. Notice that T and T do not consider the release times of the requests. The greedy algorithm consists in following the path T that is recomputed every time a new request is presented. Notice that the current position of the greedy algorithm is always inside C , and the following property holds. T

Lemma 2.3 The distance from any point inside C to the nearest extreme of T is at most half of the length of T . p c’

c

q

a

b

Fig. 1. The convex hull and the optimal hamiltonian path of a set of points Proof. Let a and b be the extreme points of T , and c any point inside C . Consider

the perpendicular to the line containing segment ab that passes through c and let c0 be its intersection with C in the semi-plane containing c. Let p and q be the vertices of the edge of C containing c0, such that the path T passes through p before q going from a to b (see Figure 1). It is simple to see that: ac + cb  ac0 + c0 b  ap + pc0 + c0q + qb  ap + pq + qb  jT j Then the minimum among ac and cb is no more than the half of jT j.

Theorem 2.4 The greedy algorithm is 5/2-competitive. Proof. The length of T is no more that the time required to serve the remaining

requests in the order speci ed by jT j followed starting at its nearest extreme

towards the furthest. By Lemma 2.3 that amount of time is less than 3=2 times jT j. Given that each time a new request is presented the optimal time is greater or equal than the current time, we have that the total time needed by the greedy algorithm is at most 5=2 the time required by the optimal o-line strategy. The following example shows that the factor of 5/2 is asymptotically tight. Note that if all the requests fall in the real line, the greedy strategy translates in going always to the nearest extreme of the smallest interval containing the requests that have yet to be visited. We suppose that ties are broken in an arbitrary way. This is not a limitation because any choice can be forced by moving requests a negligible distance. The example is illustrated in gure 2. Consider a sequence starting at time 1 with two requests in -1 and 1, and suppose without loss of generality that the greedy algorithm goes towards 1. At time 3 it will be back in 0 and the adversary may put a request at point 1 again. Let t0 = 3; p0 = 1 and in general pi = ti ?2, and ti = 35 ti?1 ?2=3, for i = 1; 2; 3; : : : ; n. The sequence continues with a request in point pi at time ti . The adversary's cost for this sequence will be exactly tn , since it can start going to -1 and then going always to the right arriving at each point pi when the request is presented. As for the cost of the greedy algorithm, we will show that at time tn it is in the middle of the interval [?1; pn], and hence he must still travel 3/2 times the length of the interval, as it has not yet served the requests in the extremes. The total cost charged will then be equal to tn + 3=2(pn + 1) = tn + 3=2(tn ? 1), and hence the ratio between the costs of the greedy algorithm and that of the adversary's tends to 5=2 as n tends to in nity. Let's see that for every i, at time ti the position of the greedy algorithm is (ti ? 3)=2, that is, the center of the interval he still has to visit. This is obvious for i = 0. Assuming the thesis is true for i we will prove it for i + 1. At time ti it leaves (ti ? 3)=2 towards the right extreme, where it arrives at time ti + (ti ? 3)=2 + 1 = 23 ti ? 1=2. Then, it turns back towards -1, and at time ti+1 = 35 ti ? 2=3 will be at point ti ? 2 ? [( 35 ti ? 2=3) ? ( 23 ti ? 1=2)] = (ti+1 ? 3)=2, the center of the new interval. −1

0

p1=1

p2

p3

greedy server time

off−line server

Fig. 2. A worst-case sequence for the greedy algorithm

2.3 The behavior of polynomial algorithms If we restrict on-line algorithms to be polynomial, it is clear that the competitive ratio achievable is lower-bounded by the approximation ratio that may be obtained by the best approximate algorithm, as a particular instance could consist in a set of requests with their relative release times presented together at time 0. One known approximation algorithm for the Euclidean Traveling Salesman Problem (ETSP) is the 2-approximate MinimumSpanning Tree heuristic (for details refer to [7]). The MST heuristic constructs a 2-approximate tour by traversing all the edges of a minimum spanning tree over the set of cities. This heuristic also provides a 2-approximation to the Hamiltonian Path Problem, since the size of a minimum spanning tree is less than the total length of an optimal hamiltonian path. An algorithm that uses the MST heuristic can be described as follows: Each time a new request is presented, arrive to the destination point (if not already in a point). Then follow the 2-approximate path given by the minimum spanning tree of the requests that still have to be served.

Theorem 2.5 Algorithm MST is 3-competitive. denote the last visited point when a new set of requests B 0 are presented at a certain time t. Let B denote the set of requests that had to be served before the arrival of the new set of requests. Finally, let S be the set containing all requests presented, and T the minimum hamiltonian path over S starting from the origin. We rst note that 0  M ST (fag [ B [ B )  M ST (S [ fog)  t where M ST ( ) represents the total length of a minimum spanning tree over a set of points. At the time when the new set of requests is available the on-line server is on an edge leading from a to a point in B . By Lemma 2.6 this edge is always included in a 2-approximate tour on fag [ B [ B 0 . Hence, the remaining distance to be traveled by the on-line server is less than 2M ST (fag [ B [ B 0 ). Hence, the total cost of the on-line server will be less than t + 2M ST (S [ fog) that is less than 3 times the cost of the optimal o-line algorithm, since t  t .

Proof. Let

a

Lemma 2.6 For every pair of points a and b in a set S, there exists a 2approximate tour on S including the segment ab.

Proof. If the segment ab is part of the MST, then the thesis holds trivially. Otherwise, a legal 2-approximate tour starts in a and visits at each node rst the subtrees not containing the path leading to b till b is reached, then the subtrees rooted at b not yet visited, and nally the segment ab. We nish this section giving an example in the line that shows that the bound of 3 on the competitiveness of the MST heuristic is tight. At time 0 a request at point 1 arrives. At time  a request at point 0 arrives. The MST contains the

edge 01, and the on-line server is at point  and continues to follow the segment 01 until 1. At time 1 +  the on-line server is at position 1 ?  and a new request is given at point 1. Now the on-line goes towards 0 and afterwards it goes back to 1. The total time is 3, while the optimal solution takes 1 + . The example is illustrated in Figure 3. 0

1

greedy server off−line server

time

Fig.3. A worst-case sequence for the MST algorithm An important feature of algorithm MST is that it can be applied (obtaining the same competitive ratio) not only to the euclidean plane but to any metric space. It is interesting to note that the competitive factor of 3 obtained by this strategy is exactly the sum of the 2-factor of the approximation rate of the heuristic plus 1, the same that would be obtained following the approximate path after the last request is presented. As we said before, such a strategy can not be considered because no information about which is the last request is given to the on-line algorithms.

3 On-line routing on the line In this section we give an algorithm for the particular case in which the metric space is the real line that achieves a competitive factor of 7=3, and hence is better than any of the algorithms we proposed for the plane. We recall that the lower bound of 2 from the previous section was obtained in the line. As we did before, we will consider the origin o in point 0, and requests are speci ed by real numbers. Let I be the smallest interval containing the requests not yet served The algorithm, which we call SNB, for \Start near the beginning", consists in going always to the extreme of I that is nearer to the origin.

Theorem 3.1 Algorithm SNB is 7/3-competitive.

Proof. We analyze the situation at a generic time t in which a new request is presented. We consider only the case in which I includes the origin. The case in which I is either to the left or to the right of 0 is easier to consider. Without loss of generality we suppose that the leftmost extreme point is the one nearest to the origin. Then, our interval is I = [?x; X ] with x  X . Moreover, say ?Y 0 and X 0 the leftmost and the rightmost requests in the past, and f (t) the position of the on-line algorithm at time t. Clearly, at time t the following hold: t  t , x  Y 0 , X  X 0 and ?Y 0  f (t)  X 0 . We consider four cases depending on the position in the line of the on-line server: 1. ?Y 0  f (t)  ?x. The on-line server is to the left of ?x and will nish its work visiting once the interval that lies to its right. Since f (t)  ?Y 0 , the total time needed to the algorithm is T   t + Y 0 + X . To serve the whole set of requests it is at least necessary to travel from the leftmost to the rightmost request and hence t  Y 0 + X 0 . The ratio in this case is T  =t  (t + Y 0 + X )=t  1 + (Y 0 + X )=(Y 0 + X 0 )  2, since t  t and X  X 0. 2. ?x  f (t)  x. In the worst case the on-line server is in position x and it must visit before the leftmost extreme in position ?x. The time needed by SNB is T   t + 3x + X . The optimal time is at least t  2x + X 0 . From this and the fact that x  X  X 0 it follows that T  =t  (t +3x + X )=t  1 + (3x + X )=(2x + X 0 )  7=3. 3. x  f (t)  X . This case is a bit more dicult since we need some assumptions on the past behavior of the on-line server and of the optimal o-line solution. We consider two dierent cases: { The optimal strategy ends to the left of the origin. Then we have t  2X 0 + x. The on-line server must at most cover twice the interval if it is very close to the rightmost extreme X . Then it will nish by T   t +2x +2X time and the ratio is T  =t  1+(2x +2X )=(x +2X 0 )  7=3. { The optimal strategy ends to the right of the starting point. We have two more cases:  The optimal o-line strategy visits X 0 before ?x. It follows that t  2x + 2X 0 since in the best case the optimal algorithm has visited X 0 , then it has gone to ?x and has nished to the right of the starting point. In this case T   t + 2x + 2X and the ratio is T  =t  1 + (2x + 2X )=(2x + 2X 0 )  2.  The optimal o-line strategy visits X 0 after having visited ?x. Assume that the optimal o-line algorithm visits for the last time ?x at time d (with d  x since it has traveled from 0 to ?x before time d). Then, at time d it has still to travel at least from ?x to X 0 , and t  d + x + X 0 . If d  t we have that T  =t  (d + 2x + 2X )=(d + x + X 0 )  2. Otherwise, if d  t, the following two facts hold:

Fact 3.2 At every time t0, d  t0  t, the position of the on-line server is f (t0 )  x.

Proof. We show this by contradiction. The release time of the request in position ?x is less than d since at time d the optimal o-line algorithm has already served ?x. Suppose SNB was in f (t0 )  ?x at time t0 . Then the request in ?x would have already been served at time t since the on-line server was in position f (t)  x at time t, a contradiction. Otherwise, if SNB was in ?x  f (t0 )  x at time d, then it must have crossed position x towards right before time t. By de nition of SNB this could only be possible if at a certain moment the nearest extreme is to the right of x. But, given that at time t the request in ?x is the leftmost one, and that anything to the right of x is further from the origin than ?x, this is a contradiction.

Fact 3.3 Starting at time d the on-line server moves towards left until time t. Proof. From the previous fact we know that the on-line server is

always in position f (t0 )  x with d  t0  t. It is sucient to show that between d and t the extreme point nearest to the origin is in the interval [?x; x] in which case the on-line server always moves to the left. This follows immediately from the observation that during this period ?x always remains the leftmost point not yet served. If at time d the on-line server starts from a position f (d)  x to travel towards left and at time t it is still to the right of x we have that T   d + X 0 +2x + X leading the ratio to be T  =t  (d + X 0 + 2x + X )=(d + x + X 0 )  2. 4. X  f (t)  X 0 . The on-line server is to the right of X and it will nish its work by T   t + X 0 + x. On the other hand, we have that t  Y 0 + X 0 . The ratio is T  =t  (t + X 0 + x)=t  1 + (x + X 0 )=(Y 0 + X 0 )  2. We nally prove that there is a sequence of requests for which SNB achieves a ratio of 7=3. At time 1 two requests in -1 and 1/2 are presented. At time 1 the on-line algorithm leaves 0 towards 1/2 and arrives at the starting point at time 2 when a new request is presented in 1 ? . Again, the on-line server goes to the right and arrives in 1 ?  at time 3 ? . At that time a new request is given in 1 +  and the on-line algorithm goes to the left since the extreme point in -1 is nearer to the starting point than 1 + . Finally the on-line server takes 7 ?  to serve the requests, while the optimal o-line solution takes 3+ . Then the ratio tends to 7=3 as  tends to 0. The example is illustrated in Figure 4.

4 Conclusions and open problems We have studied a classical scheduling problem from a new point of view that seems very natural and realistic, given the great quantity of applications in which work must be started before having complete information about the input, and in which things can not always be done optimally.

−1

0

0.5

1

greedy server off−line server time

Fig. 4. A worst-case sequence for the SNB algorithm The main open questions regards the gap between lower and upper bounds for the problems in the plane and in the line. We conjecture that 2-competitive algorithms should exist in both cases. Was this conjecture true, it would imply that the use of randomization does not help to improve the performance of online algorithms for this problem. During our research to establish the conjecture, we have considered a great quantity of algorithms, more or less intuitive, specially in the case of the line. All of them have been ruled out for having counterexamples in which their competitive ratio was not less than 7=3. Among them we may cite the strategy that always follows the optimal o-line solution computed over the set of known requests; another strategy similar to SNB but that considers as the distance from the origin the maximum between the geometric distance of the point and the release time of the request; an algorithm that waits till the optimal o-line time before starting to move, and many others. However, all the eorts done trying to obtain a lower bound bigger than 2 have also failed. As for polynomial algorithms for the plane, it would be interesting to use a better heuristic, for instance Christo des' heuristic for ETSP that approximates the optimal solution up to a factor of 3=2. However, a property such as that of Lemma 2.6 does not hold for it, and hence it has not been possible to use it to obtain a better competitive ratio for our problem. A challenging problem is that in which more than one server are used. Another interesting research direction regards the consideration of dierent metric spaces. The lower bound of 2 we have proved in this work is not necessarily valid for every metric space. We think that the factor of 2 could be beaten under certain conditions. Finally, a dierent problem to consider is that in which the server must go back to the origin after serving all the requests. In this case the lower bound of 2 does not hold either. Even if very similar to our problem, the dierences with the latter make it deserve study on its own.

References 1. M. Atallah and S. Kosaraju, Ecient solutions for some transportation problems

2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15.

with application to minimizing robot arm travel, SIAM J. on Computing, 17 (1988), pp. 849-869. S. Ben-David, A. Borodin, R.M. Karp, G. Tardos and A. Widgerson, On the power of randomization in on-line algorithms, Proc. of the 22nd Annual ACM Symposium on Theory of Computing, (1990), pp. 379-386. R. El-Yaniv, A. Fiat, R.M. Karp and G. Turpin, Competitive analysis of nancial games, Proc. 33rd Annual Symposium on Foundations of Computer Science (1992), pp. 327-333. G. Frederickson, A note on the complexity of a simple transportation problem, SIAM J. on Computing, 22-1 (1993), pp. 57-61. G. Frederickson and D. Guan, Preemptive ensemble motion planning on a tree, SIAM J. on Computing, 21-6 (1992), pp. 1130-1152. G. Frederickson, M. Hecht and C. Kim, Approximation algorithms for some routing problems, SIAM J. on Computing, 7-2 (1978), pp. 178-193. M. Garey, and D. Johnson, Computers and intractability: a guide to the theory of NP-completeness, Freeman, San Francisco (1979). Y. Karuno, H. Nagamochi and T. Ibaraki: Vehicle scheduling on a tree with release times and handling times, Proc. 4th. International Symposium on Algorithms and Computation ISAAC'93, LNCS 762 (1993), Springer-Verlag, pp. 486-495. B. Kalyanasundaram and K.R. Pruhs, Constructing competitive tours from local information, Proc. 20th International Colloquium on Automata, Languages and Programming, LNCS 700 (1993), Springer-Verlag. M. Manasse, L.A. McGeoch and D. Sleator, Competitive algorithms for server problems, Journal of Algorithms 11 (1990), pp. 208-230. H. Psaraftis, M. Solomon, T. Magnanti and T. Kim, Routing and scheduling on a shoreline with release times, Management Science 36-2 (1990), pp. 212-223. D. Sleator, R. Tarjan, Amortized eciency of list update and paging algorithms, Comm. ACM 28 (1985), pp. 202-208. D. Sleator, R. Tarjan, Self-adjusting binary search trees, Journal of the ACM, 32 (1985), pp. 652-686. M. Solomon, Algorithms for the vehicle routing and scheduling problem with time window constraints, Operations Research, 35-2 (1987), pp. 254-265. M. Solomon and J. Desrosiers, Time window constrained routing and scheduling problems: a survey, Transportation Science, 22 (1988), pp. 1-13.

This article was processed using the LaTEX macro package with LLNCS style