arX

iv:1

404.

5510

v2 [

cs.D

S]

11 O

ct 2

016

Serving Online Requests with Mobile Servers

Abdolhamid Ghodselahi and Fabian KuhnDepartment of Computer Science, University of Freiburg

79110 Freiburg, Germanyhghods,kuhn@cs.uni-freiburg.de

Abstract

We study an online problem in which a set of mobile servers have to be moved in order to efficientlyserve a set of requests that arrive in an online fashion. Moreformally, there is a set ofn nodes and a set ofkmobile servers that are placed at some of the nodes. Each nodecan potentially host several servers and theservers can be moved between the nodes. There are requests1, 2, . . . that are adversarially issued at nodesone at a time. An issued request at timet needs to be served at all timest′ ≥ t. The cost for serving therequests is a function of the number of servers and requests at the different nodes. The requirements on howto serve the requests are governed by two parametersα ≥ 1 andβ ≥ 0. An algorithm needs to guarantee atall times that the total service cost remains within a multiplicative factor ofα and an additive termβ of thecurrent optimal service cost.

We consider online algorithms for two different minimization objectives. We first consider the naturalproblem of minimizing the total number of server movements.We show that in this case for everyk, thecompetitive ratio of every deterministic online algorithmneeds to be at leastΩ(n). Given this negativeresult, we then extend the minimization objective to also include the current service cost. We give almosttight bounds on the competitive ratio of the online problem where one needs to minimize the sum of the totalnumber of movements and the current service cost. In particular, we show that at the cost of an additionaladditive term which is roughly linear ink, it is possible to achieve a multiplicative competitive ratio of 1+ εfor every constantε > 0.

1 IntroductionConsider of a company with several project teams which are located at different places. Moving a whole teamto a new location is expensive, however depending on where new customers arrive, it might still be desirable todo. The cost for serving the customers at a certain location clearly depends (in a possibly non-linear way) onthe number of project teams and on the number of customers at the location. Alternatively think of a distributedservice that is offered on a large network such as the Internet. To offer the service, a provider might have abudget to placek servers in the network. The best placement of servers depends on the distribution of theusers of the distributed service. As the set of users might grow (or even change arbitrarily) over time, fromtime to time, we might have to move some of the servers, even though migrating a whole server might be arelatively costly thing to do. These scenarios could be generally seen as a problem where servers are relativelylarge entities such that while they can be moved, doing this is a relatively costly operation, irrespective of, e.g.,between which nodes a movement occurs. The above scenarios are applications of the abstract problem studiedin this paper. The problem studied in this paper can be formally modeled as follows.

Assume two parametersα andβ are given such thatα ≥ 1 andmax α− 1, β ≥ 1. There is a setV of nnodes and there arek mobile servers, where each server has to be placed at one of the nodes. Further, there arerequests that arrive at the nodes in an online fashion and which need to be “permanently” served, i.e. an issuedrequest at timet has to be served at all timest, t + 1, . . .. We assume that any node can potentially host anarbitrary number of servers. Formally, the cost for servingthe requests at each nodev, which is calledservicecostof nodev, is given by a general cost function that depends onv, on the number of requests at nodev, aswell as on the number of servers placed atv. Generally, the more requests there are at some node, the more it

1

costs to serve these requests. Further, if we place more servers at a given node, the cost for serving the requestsat this node becomes smaller (formally defined in Section2.2).1 The requests arrive one by one and the task ofan algorithm is to plan the movements of thek servers in a way to keep afeasible configurationof thek serversat all times. A configuration of servers is called feasible whenever thetotal service cost, that is the summationof service costs for all nodes, is upper bounded byαS∗

t + β, where,S∗t is the optimal total service cost at time

t.We consider two different objective functions. We first study a natural variant of the problem where the

goal is to minimize the total number of movements. For this setting, we show that any deterministic onlinealgorithm has a competitive ratio of at leastΩ(n), independent of the value ofk.

Given this negative result, we then consider an objective function where the cost at timet is the sum ofthe total number of movements up to timet and the total service cost at timet (shown byCostAt for a givenalgorithmA). We study a simple online greedy algorithm which a) only moves when it needs to move becausethe configuration is not feasible any more and b) always movesa server which improves the service cost asmuch as possible. We show that the total number of movements up to a timet of this online greedy algorithmcan be upper bounded as a function of the optimal service costS∗

t at timet. Most significantly, we show thateven forα = 1, for anyε > 0, as long asβ = Ω(k+k/ε), at all timest, the costCostAt of the greedy algorithmcan be upper bounded by the costCost

Ot of an optimal algorithm asCostAt ≤ (1+ ε)CostOt +O(β+ k log k).

We also show that this result is essentially tight. In particular, an additive term which is at least linear ink isunavoidable (even for much larger multiplicative competitive ratio).

1.1 Related Work

In its basic version, where we only consider the movement cost, the problem considered in the present papergenerally falls into a class of movement problems introduced in [7]. In this version, the most similar of theclassic problems is thek-server problem [17] or more specifically the paging problem [20] (equivalent to thek-server problem with uniform distances). In thek-server problem, every new request has to be served bymoving some server to the location of the request and the onlycost considered is the total movement cost. Thek-server problem is well studied. For general metric spaces,the best competitive ratios known are2k − 1 [15]and O(log2 k log3 n) [4]. The authors of [4] use a problem called the allocation problem (AP) to solve thek-server problem. The AP and also the results on the AP have some resemblances to the model and results inthe present paper when considering the objective function based on service and movement costs. However, likek-server, in the AP the requests are served only once they arrive at the requested points while in our model therequests are permanently served and servers are not necessarily moved to the requested points.

When considering the variant of our problem where the service cost is included in the objective function,the problem can be seen as an online version of the mobile facility location problem (MFLP) with uniformdistances. MFLP in general metrics was introduced in [7, 11] as a movement problem. It can be seen as ageneralization of the standardk-median and facility location problems [11]. Thek-median and facility locationproblems have been widely studied in both operations research and computer science [3, 5, 6, 8, 12, 14]. In[1, 11], MFLP is modeled in such a way that the algorithm moves each facility and client to a point where inthe final configuration, each client is at a node with some facility. The goal is to minimize the total movementcost of facilities and clients. The movement cost between the clients and the final configuration points could beinterpreted as a service cost somewhat similar to what we usein this paper. Note that since in our case, requestsneed to be permanently served, we cannot model the service cost as a movement cost.

Classically, the cost of serving a request in the facility location problem is given by the distance from therequest to the facility to which it is assigned. In a uniform metric, this corresponds to the most basic costfunction that can be studied in our framework (service cost is equal to the number of requests at nodes withno servers). As described, we significantly generalize thisbasic service cost model. In the context of facility

1The most basic cost function would incur a service cost ofx wheneverx requests are at a node with no server and a service cost of0 for all requests at nodes with at least one server.

2

location, a similar approach was used in [13]. More concretely, in [13], it is assumed that the cost of a facilityincreases as a function of the requests it needs to serve.

There exist various natural models in which the locations ofrequests are not known in advance, and asolution must be built or maintained gradually over time without any knowledge about future requests likeonline facility location problem. The first algorithm for online facility location was introduced in [18]. For abroad discussion of models and results on online facility location problem, we refer to the survey in [10].

Finally, the problem studied in this paper has some resemblance to learning problems [2, 16, 19]. Some-what similarly to expert learning algorithms where in essence, one converges to the “right set of experts”, ouralgorithm has to converge to the “right set of nodes” to placeits servers. However, in our case, the cost willusually be dominated by the total movement cost, i.e., the total cost for replacing the servers. In learning,switching to a different set of experts is usually not considered a (main) cost.

2 Problem StatementWe are given a setV of n nodes and there is a set ofk servers. Further, there are requests1, 2, . . . thatadversarially arrive one at a time. Moreover two parametersα andβ are given such that

α ≥ 1 and max α− 1, β ≥ 1. (1)

We assume that at timet ≥ 1, requestt arrives at nodev(t) ∈ V . For a nodev ∈ V , let rv,t be the numberof requests at nodev after t requests have arrived, i.e.,rv,t := |i ≤ t : v(i) = v|. In order to keep thetotalservice costsmall, an algorithm can move the servers between the nodes (if necessary, for answering one newrequest, we allow an algorithm to also move more than one server). However throughout the execution, eachof thek servers is always placed at one of the nodesv ∈ V . We define aconfigurationof servers by integersfv ∈ N0 for eachv ∈ V such that

∑

v∈V fv = k. We describe such a configuration by a set of pairs asF := (v, fv) : v ∈ V . The initial configuration is denoted byF0.

Service Cost: We implicitly assume that if a nodev has some servers, all requests atv are served by theseservers. This also implies that the “assignment” of requests to servers can change over time and the servicecost is not cumulative. Depending on the number of servers and the number of requests at a nodev ∈ V ,an algorithm has to pay some service cost to serve the requests located atv. This service cost of nodev isdefined by aservice cost functionσv such thatσv(x, y) ≥ 0 is the cost for servingy requests if there arexservers at nodev. For convenience, fort ≥ 1, we also defineσv,t(x) := σv(x, rv,t) to be the service costwith x servers at nodev at time t. For some configurationF , we denote the total service cost at timet bySt(F ) :=

∑

v∈V σv,t(fv) =∑

v∈V σv(fv, rv,t).

Feasible Configuration: We define a configurationF to be feasible at timet iff

St(F ) < α · S∗t + β (2)

whereS∗t is theoptimal total service costat timet, i.e. S∗

t := minFSt(F ). Note thatS∗

t is not necessarily the

same as the total service costSOt of an optimal algorithmO at timet. We say that a configurationF ∗ is an

optimal configurationat timet if St(F ∗) = S∗t .

Feasible Solution: For a given algorithmA, we denote the solution at timet by FAt :=

FA(i) : i ∈ [0, t]

,whereFA(t) is the configuration after reacting to the arrival of requestt and whereFA(0) = F0. Note that fortwo integersa ≤ b, [a, b] := a, . . . , b denotes the set of all integers betweena andb. Further, for an integera ≥ 1, we use[a] as a short form to denote[a] := [1, a]. The service cost of an algorithmA at timet is denotedby SA

t := St(FA(t)).

Movement Cost: We define the movement costMAt of given algorithmA to be the total number of server

movements by timet. Generally, for two feasible configurations,F = (v, fv) : v ∈ V andF ′ = (v, f ′v) : v ∈ V ,we define the distanceχ(F,F ′) between the two configurations as follows:

χ(F,F ′) :=∑

v∈V

max

0, fv − f ′v

=1

2·∑

v∈V

∣

∣fv − f ′v∣

∣ . (3)

3

The distanceχ(F,F ′) is equal to the number of movements that are needed to get fromconfigurationF toconfigurationF ′ (or vice versa). Based on the definition ofχ, we can express the movement cost of an algorithmA with solutionFA

t =

FA(i) : i ∈ [0, t]

asMAt =

∑ti=1 χ

(

FA(i− 1), FA(i))

.

2.1 Objective Functions

As described in Section1, we consider two different objective functions.

Minimizing the Movement Cost: The goal is to keep the number of movements as small as possible. In otherwords, the costCostAt of an algorithmA is defined asCostAt :=MA

t .

Minimizing the Combined Cost: The goal here is to minimize the overall cost of an algorithmA, that is, weaim to keepCostAt := SA

t +MAt as small as possible.

2.2 Service Cost Function Properties

The service cost functionσ has to satisfy a number of natural properties. First of all, for everyv ∈ V , σv(x, y)has to be monotonically decreasing in the number of serversx that are placed at nodev and monotonicallyincreasing in the number of requestsy atv.

∀v ∈ V ∀x, y ∈ N0 : σv(x, y) ≥ σv(x+ 1, y) (4)

∀v ∈ V ∀x, y ∈ N0 : σv(x, y) ≤ σv(x, y + 1) (5)

Further, the effect of adding additional servers to a nodev should become smaller with the number of servers(convex property inx) and it should not decrease if the number of requests gets larger. Therefore, for allv ∈ Vand allx, y ∈ N0, we have

σv(x, y)− σv(x+ 1, y) ≥ σv(x+ 1, y)− σv(x+ 2, y) (6)

σv(x, y)− σv(x+ 1, y) ≤ σv(x, y + 1)− σv(x+ 1, y + 1) (7)

In the following, whenever clear from the context, we omit the superscriptA in the algorithm-dependentquantities defined above.

3 ContributionsThe following theorem provides a lower bound for any deterministic online algorithm that solves the problemof minimizing the total number of movements as described in Section2.1. We remark that this lower boundas well as the lower bound in Theorem3.3 even hold for the simple (and natural) scenario, where the servicecost at a node with at least1 server is0 and the service cost at a node with0 servers is equal to the number ofrequests at that node.

Theorem 3.1(Lower Bound). Assume that we are given parametersα andβ which satisfy(1) and assumethat the objective is to minimize the number of movements. Then, for any online algorithmA, there exists anexecution and a timet > 0 such that the competitive ratio between the number of movements byA and thenumber of movements of an optimal offline algorithm is at least n/2. More precisely for allMO

t > 0 there isan execution such thatMA

t ≥ n2 ·MO

t .

Given the large lower bound of Theorem3.1, we adapt the objective function to also include the servicecost. The following Theorems3.2and3.3upper and lower bound the achievable competitive ratio in this case.In Section5.1, we describe a simple, deterministic online algorithmA with the following properties. For twogiven parametersα andβ, A guarantees that at all timest ≥ 0, (2) is met. AlgorithmA guarantees (2) whilekeeping the total movement cost small. More precisely, we prove the following main theorem.

Theorem 3.2(Upper Bound). There is a deterministic algorithmA such that for all timest ≥ 0, the followingstatements hold.

4

• If α = 1 andβ = Ω(

k + kε

)

for an abitraryε > 0,

CostAt ≤ (1 + ε)CostOt +O(β + k log k).

• If α = 1 andβ = Ω(

k·log klog log k

)

, for everyε ≥ log log k/ log1−δ k and any constant0 < δ ≤ 1,

CostAt ≤ (1 + ε)CostOt +O (β) .

We also prove an almost matching lower bound. The total cost of both online and optimal offline algorithmsare bounded by functions of the optimal service cost.

Theorem 3.3(Lower Bound). Givenα ≥ 1 andβ satisfying(1), consider any deterministic online algorithmA and assume thatO is an optimal offline algorithm. Then, when considering the combined objective function,there exist an execution and a timet > 0 such that the total costs ofA andO can be bounded as follows.

• For α = 1 andβ = Ω(k/ε) for anyε > 0, it holds that

CostAt ≥

(

1 + ε

(

1− 1 + ε

k

))

CostOt +Ω(β + k log k).

• For α = 1 andβ = Ω(

k·log klog log k

)

for everyε ≥ log log k/ log1−δ k and any constant0 < δ ≤ 1 we

obtain

CostAt ≥

(

1 + ε

(

1− 1 + ε

k

))

CostOt +Ω

(

k · log klog log k

)

.

Choosingα > 1: The results of the above theorems all hold forα = 1, i.e., an algorithm is always forcedto move to a configuration which is optimal up to the additive termβ. Even ifα is chosen to be larger than1,as long as we want to guarantee a reasonably small multiplicative competitive ratio (of ordero(k)), an additiveterm of orderΩ(k) is unavoidable. In fact, in order to reduce the additive termtoO(k), α has to be chosen to beof orderkδ for some constantδ > 0. Note that in this case, the multiplicative competitive ratio grows to at leastα ≫ 1. However, it might still be desirable to chooseα > 1. In that case, it can be shown that the movementcostMA

t of our simple greedy algorithmA only grows logarithmically with the optimal service costS∗t (where

the basis of the logarithm isα). As an application, this for example allows to be(1 + ε)-competitive for anyconstantε > 0 against an objective function of the formγ · SA

t +MAt even ifγ is chosen of orderk−O(1).

4 Minimizing the Number of MovementsWe provide a proof for our lower bound as claimed in Theorem3.1 in Section3. As we can assume that eachnode either has0 or 1 servers, we slightly overload notation and simply denote a feasible configuration by a setF ⊂ V of size|F | = k.

4.1 Lower Bound

We first fixA to be any deterministic online algorithm andO to be any optimal offline algorithm. For provingthe statement of Theorem3.1, we distinguish two cases, depending on the number of servers k. In both cases,we defineiterationsto be subsequences of requests such thatA needs to move at least once per iteration. Thenumber of movements byA is therefore at least the number of iterations of a given execution.

Casek ≤ ⌊n/2⌋: At the beginning, we place a large number of requests on anyk − 1 nodes that initiallyhave servers. We choose this number of requests sufficientlylarge such that no algorithm can ever move any ofthesek − 1 servers. This essentially reduces the problem tok = 1 andn− k + 1 nodes.

To bound the number of movements byO, we then consider intervals ofn − k iterations such thatA isforced to move in each iteration. During each interval, the requests are distributed in such a way that at the

5

beginning of thei-th iteration of the interval there are at leastn − k − i + 1 nodes such that if any offlinealgorithm places a server on one of these nodes, Condition (2) remains satisfied throughout the whole interval.Hence, there exists an offline algorithm that moves at most once in each interval and therefore the number ofmovements byO is upper bounded by the number of intervals.

Casek > ⌊n/2⌋: In this case, there is some resemblance between the constructed execution and the lowerbound constructions for the paging problem. For simplicityassume that there aren = k + 1 nodes (we letrequests arrive at onlyk+1 nodes). At the beginning of each iteration we locate a sufficiently large number ofrequests on the node without any server ofA such that (2) is violated. Thus,A has to move at least one serverto keep (2) satisfied. By contrast,O does not need to move in each iteration. There is always a nodewhichwill not get new requests for the nextk interations and thereforeO only needs to move at most once everykiterations to keep (2) satisfied.

Proof of Theorem 3.1. Consider any request sequence. First we provide a partitioning of the request sequenceas follows. The request sequence is partitioned intoiterations. Iteration0 is the empty sequence and for everyi ≥ 1, iterationi consists of a request sequence of a length dependent onα, β, and the iteration numberi. Therequest sequence of an iterationi is chosen dependent on a given online algorithmA such thatA must move atleast once in iterationi. We will see that whileA needs to move at least once per iteration, there is an offlinealgorithm which only moves once every at leastn/2 iterations.

In the proof, we reduce all the cases to two extreme cases. In the first case, we reduce the original metricon a set ofn nodes withk ≤ ⌊n/2⌋ servers to the case where there is only1 server. To do this, we first placesufficiently many requests onk−1 nodes that have servers at the beginning of execution (for simplicty, assumethat we place an unbounded number of requests on these nodes). This prevents any algorithm from moving itsservers from thesek − 1 nodes during the execution and hence we can ignore thesek − 1 nodes an servers inour analysis. In contrast, for the second case wherek > ⌊n/2⌋, we assume that w.l.o.g.,k = n− 1 by simplyonly placing requests on thek nodes which have servers at the beginning and on one additional node.

In the following, we letti denote the end of an iterationi. Moreover supposeI is the total number ofiterations, where we assume thatI ≡ 0 (mod max k, n − k).Casek ≤ ⌊n/2⌋: The idea behind the execution is to uniformly increase the number of requests on then−knodes that do not have the server at the beginning of an iteration i (i.e., at timeti−1) in such a way thatA has tomove at least once to satisfy (2) at the end of iterationi. Moreover the distribution of requests guarantees thatany node without the server at timeti−1 is a candidate to have the (free) server ofA at timeti. Let vAt denotethe node on whichA locates its server at timet and letU(t) be the set of all nodes without server at timet.Moreover, letv∗t be a node which has the largest number of requests among all nodes at timet. The node withthe largest number of requests at the end if an iterationi, i.e. v∗ti , is chosen such thatv∗ti 6= vAti−1

. At time 0, wehaveru = 0 for all nodesu. The distribution of requests at the end of iterationi is as follows:

∀u ∈ U(ti−1) \

v∗ti

: ru = rv∗ti−1+max β, 1 , (8)

rvAti−1

= rv∗ti−1, (9)

rv∗ti= (α − 1) · S∗

ti + rv∗ti−1+ β. (10)

Note that since it is clear from the context, we skip the second subscript (i.e.,t) when referring to the numberof requests at a node (cf. Section2).

Claim 4.1. The above execution guarantees thatA has to move at least once per iteration. Further, thereexists an offline algorithmA that moves its servers at mostI/(n− k) times.

Proof. Consider any interval ofn − k iterations such that the first iteration of this interval hasendingtime τ1 and the finishing time of the last iteration (or the finishing time of the interval) isτn−k. Further,suppose the previous interval has finished att. Obviously, if this is the first interval,t = 0. Let U :=

6

U(t) \⋃τn−k

t=τ1

vAt

denote the set of nodes which have not had the server ofA during this interval. Theoffline algorithm for all iterations of this interval, locates its server either on nodevAτn−k

if setU is empty

or on some node inU , otherwise. The case in whichU is empty indicates that every node inU(t) has hadthe server ofA exactly once within the interval. Whenever the offline algorithm needs to move, it locates

its server at a node inU ∪

vAτn−k

. On the one hand and according to (8), nodevAτn−kor any node inU

(in the case this set is not empty) has at leastrv∗ti−1+ max β, 1 requests at the end of each iterationi

that is in this interval. Therefore, the offline service costat ti is

SAti ≤ (α− 1) · S∗

ti + 2rv∗ti−1

+ β + (n− k − 2) ·(

max β, 1 + rv∗ti−1

)

(11)

On the other hand, the optimal service cost is

S∗ti = (n− k − 1) ·

(

max β, 1+ rv∗ti−1

)

+ rv∗ti−1(12)

using (8), (9), and (10). Hence (11) and (12) imply that

SAti < αS∗

ti + β. (13)

This guarantees that offline algorithm does not need to move more than once during any interval ofn− kiterations. In other words, at the beginning of the interval, the offline algorithm decides to locate its server

to a node inU ∪

vAτn−k

if it needs because it knows the behaviour of the online algorithm in advance as

well as the request sequence. According to (13), this one movement byA is sufficient to keep (2) satisfiedwithin the interval. Therefore, the offline algorithm movesat mostI/(n− k) times.

At the end of each iterationi, if the online algorithm has not moved yet within the iteration i then wehavevAti−1

= vAti . Thus,

SAti = (α− 1) · S∗

ti + rv∗ti−1+ β + (n− k − 1) ·

(

max β, 1+ rv∗ti−1

)

(14)

with respect to (8), (9), and (10). Therefore due to (12) and (14) we haveSAti = αS∗

ti + β. This impliesthat the online algorithm must had moved at least once to guarantee

∀i : vAti−16= vAti .

ThusA has to move once per iteration and then the claim holds.

Corollary 4.2. The Claim4.1 implies that

MOt ≤ MA

t

n− k.

wheret be the ending time of(c · (n− k))-th iteration for any integerc ≥ 1.

Proof. It follows the fact thatMOt ≤MA

t .

Casek > ⌊n/2⌋: Here when we have more servers than half of the nodes, we assume, w.l.o.g.n = k + 1.This is doable by letting the requests arrive at a fix set of nodes of sizek + 1 includingk servers. Therefore, ateach time there is only one node without a server in which thissituation holds for any algorithm. LetvAt denotethe node without any server ofA at timet. We forceA to move in each iterationi by putting large enoughnumber of requests onvAti−1

while any optimal offline algorithm only moves one of its servers after at leastkiterations. Consider an interval ofk iterations starting from the first iteration of this interval with ending time

7

τ1 and ending at the last iteration at timeτk. For any iterationi of this interval the distribution of the requestsat the end of the iteration is as follows.

rvAti−1

= αS∗ti +max β, 1 . (15)

According to (15) the optimal service cost does not change during the interval, i.e. S∗τi = S∗

τi+1 for all i ∈ [k−1]of the current interval.

Claim 4.3. The above execution guarantees thatA has to move at least once per iteration while thenumber of movements by any optimal offline algorithm is at most I/k.

Proof. At the end of iterationi, assumevAti−1= vAti , then we have

SAti = αS∗

ti +max β, 1 ≥ αS∗ti + β (16)

using (15). It implies that the online algorithm must had moved at least once to guarantee

∀i : vAti−16= vAti .

The optimal offline algorithm, by contrast, need to move a server from vAτk to vAτ1 during the intervalwith respect to the request distribution in (15). The nodevAτk is the node hasαS∗

t+max β, 1 requests

within the interval due to (15) wheret is the ending time of any iteration of the previous interval.Hence,at the end of any iterationi in the interval, the optimal offline service cost equals the optimal service costand thus (2) remains satisfied. Consequently it implies that at most onemovement by optimal offlinealgorithm is sufficient during the interval. This concludesthat the number of movements by any optimaloffline algorithm is at mostI/k in this case.

Let t be the ending time of(c · max k, n − k)-th iteration for any integerc ≥ 1. Using Corollary4.2 andClaim 4.3

MAt ≥ max n− k, k ·MO

t ≥ n

2·MO

t .

Thus the claim of the theorem holds.

5 Minimizing Movements and Service CostWe will now extend the objective function used in Section4 by also including the service cost. We will seethat this allows us to be able to compete against an optimal offline algorithmO. In the rest of this section, firstwe devise a simple and natural online greedy algorithm. We then analyze the algorithm and provide an almosttight lower bound.

5.1 Algorithm Description

The goal of our algorithm is two-fold. On the one hand, we haveto guarantee that the service cost of thealgorithm is always within some fixed bounds of the optimal service cost. On the other hand, we want to achievethis while keeping the overall movement cost low. Specifically, as we are givenα andβ in which (1) holds, weguarantee that at all times (2) remains satisfied. Condition (2) is maintained in the most straightforward greedymanner. Whenever after a new request arrives, (2) is not satisfied, the algorithm greedily moves servers until(2) holds again. Hence, as long as (2) does not hold, the algorithm moves a server that reduces thetotal servicecost as much as possible. The algorithm stops moving any server as soon as the validity of (2) is restored.

Whenever the algorithm moves a server, it does a best possible move, i.e., a move that achieves the bestpossible service cost improvement. Thus, the algorithm always moves a server from a node where removing a

8

server is as cheap as possible to a node where adding a server reduces the cost as much as possible. Therefore,for each movementm, we have

vsrcm ∈ argminv∈V

σv,τm(fv,m−1 − 1)− σv,τm(fv,m−1) and (17)

vdstm ∈ argmaxv∈V

σv,τm(fv,m−1)− σv,τm(fv,m−1 + 1) , (18)

whereargminv andargmaxv denote the sets of nodes minimizing and maximizing the respective terms.

5.2 Analysis Overview

While the algorithm itself is quite simple, its analysis turns out relatively technical. We thus first describe thekey steps of the analysis by discussing a simple case. We assume that the service cost at any node is equalto 0 if there is at least one server at the node and the service costis equal to the number of requests at thenode, otherwise. Further, we assume that we run the algorithm of 5.1 with parametersα = 1 andβ = 0, i.e.after each request arrives, the algorithm moves to a configuration with optimal service cost. Note that theseparameter settings violate Condition (1) and we will therefore get a weaker bound than the one promised byTheorem3.2.

First, note that in the described simple scenario, the algorithm clearly never puts more than one server tothe same node. Further, whenever the algorithm moves a server from a nodeu to a nodev, the overall servicecost has to strictly decrease and thus, the number of requests at nodev is larger than the number of requests atnodeu. Consider some point in timet and let

rmin(t) := minv∈V :fv,t=1

rv,t

be the minimum number of requests among the nodesv with a server at timet. Hence, whenever at a timet, thealgorithm moves a server from a nodeu to a nodev, nodeu has at leastrmin(t) requests and consequently, nodev has at leastrmin(t) + 1 requests. Further, if at some later timet′ > t, the server at nodev is moved to someother nodew, because the algorithm always removes a server from a node with as few requests as possible, wehavermin(t

′) ≥ rmin(t) + 1. Consequently, if in some time interval[t1, t2], there is some server that is movedmore than once, we know thatrmin(t1) < rmin(t2). In our analysis, we partition time into phases, where thefirst phase starts at time0 and where phases are maximal time intervals in which each server is moved at mostonce (cf. Def.5.1 in the formal analysis of the algorithm).

The above argument implies that after each phasermin increases by at least one and therefore at any timet in phasep, we havermin(t) ≥ p − 1 and at the end of phasep, we havermin(t) ≥ p. In Section5.3, themore general form of this statement appears in Lemma5.1. There,γp is defined to be the smallest service costimprovement of any movement in phasep (γp = 1 in the simple case considered here), and Lemma5.1showsthatrmin grows by at leastγp in phasep. Assume that at some timet in phasep, a server is moved from a nodeu to a nodev. Because nodeu already had its server at the end of phasep− 1, we haveru,t = rmin(t) ≥ p− 1.Consequently, at the end of phasep, there is at least one node (the source of the last movement) that has noserver and at leastp−1 requests. The corresponding (more technical) statement inour general analysis appearsin Lemma5.3.

We will bound the total cost of the online algorithm and an optimal offline algorithm from above and below,respectively, as a function of the optimal service cost. Hence, the ratio between these two total costs providesthe desired competitive factor. Our algorithm guarantees that at all times, the service cost is within fixed boundsof the optimal service cost (in the simple case here, the service cost is always equal to the optimal service cost).Knowing that there are nodes with many requests and no servers, therefore allows to lower bound the optimalservice cost. In the general case, this is done by Lemmas5.6and5.7. In the simple case, considered here, as atthe end of phasep, there arek nodes with at leastp requests (the nodes that have servers) and there is at leastone additional node with at leastp− 1 requests, we know that at the end of phasep, the optimal service cost isat leastp− 1. Consequently, the online algorithm (in the simple case) pays exactly the optimal service cost (as

9

mentioned before, in the general case, the service cost is within fixed bounds of the optimal service cost) and atmost(p− 1)k as movement cost. Hence, the total cost paid by online algorithm is at most a factork + 1 timesthe optimal service cost since the optimal service cost is atleastp − 1. By choosingα which is slighly largerthan1 and a largerβ (β ≥ k), the algorithm becomes more lazy and one can show that the difference betweenthe number of movements ofA and the optimal service cost becomes significantly smaller.Also note that byconstruction, the service cost ofA is always at mostαS∗

t + β ≤ αSOt + β.

When analyzing our algorithm, we mostly ignore to take into account the movement cost of an optimaloffline algorithm. We only exploit the fact that by the timeA decides to move a server for the first time, anyother algorithm must also move at least one server and therefore the optimal offline cost becomes at least1.

5.3 Upper Bound Analysis

In the following, we show that how to upper bound the combinedcost (service cost and movement cost) of ouronline algorithmA by a function of the combined cost of an optimal offline algorithmO. Clearly, the algorithmat all timest ≥ 0 guarantees that the service cost can be bounded as

SAt < αS∗

t + β ≤ αSOt + β. (19)

In order to upper bound the combined cost, it therefore suffices to study how the movement costMAt of the

online algorithm grows as a function of the combined optimaloffline algorithm cost. LetO be an optimaloffline algorithm and letFO(t) be the configuration ofO at timet. Recall thatχ(F0, F

O(t)) denotes the totalnumber of movements required to move from the initial configuration to configurationFO(t). We thereforehaveCostOt = SO

t +MOt ≥ S∗

t +χ(F0, FO(t)). In order to upper boundMA

t as a function ofCostOt , we willupper bound it as a function ofS∗

t + χ(F0, FO(t)).

Instead of directly dealing withχ(F0, FO(t)), we will make use of the fact that our analysis works for a

general cost functionσ satisfying the conditions given in (4), (5), (6), and (7). Given a service cost functionσ,consider a functionσ′ which is defined as follows:

∀v ∈ V,∀x ∈ 0, . . . , k ,∀y ∈ N0 : σ′v(x, y) := σv(x, y) + max 0, fv(0) − x

wherefv(t) is the number of servers at timet on nodev. Clearly,σ′ also satisfies the conditions given in (4),(5), (6), and (7). In addition, for any timet and any configurationF = (v, fv) : v ∈ V , we have

S′t(F ) =

∑

v∈V

σ′v(fv, rv,t)

=∑

v∈V

(σv(fv, rv,t) + max 0, fv(0)− fv)

(3)= St(F ) + χ(F0, F ) (20)

whereS′t(F ) refers to the total service cost w.r.t. the new cost functionσ′. Hence,S′

t(F ) exactly measures thesum of service cost and movement cost of a configurationF . Of course now, in all our results,S∗

t correspondsto the combination of service and movement cost of an optimalconfigurationF ∗.

We are now going to analyze the algorithm of Section5.1. In the following, whenever we refer to thealgorithm introduced in Section5.1, we omit the superscriptA. In our analysis, we will bound the total costsof optimal offline algorithmO and online algorithmA from below and above, respectively, as functions ofoptimal service cost and thus provide the upper bound (competitive factor) promised in Theorem3.2. Hencewe first go through calculating the optimal service cost.

For the analysis of the described online algorithm, we partition the movements into phasesp = 1, 2, . . . ,where roughly speaking, a phase is a maximal consecutive sequence of movements in which no server is movedtwice. We usemp to denote the first movement of phasep (for p ∈ N). In addition, we definevsrc,Am andvdst ,Am

to be the nodes involved in them-th server move, where we assume thatA moves a server from nodevsrcm tovdstm . Formally, the phases are defined as follows.

10

Definition 5.1 (Phases). The movements are divided into phasesp = 1, 2, . . . , where phasep starts withmovementmp and ends with movementmp+1 − 1. We havem1 = 1, i.e., the first phase starts with the firstmovement. Further for everyp > 1, we define

mp := min

m > mp−1 : ∃m′ ∈ [mp−1,m− 1] s.t.vsrcm = vdstm′

. (21)

For a phasep ≥ 1, letλp := mp+1 −mp be the number of movements of Phasep.

5.3.1 Optimal Service Cost Analysis

The algorithm moves servers in order to improve the service cost. Throughout the rest of the paper, we useτAm to denote the time of themth movement. For a given movementm, we useγ(m) > 0 to denote servicecost improvementof m. Further, we useF0 to denote the initial configuration of thek servers and for a given(deterministic) algorithmA, for anym ≥ 1, we letFA

m =

(v, fAv,m) : v ∈ V

be the configuration of thekservers forA afterm server movements (i.e., afterm server movements ofA, nodev hasfAv,m servers).

γ(m) := Sτm(Fm−1)− Sτm(Fm)

=(

σvdstm ,τm(fvdstm ,m−1)− σvdstm ,τm(fvdstm ,m))

−(

σvsrcm ,τm(fvsrcm ,m)− σvsrcm ,τm(fvsrcm ,m−1))

. (22)

For each Phasep, we define the improvementγp of p and thecumulative improvementΓp by Phasep asfollows

γp := minm∈[mp,mp+1−1]

γ(m) and Γp :=

p∑

i=1

γi, Γ0 := 0, γ0 := 0. (23)

We are now ready to prove our first technical lemma, which lower bounds the cost of removing serversfrom nodes with servers (for allv ∈ V such thatfv ≥ 1) at any point in the execution. The result of followingLemma implies that removing any server of an optimal configuration during some phasep increases the optimalservice cost at leastΓp−1 (andΓp at end of phasep) since the servers of an optimal configuration are located atplaces with maximum number of requests.

Lemma 5.1. Letm be a movement and,F = (v, fv) : v ∈ V be the configuration of the algorithm at anypoint in the execution after movementm and lett ≥ τm be the time at which the configurationF occurs. Then,for all timest′ ≥ t and for all nodesv ∈ V , if fv > 0 it holds that

σv,t′(fv − 1)− σv,t′(fv) ≥ Γp−1,

wherep is the phase in which movementm occurs.

Proof. We will show that for each server movementm ∈ N of the algorithm, it holds that

∀v ∈ V : fv,m > 0 =⇒ σv,τm(fv,m − 1)− σv,τm(fv,m) ≥ Γp−1, (24)

wherep is the phase in which movementm occurs (i.e., the claim of the lemma holds immediately aftermove-mentm). The lemma then follows because(i) any configuration(v, fv) : v ∈ V occurring after movementm is the configurationFm′ for some movementm′ ≥ m, (ii) the valuesΓp−1 are monotonically increasingwith p, and(iii) by (7), for all v ∈ V , the valueσv,t(f − 1)− σv,t(f) is monotonically non-decreasing witht.

It therefore remains to prove (24) for everym, wherep is the phase of movementm. We prove a slightlystronger statement. Generally, for a movementm′ and a phasep′, let V dst

p′,m′ be the set of nodes that havereceived a new server by some movementm′′ ≤ m′ of Phasep′. Hence,

V dst

p′,m′ :=

v ∈ V : ∃ movementm′′ ≤ m′ of Phasep′ s.t.vdstm′′ = v

.

11

We show that in addition to (24), it also holds that

∀v ∈ V dst

p,m : fv,m > 0 =⇒ σv,τm(fv,m − 1)− σv,τm(fv,m) ≥ Γp. (25)

We prove (24) and (25) together by using induction onm.

Induction Base (m = 1): The first movement occurs in Phase1. By (23), Γ0 = 0 and by (4), we also haveσv,t(f − 1)− σv,t(f) ≥ 0 for all timest ≥ 0, all nodesv ∈ V , and allf ≥ 1. Inequality (24) therefore clearlyholds form = 1. It remains to show that also (25) holds form = 1. We haveV dst

1,1 =

vdst1

and showing (25)for m = 1 therefore reduces to showing thatσvdst

1,τ1(fvdst

1,1 − 1) − σvdst

1,τ1(fvdst

1,1) ≥ Γ1 = γ1, which follows

directly from (22) and (23).

Induction Step (m > 1): We first show that Inequalities (24) and (25) hold immediately before movementmand thus,

∀v ∈ V : fv,m−1 > 0 ⇒ σv,τm(fv,m−1 − 1)− σv,τm(fv,m−1) ≥ Γp−1, (26)

∀v ∈ V dst

p,m−1 : fv,m−1 > 0 ⇒ σv,τm(fv,m−1 − 1)− σv,τm(fv,m−1) ≥ Γp. (27)

If m is not the first movement of Phasep, Inequalities (26) and (27) follow directly from the induction hy-pothesis (form − 1) and from (7). Let us therefore assume thatm is the first movement of Phasep. Notethat in this caseV dst

p,m−1 = ∅ and (27) therefore trivially holds. Becausem > 1, we know that in thiscasep ≥ 2. From the induction hypothesis and from (7), we can therefore conclude that for every nodev ∈ V dst

p−1,m−1 (every nodev that is the destination of some server movement in Phasep − 1), we haveσv,τm(fv,m−1 − 1) − σv,τm(fv,m−1) ≥ Γp−1. Note that for all these nodes, we havefv,m−1 > 0. Becausemis the first movement of Phasep, Definition 5.1 implies thatvsrcm ∈ V dst

p−1,m−1. Applying (17), we get that forall v ∈ V , σv,τm(fv,m−1 − 1) − σv,τm(fv,m−1) ≥ σvsrcm ,τm(fvsrcm ,m−1 − 1) − σvsrcm ,τm(fvsrcm ,m−1) ≥ Γp−1 andtherefore (26) also holds ifm ≥ 2 is the first movement of some phase.

We can now prove (24) and (25). For all nodesv /∈

vsrcm , vdstm

, we havefv,m = fv,m−1 and we furtherhaveV dst

p,m = V dstp,m−1∪

vdstm

. Forv /∈

vsrcm , vdstm

, (24) and (25) therefore directly follow from (26) and (27),respectively. For the two nodes involved in movementm, first note thatvsrcm /∈ V dst

p,m−1. It therefore suffices toshow that

fvsrcm ,m = 0 or σvsrcm ,τm(fvsrcm ,m − 1)− σvsrcm ,τm(fvsrcm ,m) ≥ Γp−1, (28)

as well as σvdstm ,τm(fvdstm ,m − 1)− σvdstm ,τm(fvdstm ,m) ≥ Γp. (29)

We havefvsrcm ,m = fvsrcm ,m−1 − 1 andfvdstm ,m = fvdstm ,m−1 + 1. Inequality (28) therefore directly follows from(26) and from (6). For (29), we have

σvdstm ,τm(fvdstm ,m − 1)− σvdstm ,τm(fvdstm ,m)

(22)= σvsrcm ,τm(fvsrcm ,m)− σvsrcm ,τm(fvsrcm ,m − 1) + γ(m)

(26)≥ Γp−1 + γ(m)

(23)≥ Γp.

This completes the proof of (24) and (25) and thus the proof of the lemma.

For each phase numberp, let θp := τmp be the time of the the first movementmp of Phasep. Beforecontinuing, we give lower and upper bounds onγp, the improvement of Phasep. For allp ≥ 1, we define

ηp := (α− 1) · S∗θp + β. (30)

Lemma 5.2. Letm be a movement of Phasep and letF ∗ = argminFSt(F ) be the optimal configuration at

timeτm. We then haveηp

χ(Fm−1, F ∗)≤ γ(m) ≤ ηp+1.

12

Proof. For the upper bound, observe that we have

γ(m) ≤ Sτm(Fm−1)− S∗τm

as clearly the service cost cannot be improved by a larger amount. Because at all timest, the algorithm keepsthe service cost belowαS∗

t + β, we haveSτm−1(Fm−1) < αS∗τm−1 + β ≤ αS∗

τm + β. The upper bound onγ(m) follows from (30) and becauseS∗

τm ≤ S∗θp+1

.For the lower bound onγ(m), we need to prove thatχ(Fm−1, F

∗) ≥ ηp/γ(m). Because the algorithmmoves a server at timeτm, we know thatSτm(Fm−1) ≥ αSτm(F

∗) + β and applying the Definition (30)of ηp, we thus haveSτm(Fm−1) − Sτm(F

∗) ≥ ηp. Intuitively, we haveχ(Fm−1, F∗) ≥ ηp/γ(m) because

the algorithm always chooses the best possible movement andthus every possible movement improves theoverall service cost by at mostγ(m). Thus, the number of movements needs to get fromFm−1 to an optimalconfigurationF ∗ has to be at leastηp/γ(m). For a formal argument, assume that we are given a sequence ofℓ := χ(Fm−1, F

∗) movements that transform configurationFm−1 into configurationF ∗. For i ∈ [ℓ], assumethat theith of these movements moves a server from nodeui to nodevi. Further, for anyi ∈ [ℓ] let fi be thenumber of servers at nodeui and letf ′i be the number of servers at nodevi before theith of these movements.Because the sequence of movements is minimal to get fromFm−1 to F ∗, we certainly havefi ≤ fui,m−1 andf ′i ≥ fvi,m−1. For the service cost improvementγ of theith of these movements, we therefore obtain

γ =(

σvi,τm(f′i)− σvi,τm(f

′i + 1)

)

−(

σui,τm(fi − 1)− σui,τm(fi))

(6)≤

(

σvi,τm(fvi,m−1)− σvi,τm(fvi,m−1 + 1))

−(

σui,τm(fui,m−1 − 1)− σui,τm(fui,m−1))

≤ γ(m).

The last inequality follows from (17),(18), and (22). As the sum of theℓ service cost improvements has to beat leastηp, we obtainℓ = χ(Fm−1, F

∗) ≥ ηp/γ(m) as claimed.

We can now lower bound the distribution of requests at the time of each movement.

Lemma 5.3. Letm be a movement of Phasep (for p ≥ 1). Then, there are integersψv ≥ 0 for all nodesv ∈ Vsuch that

∑

v∈V

ψv ≥ k +ηpγ(m)

and

∀t ≥ τm ∀v ∈ V : ψv > 0 =⇒ σv,t(ψv − 1)− σv,t(ψv) ≥ Γp−1.

Proof. It suffices to prove the statement fort = τm. For largert, the claim then follows from (7). Consider anoptimal configuration

F ∗ = (v, f∗v ) : v ∈ V at the timeτm of movementm. Let us further consider the configurationFm−1 of the algorithm immediatelybefore movementm. Consider a pair of nodesu andv such thatf∗u > fu,m−1 andfv,m−1 > f∗v . By theoptimality ofF ∗, we have

σu,τm(f∗u − 1)− σu,τm(f

∗u) ≥ σv,τm(fv,m−1 − 1)− σv,τm(fv,m−1). (31)

Otherwise, moving a server fromu to v would (strictly) improve the configurationF ∗. By Lemma5.1, we haveσv,τm(fv,m−1 − 1)− σv,τm(fv,m−1) ≥ Γp−1 for all nodesv for whichfv,m−1 > 0. Together with (31), for allv ∈ V for whichmax fv,m−1, f

∗v > 1, we obtain

σv,τm(max fv,m−1, f∗v − 1)− σv,τm(max fv,m−1, f

∗v ) ≥ Γp−1. (32)

13

To prove the lemma, it therefore suffices to show that∑

v∈V max fv,m−1, f∗v ≥ k + ηp/γ(m), as we can

then setψv := max fv,m−1, f∗v and (32) implies the claim of the lemma. By (3), we have

∑

v∈V

max fv,m−1, f∗v = k +

∑

v∈V

max 0, f∗v − fv,m−1 = k + χ(Fm−1, F∗).

We therefore need thatχ(Fm−1, F∗) ≥ ηp/γ(m), which follows from Lemma5.2.

In the next lemma, we derive a lower bound onS∗θp

, the service cost of optimal configuration when Phasep

starts. For each phasep ≥ 1, we first defineSp as follows.

Forp ≥ 3 : Sp :=

(

1 + (α− 1)γp−2

γp−1

)

· Sp−1 +γp−2

γp−1β, andS1 := S2 := 1. (33)

Lemma 5.4. For all p ≥ 1, we haveS∗θp

≥ Sp.

Proof. We prove the lemma by induction onp.

Induction Base (p = 1, 2): Using (20) we haveS∗θ1

≥ 1 and sinceS1 = S2 = 1, we getS∗θ2

≥ S∗θ1

≥ S2 =

S1.

Induction Step (p > 2): We use the induction hypothesis to assume that the claim of the lemma is true up toPhasep and we prove that it also holds for Phasep+ 1. Therefore by the induction hypothesis, for alli ∈ [p],

S∗θp ≥ Sp. (34)

For all i ∈ [p], we defineηi := (α − 1)Si + β andδi := maxηi+1

γi+1, · · · , ηpγp

. As a consequence of (30) and

(34), we get thatηi ≥ ηi for all i ∈ [p]. In the following, letp′ ∈ [2, p] be some phase. Lemma5.3implies thatafter the last movementm of Phasep′, there are non-negative integersψv (for v ∈ V ) such that

∑

v∈V ψv ≥k+ηp′/γp′ ≥ ηp′/γp′ and for all timest ≥ τm, for all v ∈ V for whichψv > 0, σv,t(ψv−1)−σv,t(ψv) ≥ Γp′−1.As there are onlyk servers for any feasible configurationF = (v, fv), we have

∑

v∈V fv = k and therefore∑

v∈V (ψv−fv) ≥ ηp′/γp′ . For anyv ∈ V for whichψv > fv, by using (6), we getσv,t(fv) ≥ (ψv−fv)Γp′−1.

Hence, after the last movement of Phasep′, for any feasible configurationF , we haveSt(F ) ≥ S∗t ≥ ηp′

γp′Γp′−1.

At the beginning of Phasep+ 1 (for p ≥ 2), the total optimal service cost therefore is

S∗θp+1

≥ maxp′∈[2,p]

ηp′

γp′Γp′−1 ≥ δp−1Γp−1 +

p−2∑

i=1

(δi − δi+1) · Γi =

p−1∑

i=1

γi · δi. (35)

We defineζi for all i ∈ [3, p] as follows:

ζi :=

i−2∑

j=1

γj · δj . (36)

Using the definition ofδi, we thus have

ζp+1 = ζp + γp−1δp−1 = ζp + ηpγp−1

γp.

Considering the definition ofηi we get

ζp+1 = ζp ·(

1 + (α− 1)γp−1

γp

)

+ β · γp−1

γp.

We therefore haveζp+1 = Sp+1 directly from (33) and thus the claim of the lemma follows.

14

In order to explicitly lower bound the optimal service cost after p phases, we need the following technicalstatement.

Lemma 5.5. Letℓ ≥ 2 be an integer and consider a sequencec1, c2, . . . , cℓ > 0 of ℓ positive real numbers andlet cmax = max

i∈[ℓ]ci andcmin = min

i∈[ℓ]ci. Further, letλ ≥ 0 be an arbitrary non-negative real number. We have

(I)ℓ∑

i=2

ci−1

ci≥ (ℓ− 1) ·

(

cmin

cmax

) 1

ℓ−1

,

(II)ℓ∏

i=2

(

1 + λci−1

ci

)

≥(

1 + λ

(

cmin

cmax

) 1

ℓ−1

)ℓ−1

.

Proof. The first part of the claim follows from the means inequality (the fact that the arithmetic mean is largerthan or equal to the geometric mean). In the following, we nevertheless directly prove both parts together. Weletx = (x1, . . . , xℓ) ∈ R

ℓ be a vectorℓ real variables and we define multivariate functionsf(x) : Rℓ → R andg(x) : Rℓ → R as follows:

f(x) :=

ℓ∑

i=2

xi−1

xiand g(x) :=

ℓ∏

i=2

(

1 + λxi−1

xi

)

.

We further defineX ⊂ Rℓ asX :=

(z1, . . . , zℓ) ∈ Rℓ | ∀i ∈ [ℓ] : cmin ≤ zi ≤ cmax

. We need to showthat forx ∈ X, f(x) andg(x) are lower bounded by the right-hand sides of Inequalities (I) and (II) above,respectively. Note thatX is a closed subset ofRℓ and becausecmin > 0, both functionsf(x) andg(x) arecontinuous when defined onX. The minimum forx ∈ X is therefore well-defined for bothf(x) andg(x).We show that bothf(x) andg(x) attain their minimum for

x∗ := (x∗1, . . . , x∗ℓ ), where∀i ∈ [ℓ] : x∗i = cmin ·

(

cmax

cmin

)i−1

ℓ−1

.

Note thatx∗ is the unique configurationx ∈ X to the following system of equations

x1 = cmin, xℓ = cmax, ∀i ∈ 2, . . . , ℓ− 1 : xi ∈xi−1

xi=

xixi+1

. (37)

Because we know thatminx∈X

f(x) = f(x∗) andminx∈X

g(x) = g(x∗), it is therefore sufficient to show that for

any y ∈ X that does not satisfy (37), f(y) and g(y) are not minimal. Let us therefore consider a vectory = (y1, . . . , yℓ) ∈ X that does not satisfy (37). First note that bothf(x) andg(x) are strictly monotonicallyincreasing inx1 and strictly monotonically decreasing inxℓ. If either y1 > cmin or yℓ < cmax, it is thereforeclear thatf(y) andg(y) are both not minimal (overX). Let us therefore assume thaty1 = cmin andyℓ = cmax.From the assumption thaty does not satisfy (37), we then have ani0 ∈ 2, . . . , ℓ− 1 for which

yi0−1

yi06= yi0

yi0+1

and thusyi0 6= √yi0−1yi0+1. We define a new vectory′ = (y′1, . . . , y

′ℓ) ∈ X as follows. We havey′i0 =√

yi0−1yi0+1 andy′i = yi for all i 6= i0 and we will show thatf(y′) < f(y) andg(y′) < g(y). Define

C :=∏

i∈[2,ℓ]\i0,i0+1

(

1 + λyi−1

yi

)

.

15

We then have

f(y)− f(y′) =

(

yi0−1

yi0+

yi0yi0+1

)

−(

yi0−1

y′i0+

y′i0yi0+1

)

g(y)− g(y′) =

[

(

1 + λyi0−1

yi0

)

·(

1 + λyi0yi0+1

)

−(

1 + λyi0−1

y′i0

)

·(

1 + λy′i0yi0+1

)

]

· C

=

[

(

yi0−1

yi0+

yi0yi0+1

)

−(

yi0−1

y′i0+

y′i0yi0+1

)]

· λC.

Note thatλ ≥ 0 andC > 0. In both cases, we therefore need to show that

∀yi0 ∈ [cmin, cmax] \√

yi0−1yi0+1

:

(

yi0−1

yi0+

yi0yi0+1

)

>

(

yi0−1

y′i0+

y′i0yi0+1

)

. (38)

This follows because the functionh : [cmin, cmax] → R, h(z) :=yi0−1

z + zyi0+1

is strictly convex forz ∈[cmin, cmax] and it has a stationary point atz =

√yi0−1yi0+1 ∈ [cmin, cmax].

As long as(α − 1)S∗θp< β, the effect of the(α − 1)S∗

θp-term onηp (and thus of theαS∗

t term in (2)) isrelatively small. Let us therefore first analyze how the service cost grows by just considering terms that dependsonβ (and not onα).

Lemma 5.6. For all p ≥ 3, we have

S∗θp ≥ min

β

α− 1, β · (p− 2) · (2k)−

1

p−2

.

Proof. Assume thatS∗θp< β/(α − 1) as otherwise the claim of the lemma is trivially true. By Lemma 5.4,

usingα ≥ 1, for all p ≥ 3, we getSp ≥ Sp−1 +γp−2

γp−1β. Plugging inS2 ≥ 0, induction onp therefore gives

S∗θp ≥ Sp ≥ β ·

p−1∑

i=2

γi−1

γi(39)

for all p ≥ 3. We defineγmin = min γ1, . . . , γp−1 andγmax = max γ1, . . . , γp−1. By Lemma5.2 andbecauseη1 ≤ · · · ≤ ηp−1, we haveγmin ≥ η1/k andγmax ≤ ηp. Fromα ≥ 1 and (30), we haveη1 ≥(α− 1) + β since we knowS∗

θp≥ 1 for p ≥ 1 regarding to (20). Further, we haveηp = (α− 1)S∗

θp+ β < 2β.

We therefore haveγmin ≥ [(α− 1) + β]/k andγmax < 2β and thus

γmin

γmax≥ (α− 1) + β

2kβ

(1)≥ max β, 1

2kβ≥ 1

2k.

The lemma now follows from (39) and from Inequality (I) of Lemma5.5.

On the other hand, as soon asS∗θp> max

1, βα−1

, the effect of theβ-term in (2) becomes relatively small.

As a second case, therefore, we analyze how the service cost grows by just considering terms that depends onα (and not onβ).

Lemma 5.7. Let p0 ≥ 2 be a phase for whichSp0 ≥ Sp0−1 ≥ S0 := max

1, βα−1

. For any phasep > p0,we have

S∗θp ≥ S0 ·

(

1 +

√α− 1

(2k)1

p−p0

)p−p0

≥ S02k

· αp−p0

2 .

16

Proof. By Lemma5.4, usingβ ≥ 0, for all p > p0, we getSp ≥(

1 + (α− 1)γp−2

γp−1

)

· Sp−1. Induction onp

therefore gives

S∗θp ≥ Sp ≥ Sp0 ·

p−1∏

i=p0

(

1 + (α− 1)γi−1

γi

)

(40)

for all p ≥ p0. Similarly to before, we defineγmin = min γp0−1, . . . , γp−1 andγmax = max γp0−1, . . . , γp−1.By Lemma5.2, the assumptions regardingp0, and because the valuesηi are non-decreasing ini, we have

γmin ≥ ηp0−1

k≥ max (α− 1) + β, 2β

kand

γmax ≤ ηp ≤ (α− 1)S∗θp + β ≤ 2(α − 1)S∗

θp .

The last inequality follows becauseS∗θp

≥ Sp ≥ Sp0 ≥ max

1, βα−1

and by applying (1). We can now applyInequality (II) from5.5to obtain

S∗θp ≥ Sp ≥ Sp0 ·

(

1 + (α − 1)

(

γmin

γmax

)1

p−p0

)p−p0

≥ Sp0 ·

1 + (α− 1)

(

max (α− 1) + β, 2β2k(α − 1)S∗

θp

) 1

p−p0

p−p0

. (41)

In the following, assume that

S∗θp ≤ max

1,β

α− 1

αp−p0

2 . (42)

Note that if (42) does not hold, the claim of the lemma is trivially true. By replacingS∗θp

on the right-hand sideof (41) with the upper bound of (42), we obtain

S∗θp ≥ Sp ≥ Sp0 ·

1 + (α− 1) ·

(α − 1) + β

2k(α − 1)max

1, βα−1

αp−p0

2

1

p−p0

p−p0

≥ Sp0 ·(

1 +α− 1

(2k)1

p−p0

√α

)p−p0

≥ Sp0 ·(

1 +

√α− 1

(2k)1

p−p0

)p−p0

≥ Sp0

2k· α

p−p02 .

The lemma then follows because we assumed thatSp0 ≥ max

1, βα−1

.

5.3.2 Optimal Offline Algorithm Total Cost

Service Cost: In order to minimize the service cost, we can simply bound theservice cost ofO as follows

SOθp ≥ S∗

θp .

Movement Cost: To simplify our analysis, we take no notice of movement cost by optimal offline algorithmsince it has no substantial effect on the competitive factorwe will provide sinceO has to pay at least the optimalservice cost which we show it is large enough. The total cost of optimal offline algorithm, therefore, is boundedas follows

CostOθp =MO

θp + SOθp ≥ S∗

θp . (43)

17

5.3.3 Online Algorithm Total Cost

Service Cost: The online algorithm like any other algorithm has to keep theservice cost smaller than a linearfunction of optimal service cost as mentioned in (2). In other words, the configuration of servers at any timehas to be feasible as defined in Section2. Thus

SAθp < αS∗

θp + β. (44)

Movement Cost: First, using Definition5.1we bound the number of movement in each phase.

Observation 5.8. For each Phasep ≥ 1, we haveλp ≤ k.

Proof. As an immediate consequence of Definition5.1, we obtain that the maximum number of movements ineach phase is at mostk. Letm > mp and consider the movements[mp,m]. We prove that ifm < mp+1, notwo the movements in[mp,m] move the same server. The claim then follows because there are onlyk servers.For the sake of contradiction, assume that there is some server i that is moved more than once and letm′ andm′′ (m′,m′′ ∈ [mp,m],m′ < m′′) be the first two movements in[mp,m], where serveri is moved. We clearlyhavevdstm′ = vsrcm′′ and Def.5.1 thus leads to a contradiction to the assumption thatm < mp+1.

As a result of above observation and Lemma5.6and Lemma5.7, it is possible to prove the following lemmato bound the number of online algorithm movements by means ofoptimal service cost.

Lemma 5.9. For anyα ≥ 1 andβ satisfying(1), there is a deterministic online algorithmA, such that for alltimest ≥ 0, the total movement costMA

t is bounded as follows.

• If α = 1, for anyℓ ≥ 1, ε > 0, andβ ≥ k(2k)1/ℓ/ε, we have

MAt ≤ ε · S∗

t +O(ℓk).

• For α ≥ 1 + ε whereε > 0 is some constant and anyβ satisfying (1), we have

MAt ≤ k ·O

(

1 + logα S∗t +min

log k

log log k, logα k

+ logαk

1 + β

)

.

Proof. First note that by Observation5.8, the movement cost of our algorithm by timeθp is at most

Mθp ≤ (p − 1)k + 1 ≤ pk. (45)

Together with the lower bounds onS∗θp

of Lemmas5.6 and5.7, this allows to derive an upper bound on themovement cost of our algorithm as a function ofS∗

θp. Note that as all upper bound claimed in the lemma have

an additive term ofO(k) (with no specific constant), it is sufficient to prove that thelemma holds for all timet = θp, wherep ≥ 2 is a phase number.

Let us first consider the case whereα = 1. Because in that caseβ/(α − 1) is unbounded, we can onlyapply Lemma5.6 to upper bound the movement cost as a function ofS∗

t . We chooseℓ ≥ 1 and assume thatβ ≥ k(2k)1/ℓ/ε for ε > 0. Together with (45), for p ≥ ℓ+ 2, Lemma5.6then gives

S∗θp ≥ k(2k)

1

ℓ

ε· (p− 2) · (2k)− 1

ℓ =k

ε(p − 2) ≥ 1

ε(Mθp − 2k). (46)

The first part of lemma5.9 then follows because the total movement cost for the firstℓ + 2 phases is at mostO(ℓk). The special cases are obtained as follows. Forβ = Ω(k + k/ε), we setℓ = Θ(log k) and everyε > 0,whereas forβ = Ω(k log k/ log log k), we setε = Θ(log log k/ log1−δ k) andℓ = Θ

(

1δ ·

log klog log k

)

for constant0 < δ ≤ 1.

18

Let us therefore move to the case whereα > 1. Let p0 be the first phasep0 ≥ 2 for which S∗θp0

≥ S0,

whereS0 = max

1, βα−1

as in Lemma5.7. Further, we setp1 = p0 + ⌈2 logα(2k)⌉. Using Lemma5.7, forp ≥ p1, we have

Sθp ≥ S02k

· αp−p1

2 αp1−p0

2 ≥ S0 · αp−p1

2 .

We therefore get

Mθp ≤ k · p ≤ k

(

p1 + 2 logαS∗θp

S0

)

≤ k

(

p0 + 1 + 2 logα S∗θp + logα

2k

S0

)

.

The second claim of lemma5.9then follows by showing that

p0 = O(

min log k

log log k, logα k

)

.

If S0 = 1, we havep0 = 2. Otherwise, we can apply Lemma5.6 to upper boundp0 as the smallest valuep0for which β

α−1 = β(p− 2)(2k)−1/(p−2). Forα = O( log klog log k

)

, the assumption thatα is at least1 + ε for some

constantε > 0 gives thatp0 = Θ( log klog log k

)

. Otherwise, (i.e., for largeα), we obtainp0 = Θ(logα−1 k) =Θ(logα k).

Note that by choosingα > 1, the dependency of the movement costMAt on the optimal service costS∗

t is

only logarithmic because termsmin

log klog log k , logα k

andlogαk

1+β are dominated bylog k.

Proof of Theorem 3.2. Putting(43), (44), and Lemma5.9all together conclude the claim of theorem.

5.4 Lower Bound

The aim of this section is to prove our lower bound theorem stated in Section3. As discussed in Section3, thelower bound even holds for a natural special case where each nodev ∈ V can only have either0 or 1 servers.

Assume that we are given parametersα ≥ 1 andβ such that (1) holds and an algorithmA which guaranteesthat (2) remains satisfied at all timest. In the following, letO be any optimal offline algorithm. GivenA, weconstruct an execution in whichA has to perform a large number of movements while the optimal service costdoes not grow too much. Analogously to the analysis of the upper bound, we divide time into phases such thatin each phase,A has to moveΩ(k) servers and the optimal service cost grows as slowly as possible. Forpphases, we define a sequence of integersk/3 ≥ n1 ≥ n2 ≥ . . . np ≥ 1 and valuesΓ1 < Γ2 < · · · < Γp. In thefollowing, let v be a free node ifv does not have a server. Roughly, at the beginning of a phasei, we choose asetNi of ni (ideally) free nodes and make sure that all these nodes haveΓi requests. Note that constructing anexecution means to determine where to add the request in eachiteration. The valueΓi is chosen large enoughsuch that throughout phasei a service cost ofniΓi is sufficiently large to force an algorithm to move. Hence,whenever there areni free nodes withΓi requests,A has to move at least one server to one of these nodes.For each such movement, we pick another free node that currently has less thanΓi requests and make sure ithasΓi requests. We proceed until there arek nodes withΓi requests at which point the main part of the phaseends. Except for the nodes inNi, each of thek nodes withΓi requests leads to a movement ofA and therefore,A has to move at leastk − ni = Ω(k) servers in phasei. At the end of phasei, we can guarantee that thereare exactlyk nodes withΓi requests,ni nodes withΓi−1 requests,ni−1 − ni nodes withΓi−2 requests, etc.Assuming that for allv, σv(x, y) = (1 − x)y, we can then compute the optimal service cost after phasep asnpΓp−1+

∑pi=3(ni−1−ni)Γi−2. The service cost paid byA at timet can not be smaller thanS∗

t . By contrast,the optimal offline algorithm moves at mostni−1−ni+1 times in each phasei > 1 (in the first phase it movesjust once) and at mostnp at the end of the last phase to locate its servers in the optimal configuration. Therefore

19

by the end of phasep, O has to pay at mostO(n1+p) as the total movement cost. If we choosep ≥ k, the totalmovement cost paid byO isO(p) by end of phasep, while the online algorithm has to payΘ(pk) in total bythis time. The service cost ofO equals the optimal service cost at the end of phasep. By choosing the valuesni appropriately, we obtain the claimed bounds.

5.4.1 Lower Bound Execution

We needn to be sufficiently large, for simplicity assume thatn ≥ 3k. As we can assume that each node eitherhas0 or 1 server, we slightly overload notation and simply denote a feasible configuration by a setF ⊂ V ofsize|F | = k. Further, we assume all servers are at the same locations at the beginning (i.e.t = 0) without lossof generality. At each pointt in the execution, an optimal configurationF ∗

t places servers at thek nodes withthe most requests (breaking ties arbitrarily if there are several nodes with the same number of requests). Also,at a timet the optimal service cost is equal to the total number of requests at nodes inV \ F ∗

t for an arbitraryoptimal configurationF ∗

t .Time is divided into phases. We construct the execution suchthat it lasts for at leastk phases. As described

in the outline, we define integersΓ1 < Γ2 < . . . such that at the end of phasei, there are exactlyk nodes withΓi requests (and all other nodes have fewer requests). For eachphasei, we defineVi to be this set ofk nodeswith Γi requests. We also fix integersk/3 ≥ n1 ≥ n2 ≥ · · · ≥ 1 and at the beginning of each phasei, we picka setNi of ni nodes to which we directly add requests so that all of them have exactlyΓi requests. Fori = 1,we pickN1 as an arbitrary subset ofV \ F0. We defineV0 := F0. For i ≥ 2, we chooseNi as an arbitrarysubset ofVi−2 \ Vi−1. Clearly, at the end of phasei, we haveNi ⊆ Vi as otherwise there would be more thank nodes with exactlyΓi requests. Note that becauseNi−1 ⊆ Vi−1 and becauseNi−1 ∩ Vi−2 = ∅, Vi−2 \ Vi−1

containsni−1 ≥ ni nodes and it is therefore possible to chooseNi as described. Note also that becauseNi ⊆ Vi−2 \ Vi−1, at the beginning of phasei all nodes inNi have exactlyΓi−2 requests. The remaining onesof thek nodes that end up inVi (and thus haveΓi requests at the end of phasei) are chosen among the nodesin Vi−1. Consequently, at the end of phasei− 1 and thus at the beginning of phasei, there are exactlyk nodesVi−1 with Γi−1 requests,ni−1 nodesVi−2 \Vi−1 with Γi−2 requests,ni−2−ni−1 requestsVi−3 \(Vi−2∪Ni−1)with Γi−3 requests,ni−3 − ni−2 nodes withΓi−4 requests, and so on. Now,ni of the nodes inVi−2 \ Vi−1 arechosen as setNi and we increase their number of requests toΓi. From now on, throughout phasei, there arek + ni nodes with at leastΓi−1 requests such that at mostk of these nodes haveΓi requests. The number ofnodes with less thanΓi−1 requests is the same as at the end of phasei−1. In fact nodes that are not inVi−1∪Ni

do not change their number of requests after phasei − 1. As a consequence of the execution, after increasingthe number of requests inNi to Γi, the optimal service cost remains constant throughout phase i ≥ 1 and it canbe evaluated to

Σ∗i := ni · Γi−1 +

i−1∑

j=2

(nj − nj+1)Γj−1.

For convenience, we also defineΣ∗0 := 0 and moreoverΣ∗

1 = 0 since there are at mostk nodes withΓ1 requestsat the end of phase1.

In the following, letv be a free node at some point in the execution, if the algorithmcurrently has no serverat nodev. We now fix a phasep ≥ 1 and assume that we are at a timet, when we have already picked the setNp and increased the number of requests of nodes inNp to Γp. By the above observation, we haveS∗

t = Σ∗p

and thereforeA is forced to move if there arenp free nodes withΓp requests and if we chooseΓp such that

γp := Γp − Γp−1 =(α− 1)Σ∗

p + β

np. (47)

We can now describe how and when the remainingk−np nodes ofVp are chosen after picking the nodes inNp.As described above, the nodes are chosen fromVp−1. We choose the nodes sequentially. Whenever we choosea new node fromVp, we pick some free nodev ∈ Vp−1 with less thanΓp requests and increase the numberof requests ofv to Γp. As described above,Γp is chosen large enough (as given in (47)) such that throughout

20

phasep there are never more thannp − 1 free nodes withΓp requests. Because|Np ∪ Vp−1| = k + np, as longas there are at mostk nodes withΓp requests there always needs to be a free nodev ∈ Vp−1 that we can pickand we actually manage to addk nodes toVp.

5.4.2 Online Algorithm Total Cost

The service cost paid byA at any timet could be simply lower bounded byS∗t . Hence, it remains to compute a

lower bound forMAt as a function of optimal service cost. The following lemma computes such a lower bound.

Lemma 5.10. For anyα ≥ 1 andβ satisfying(1), assumeA be any deterministic online algorithm that cansolve the problem. There exists a timet > 0 such that the execution of Section5.4.1 guarantees the totalmovement costMA

t can be bounded as follows.

• If α = 1, for anyℓ ≥ 1, ε > 0, andβ ≤ k(2k)1/ℓ/ε, we have

MAt = ε · S∗

t +Θ(ℓk).

Specifically, forβ = O(k + k/ε) we getMAt = ε · S∗

t + Θ(k log k) and forβ = O( k log klog log k

)

we have

MAt = ε · S∗

t +Θ( k log klog log k

)

.

• For α ≥ 1 + ε whereε > 0 is some constant and anyβ satisfying (1), we have

MAt = k ·Θ(1 + logα S

∗t ) .

Proof. Let us count the number of movements ofA in a given phasep. At each point in timet during thephase, letΦt be the number of free nodes withΓp requests (possibly including a nodev that we already choseto be added toVp). We know that for allt, Φt < np. Whenever we decide to add a new nodev to Vp, Φt

increases by1 (asv is a free node). The value ofΦt can only decrease whenA moves a server and each servermovement reduces the value ofΦt by at most1. As after fixingNp, we addk−np nodes toVp, we need at leastk − 2np ≥ k/3 movements to keepΦt belownp throughout the phase. Consequently, every online algorithmA has to do at leastk/3 movements in each phase.

Now we upper bound the optimal service costΣ∗p as a function ofα, β, andp. Using (47), for all p ≥ 0, we

have

Σ∗p =

p∑

i=1

np · γp−1

Forp ≥ 1, we then get

Σ∗p =

npnp−1

(

(α− 1)Σ∗p−1 + β

)

+Σ∗p−1

=

(

1 + (α− 1)npnp−1

)

· Σ∗p−1 + β · np

np−1.

(48)

In the following, we for simplicity assume that fori = 1, 2, . . . , p, valuesni do not have to be integers. Forintegerni, the proof works in the same way, but becomes more technical and harder to read. We fix the valuesof ni as

ni := (k/3)p−i

p−1

such thatn1 = k/3 andnp = 1. For alli ≥ 1, we then have ni

ni−1 = (k3 )− 1

p−1 . Equation (48) now be simplifiedas

Σ∗p =

(

1 +α− 1

(k/3)1/(p−1)

)

· Σ∗p−1 + β · 1

(k/3)1/(p−1). (49)

We have already seen thatS∗t = Σ∗

p. Using (49) and (33), the claim of the first part of the lemma followsanalogously from Lemma5.4and Lemma5.6and the claim of the second part of the lemma follows analogouslyfrom Lemma5.4and Lemma5.7in the upper bound analysis section.

21

5.4.3 Optimal Offline Algorithm Total Cost

First we specify a specific offline algorithmA and compute its total cost. It is obvious that

CostOt ≤ Cost

At (50)

for every timet. The offline algorithmA knows the request sequence in advance as well as everything aboutA in order to answer each request. When AlgorithmA moves a server, it always moves a server from a nodewith a minimum number of requests to a node with a maximum number of requests (among the nodes whereA did not have a server before the movement). We show that Algorithm A always satisfies (2) and that thenumber of movements is sufficiently small.

Offline Algorithm A : With respect to the execution described in Section5.4.1, at the beginning of the firstphase, the offline algorithm moves one server from(FA

t0 \ V1) to a node in(V1 \ FAt0 ). For i ≥ 2, at the

beginning of each phasei, it moves all servers located at nodes in(FAti−1

\ Vi) that have less thanΓi−1 requests

to some nodes in(Vi \ FAti−1

). Further, among the servers located at nodes in(FAti−1

\ Vi) and which haveΓi−1

requests, AlgorithmA moves as few servers as possible to nodes in(Vi \FAti−1

) such that the number of nodeswith Γi requests and without servers (ofA ) becomes less thanni. At the end of the execution, the offlinealgorithm moves all its servers to the locations of an optimal configuration. Therefore, the service cost paid bythe offline algorithm at the end of the execution equals the optimal service cost, i.e.,

SAtp = S∗

tp . (51)

Correctness of the Offline Algorithm A : We show that the offline algorithmA keeps (2) satisfied at all

times. Regarding to the algorithm, at the end of each phasei ≥ 1 we havexi < ni nodes in(Vi \ FAti ).

Moreover,xi servers ofA that are in(FAti \ Vi) are at nodes withΓi−1 requests. Therefore we have

SAti ≤ xi · Γi + S∗

ti − xi · Γi−1

= xi · (Γi − Γi−1) + S∗ti

(47)=

(α− 1) · S∗ti + β

ni/xi+ S∗

ti

xi<ni

< α · S∗ti + β.

Since the offline algorithm moves its servers at the beginning of phasei, at all times within phasei, Condition(2) remains satisfied.

The following lemma shows that the number of movements by theoffline algorithmA is at mostk/3 + pwherep is the number of phases of the execution provided in Section5.4.1.

Lemma 5.11.For anyα ≥ 1 andβ satisfying(1), the execution of Section5.4.1consisting ofp phases provides

MAt <

k

3+ p,

wheret is the ending time of phasep.

Proof. Let ti denote the ending time of phasei. The following claim guarantees that the number of movementsat each iterationi for A to keep (2) satisfied is sufficiently small. More specifically, at the beginning of phasei, the offline algorithm moves in two steps. The first step is when it moves its servers from the nodes with lessthanΓi−1 requests. The first part of the following claim guarantees that the number of these movements is atmostni−1−ni. The second step is done when all servers ofA are at the nodes with eitherΓi orΓi−1 requests.The second part of the following claim indicates that after the first step is done by the offline algorithm, thereremain at mostni nodes withΓi requests and without any server of the offline algorithm.

22

Claim 5.12. For i ≥ 2,

(1) |FAi−1 \ (Vi−1 ∪ Vi)| ≤ ni−1 − ni.

(2) |Vi \ FAi−1| ≤ |FA

i−1 \ (Vi−1 ∪ Vi)|+ ni.

Proof. At the end of phase(i − 1), for i ≥ 2, we haveni−1 = |Vi−2 \ Vi−1| where each of the nodesin (Vi−2 \ Vi−1) hasΓi−2 requests. Assumewi of them are with the servers of the offline algorithm.Therefore,(k − wi) of the nodes inVi−1 are with the servers ofA . During phasei, a set ofNi ⊆(Vi−2 \ Vi−1) is chosen (|Ni| = ni) and the number of requests at them increased toΓi. There are twocases: eitherni ≤ (ni−1 − wi) or ni > (ni−1 − wi). In both cases, there are at most(ni−1 − ni) nodeswith Γi−2 requests that are with servers of the offline algorithm. Hence, the first part of the claim holds.

As already described, there are(k − wi) nodes in(FAti−1

\ Vi−1). With respect to the execution, therequests at(k−ni) nodes inVi−1 increased toΓi since the execution has to guarantee that there are exactlyk nodes withΓi requests at the end of phasei. Hence, at mostwi nodes inVi−1 can haveΓi requests whileare without any server ofA . If ni > (ni−1−wi) then we have at mostni−1 nodes in(Vi \FA

i−1) in whichat most(ni−1 − wi) of them are among the nodes in(Vi−2 \ Vi−1). Since the number of nodes withΓi−2

requests with servers of the offline algorithm is at most(ni−1 − ni), therefore the second part holds forthis case. Otherwise, ifni ≤ (ni−1 − wi) then we have at most(ni + wi) nodes in(Vi \ FA

i−1) in whichat mostni of them are among the nodes in(Vi−2 \ Vi−1). Since the number of nodes withΓi−2 requestswith servers of the offline algorithm is at mostwi, hence the second part holds as well for this case.

At the beginning of the first phase, the offline algorithm moves one server. Fori ≥ 2, it follows from tothe offline algorithm description and the first part of the Claim 5.12that the offline algorithm moves at most(ni−1−ni) times at the beginning of each phasei. Therefore using the second part of the claim, the number ofnodes withΓi requests and without any server ofA is at mostni. If it is strictly less thanni thenA does notmove anymore due to the description of the offline algorithm.Otherwise, the number of nodes withΓi requestsand without any server ofA isni after moving the servers in(FA

i−1 \(Vi−1∪Vi)). This implies that the numberof nodes withΓi−1 requests and with servers ofA is ni. Hence, the offline algorithm needs to move only oneserver that is located at a node withΓi−1 requests to a node withΓi requests and without any server of theoffline algorithm to keep the number of nodes withΓi requests and without any server ofA belowni. At theend of the execution that is the end of phasep, the number of nodes withΓp−1 requests and with servers ofA is at most(np − 1) because the number of nodes in(Vp \ FA

tp ) is less thannp. Thus, as described in thealgorithm, the offline algorithm moves at most(np − 1) times to locate its all servers at the nodes with optimalservers inF ∗

tp so that provides the optimal total service cost. Consequently, the total number of movements byA is at most

1 +

(

p∑

i=2

(ni−1 − ni + 1)

)

+ (np − 1)n1≤k/3

≤ p− 1 +k

3.

Corollary 5.13. With respect to(50), (51), and the Lemma5.11we can get

CostOt ≤ Cost

At ≤ S∗

t +4 · p3.

sincep ≥ k andt is the ending time of the execution.

Proof of Theorem 3.3. By Lemma5.10and the Corollary5.13the claim of the theorem holds.

23

6 Future WorkA possible way to extend the work of this paper could be to study an online version of MFLP [11] (OMFLP). In[4], it is shown that exploiting the randomized low-stretch hierarchical tree decomposition of [9], it is possible toobtain a polylogarithmic competitive ratio for thek-server problem. Combined with the general cost functionsstudied in the present paper, a similar approach could work for OMFLP. On each level of the hierarchicaldecomposition, the cost of each subtree can potentially be modelled using a cost function similar to what weuse in the present paper. Note that the lower bound of Theorem3.3 already applies to OMFLP, even for auniform underlying metric. Another natural direction would be to study randomized online algorithms forminimizing the movements in our model against an oblivious adversary.

References[1] S. Ahmadian, Z. Friggstad, and C. Swamy. Local-search based approximation algorithms for mobile facil-

ity location problems. InProceedings of the 24th Annual ACM-SIAM Symposium on Discrete Algorithms(SODA), pages 1607–1621, 2013.

[2] S. Arora, E. Hazan, and S. Kale. The multiplicative weights update method: a meta-algorithm and appli-cations.Theory of Computing, 8(1):121–164, 2012.

[3] V. Arya, N. Garg, R. Khandekar, A. Meyerson, K. Munagala,and V. Pandit. Local search heuristics fork-median and facility location problems.SIAM Journal on Computing, 33(3):544–562, 2004.

[4] N. Bansal, N. Buchbinder, A. Madry, and J. S. Naor. A polylogarithmic-competitive algorithm for thek-server problem. InProceedings of the 52nd Annual IEEE Symposium on Foundations of ComputerScience (FOCS), pages 267–276, 2011.

[5] J. Byrka and K. Aardal. An optimal bifactor approximation algorithm for the metric uncapacitated facilitylocation problem.SIAM Journal on Computing, 39(6):2212–2231, 2010.

[6] M. Charikar, C. Chekuri, T. Feder, and R. Motwani. Incremental clustering and dynamic informationretrieval. InProceedings of the 29th Annual ACM Symposium on Theory of computing (STOC), pages626–635, 1997.

[7] E. D. Demaine, M. Hajiaghayi, H. Mahini, A. S. Sayedi-Roshkhar, S. Oveisgharan, and M. Zadimoghad-dam. Minimizing movement.ACM Transactions on Algorithms (TALG), 5(3):30, 2009.

[8] Z. Drezner and H. W. Hamacher.Facility Location: Applications and Theory. Springer Science &Business Media, 2004.

[9] J. Fakcharoenphol, S. Rao, and K. Talwar. A tight bound onapproximating arbitrary metrics by treemetrics. InProceedings of the 35th Annual ACM Symposium on Theory of computing (STOC), pages448–455, 2003.

[10] D. Fotakis. Online and incremental algorithms for facility location. ACM SIGACT News, 42(1):97–131,2011.

[11] Z. Friggstad and M. R. Salavatipour. Minimizing movement in mobile facility location problems.ACMTransactions on Algorithms (TALG), 7(3):28, 2011.

[12] S. Guha and S. Khuller. Greedy strikes back: improved facility location algorithms. InProceedings ofthe 9th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 649–657, 1998.

[13] M. T. Hajiaghayi, M. Mahdian, and V. S. Mirrokni. The facility location problem with general costfunctions.Networks, 42(1):42–47, 2003.

24

[14] K. Jain, M. Mahdian, E. Markakis, A. Saberi, and V. V. Vazirani. Greedy facility location algorithmsanalyzed using dual fitting with factor-revealing LP.Journal of the ACM (JACM), 50(6):795–824, 2003.

[15] E. Koutsoupias and C. H. Papadimitriou. On the k-serverconjecture. Journal of the ACM (JACM),42(5):971–983, 1995.

[16] N. Littlestone and M. K. Warmuth. The weighted majorityalgorithm. Information and computation,108(2):212–261, 1994.

[17] M. S. Manasse, L. A. McGeoch, and D. D. Sleator. Competitive algorithms for server problems.Journalof Algorithms, 11(2):208–230, 1990.

[18] A. Meyerson. Online facility location. InProceedings of the 42nd IEEE Symposium on Foundations ofComputer Science (FOCS), page 426, 2001.

[19] S. Shalev-Shwartz. Online learning and online convex optimization.Foundations and Trends in MachineLearning, 4(2):107–194, 2011.

[20] D. D. Sleator and R. E. Tarjan. Amortized efficiency of list update and paging rules.Communications ofthe ACM, 28(2):202–208, 1985.

25