Carrying Umbrellas: An Online Relocation Problem on Graphs

Transcription

1 Carrying Umbrellas: An Online Relocation Problem on Graphs Jae-Ha Lee, Chong-Dae Park, and Kyung-Yong Chwa Dept. of Computer Science, KAIST, Korea Abstract. We introduce an online relocation problem on a graph, in which a player who walks around the nodes makes decisions on whether to relocate mobile resources, while not knowing the future requests. We call it Carrying Umbrellas. This paper gives a necessary and sufficient condition under which a competitive algorithm exists and describes an optimal algorithm and anaylzes its competitve ratio. We also extend this problem to the case of digraphs. 1 Introduction To carry an umbrella or not? This is an everyday dilemma. To illustrate some of our concepts, we describe a detailed scenario. Picture a person who walks around N places. At each place, he is told where to go next and then must go there. As a usual person, he dislikes being caught in the rain without umbrellas. Since today s weather forecast is correct, he knows if it will be rainy today. However, he does not know the future destinations and weathers, which might be controlled by a malicious adversary. We say a person is safe if he never get wet. There is a trivial safe strategy: Always carry an umbrella. However, carrying an umbrella in sunny days is annoying and stupid. As an alternative, he placed several umbrellas in advance and thinks about an efficient strategy; he hopes, through some cleverness, to minimize the number of days he carries umbrellas. By adopting the competitive analysis [8], we say a person s strategy is competitive if he carries umbrellas in a small number of days (for details, see Subsection 1.1). The following questions are immediate: 1. What is the minimum number of umbrellas with which the person can be safe and competitive? (For example, is placing one umbrella per place sufficient?) 2. What is a safe and competitive strategy? We formally define the problem next. 1.1 A Game Let G =(V,E) be a simple undirected graph with N vertices and M edges. (An extension to digraphs is straightforward and considered only in Section 5.) An integer u(v) is associated with each vertex v V, indicating the number of Supported in part by KOSEF grant A. Aggarwal, C. Pandu Rangan (Eds.): ISAAC 99, LNCS 1741, pp , c Springer-Verlag Berlin Heidelberg 1999

2 196 J.-H. Lee, C.-D. Park, and K.-Y. Chwa umbrellas placed on the vertex v. We use u(g) to represent the total number of umbrellas in G. Consider an on-line game between a player and the adversary, assuming that u(g) is fixed in advance. Game Carrying-Umbrellas(G, u(g)) 1. Initialization Player determines the initial configuration of u(g) umbrellas; Adversary chooses the initial position s V of Player; 2. for i =1to L do (a) Adversary specifies (v, w), where w is a boolean value and v V is adjacent to the current vertex of Player; (b) Player goes to v; Ifw =1, he must carry at least one umbrella; As an initialization, it is assumed that the player first determines the initial configuration of u(g) umbrellas and later the adversary chooses the initial position s V of the player, although our results described in the sequel also hold even if the initialization is done in reverse order. A play consists of L phases, where L is determined by the adversary and unknown to the player. In each phase, the adversary gives a request (v, w), where v is adjacent to the current vertex of the player and w is a boolean value indicating the weather; w = 1 indicates that it is rainy, and w =0 sunny. For this request (v, w), the player must go to the specified vertex v and decide whether to carry umbrellas or not. If w =1, he must carry at least one umbrella; Only in sunny days, he may or may not carry umbrellas. Notice that the player can carry an arbitrary number of umbrellas, if available. The player loses if he cannot find any umbrella at the current vertex in a rainy phase. A strategy of the player is said to be safe if it is guaranteed that whenever w =1 the player carries at least one umbrella. Moreover, a strategy of the player should be efficient. As a measure of efficiency, we adopt the competitive ratio [8], which has been widely used in analyzing the performance of online algorithms. Let σ =σ 1 σ L be a request sequence of the adversary, where σ i =(v i, w i ) is the request in i-th phase. The cost of a strategy A for σ, written C A (σ), is defined as the number of phases in which the player carries umbrellas by the strategy A. Then, C A (σ) C Opt (σ) the competitive ratio of the strategy A is where Opt is the optimal offline strategy. (Since Opt knows the entire σ in advance, it pays the minimum cost. However, Opt cannot be implemented by any player and is used only for comparison.) A strategy whose competitive ratio is bounded by c is termed c- competitive; it is simply said to be competitive, ifitisc-competitive for some bounded c irrespective of the length of σ. The player wins, if he has a safe and competitive strategy; he loses, otherwise. Not surprisingly, whether the player has a winning strategy depends on the number of umbrellas. In this paper, we are interested in it. Definition 1 ForagraphG, we define u (G) to be the minimum number of umbrellas with which the player has a winning strategy in G.

3 Carrying Umbrellas: An Online Relocation Problem on Graphs Summary of Our Results Let G =(V,E) be a simple graph (having no parallel edges) with N vertices and M edges. We show that u (G)=M +1. That is, no strategy of the player is safe and competitive if u(g) <M+1 (Section 3) and there exists a competitive strategy of the player if u(g) M +1 (Section 4). The competitive ratio of our strategy is b(g), the number of vertices in the largest biconnected component in G. Moreover, the upper bound is attained by a weak player that carries at most one umbrella in a phase, and the competitive ratio b(g) is optimal for some graphs when u(g)=m +1. Finally, we extend this problem to the case of digraphs (Section 5). Interestingly, u (G) of a digraph G seems to be closely related with a structure of G. We present a general upper and lower bound on u (G), which is naturally reduced to M + 1 in undirected graphs. 1.3 Related Works Every online problem can be viewed as a game between an online algorithm and the adversary[7,3,6,5]. In this prospect, Ben-David, et al. [3] introduced requestanswer game as a general model of online problems. Clearly, the problem of the present paper is an example of the request-answer game. Many research works, though not directly related with our problem, have studied online problems on a graph. Such examples include the k-server problem [1], graph coloring [2,4]. 2 Lower Bound This section describes the lower bound on u (G). For a simple explanation, we first consider a weak player that can carry at most one umbrella in a phase, and showed that u (G) M +1 for the weak player. Later the same bound is extended to the general player that can carry multiple umbrellas. Theorem 1. Let G be a simple graph (with no parallel edges) with N vertices and M edges. Under the constraint that the player can carry at most one umbrella in a phase, u (G) M +1. Proof. Assume that G is connected (otherwise, the number of umbrellas in some connected component of G is no larger than the number of edges in it, and our proof can be applied to it). We show that if u(g) M then no strategy of the player is safe and competitive in G. Equivalently, it suffices to show that any safe strategy of the player is not c-competitive, for any fixed c (< ). For convenience, imagine we are the adversary that would like to defeat the player. Let σ = σ 1 σ 2 σ L denote a request sequence that we generate. Recall that the starting vertex s of the player is determined by the adversary; We choose an arbitrary vertex as s. Suppose we were somehow able to make the player lie in s so that u (s) becomes d+1, where d is the degree of s in G. This would tell us that G {s} is deficient in umbrellas, that is, u(g {s}) is strictly less than the number of

4 198 J.-H. Lee, C.-D. Park, and K.-Y. Chwa edges in G {s}. In the next step, we make the player go into G {s}. Evenif the player has carried an umbrella, u(g {s}) is no larger than the number of edges in G {s}, and the player is in it. Now we use recursion: We make the player not safe and competitive in G {s}. (In fact, some cautions are needed to make the entire competitive ratio unbounded.) So our subgoal is to make u(s) increase to d+1. Let v 1,,v d be the adjacent vertices of s and let C 1,,C d denote the maximal connected components in G {s} such that C i includes v i. Of course, C i happen to be equal to C j even when i j. Let u(c k ) denote the number of umbrellas placed in C k. Observe that if G {s} is deficient in umbrellas, then some component C k also is. We begin with explaining how to increase u(s). Suppose that at the start of (2i 1)-th phase, the player is located at s and u(s)=j. In subsequent two phases, the adversary makes the player go to v j and return to s. That is, σ 2i 1 = (v j, sunny) and σ 2i =(s, w 2i ). The 2i-th weather w 2i is determined according to the player s decision in (2i 1)-th phase; If the player carried an umbrella in (2i 1)-th phase, w 2i is set to sunny; Otherwise rainy. The strategy of the adversary is summarized below. The first and second if parts are the generation of σ 2i 1 and σ 2i, and the last if part is to check whether deficient C k exists. If it exists, the recursive procedure Adversary(C k,v k ) is called. Remember that if u(s) becomes d+1, deficient C k exists and the recursive procedure starts. Adversary(G, s) i =1; while TRUE do if u(s) =j then σ 2i 1 =(v j, sunny); if (the player carried an umbrella for σ 2i 1 ) then σ 2i =(s, sunny); else σ 2i =(s, rainy); if (there is C k such that u(c k ) < E(C k ) ) then σ 2i+1 =(v k, sunny); Adversary(C k,v k ); end-while To see why this request sequence makes u(s) increase, we define a weighted sum Φ of the umbrellas placed in vertex s and its neighbors, where j umbrellas in s weighs 0.5, 1.5,,j 0.5, respectively and each umbrella in vertex v i weighs i. Specifically, Φ = d i=1 u(s) i u(v i )+ (j 0.5) Let Φ k denote Φ at the end of k-th phase. We are interested in the change between Φ 2k 2 and Φ 2k. Suppose that u(s) isj at the end of (2k 2)-th phase. Depending on the decision of the player, there are four cases to consider. j=1

5 Carrying Umbrellas: An Online Relocation Problem on Graphs 199 Case A. If the player carried an umbrella throughout (2k 1)-th and 2k-th phase, we have Φ 2k 2 =Φ 2k because the number of umbrellas is unchanged. However, the weather must be sunny from Adversary(G, s). Therefore, the player did an useless carrying. Case B. If the player carried an umbrella from s to v j only, Φ 2k = Φ 2k This is because the umbrella moved had weight j 0.5 ats and j at v j. Case C. If the player carried an umbrella from v j to s only, Φ 2k = Φ 2k This is because the weight of the umbrella moved changes from j to j+0.5. Case D. The remaining case is that the player never carried an umbrella. This is impossible by Adversary(G, s), because if the player didn t carry an umbrella in (2k 1)-th phase w 2k is set to rainy. In summary, over two phases 2k 1 and 2k, Φ increases or is unchanged; If Φ is unchanged, the player did useless carrying in consecutive sunny days. Note that successive useless carryings make the player s strategy not competitive, because Opt would not carry an umbrella over two sunny days. Hence, in order to be competitive, the player must sometimes increase Φ. How many times Φ can increase before u(s) becomes d+1? Recall that once u(s) becomes d+1, some deficient C k exists and we start the recursive procedures. While u(s) d, each umbrella can have 2d different weights. Moreover, since u(g) is less than or equal to the number of edges in G, Φ can increase at most 2d N 2 2 <N3 phases before u(s) becomes d+1. Thus, Φ can increase at most N 3 phases, before the recursive procedure is called. In Adversary(C k,v k ), we recursively define a request sequence and weight sum Φ. Thus, in C k, Φ can increase in at most (N 1) 3 phases, before the player moves into some its deficient subgraph. In all recursive procedures, its weight sum can increase in at most N 3 +(N 1) <N 4 phases. In the limiting case that N = 2, the player always does useless carrying. This means that the player carries an umbrella except at most N 4 phases, and that for the same input, Opt can carry an umbrella in at most N 4 phases. Finally, we choose the length L of input sequence σ sufficiently large. Specifically, we let L (c +1) (N 4 ). Then, the cost of the player s strategy A is C A (σ) L N 4 c (N 4 ) And, the cost of Opt is C Opt (σ) <N 4 Therefore, the competitive ratio is, for an arbitrary c(< ), C A (σ) C Opt (σ) >c completing the proof. With small modification, we can show the following theorem but details are omitted in this abstract. Theorem 2. If G is a graph with M edges (but no parallel ones), u (G) M+1.

6 200 J.-H. Lee, C.-D. Park, and K.-Y. Chwa 3 Upper Bound In this section, we show u (G) is no larger than M + 1. It suffices to show that if u(g)=m +1 then the player has a safe and competitive strategy. Throughout this section, we assume that u(g)=m+1. To show this theorem, we only consider the weak player that carries at most one umbrella in a phase. Imagine that we are the player that should be safe and competitive against the adversary. The heart of our strategy is how to decide whether to carry an umbrella in sunny days. To help this decision, we maintain two things: labels of umbrellas and a rooted subtree of G. First, let us explain the labels, recalling that u(g)=m+1. M umbrellas are labeled as γ(e) for each edge e E, and one remaining umbrella is labeled as Current. Under these constraints, labels are updated during the game. In addition to the labels, we also maintain a dynamic rooted subtree S of G, called skeleton. S is a subtree of G whose root is the current position of the player. The root of S has the umbrella labeled as Current. For an edge e S, the child-vertex of e has the umbrella labeled as γ(e). For an edge e/ S, the umbrella labeled as γ(e) lies in one endpoint of e. Note that all umbrellas labeled as γ(e) is placed on one endpoint of e. Inan example of Figure 1a, current skeleton S is enclosed by a dotted line and every edge in S is directed towards the child, indicating the location of its umbrella. root Fig. 1. Example of a skeleton (enclosed in a dotted line). S is initialized as follows: The player first chooses an arbitrary spanning tree T and places an umbrella in each vertex of T, with their labels undetermined. Then, the number of umbrellas used in T is N. For an edge e not in T, we place an umbrella on any endpoint of it; This umbrella is labeled as γ(e). Then, the number of umbrellas labeled equals the number of edges not in T that is M N+1 and so the total number of umbrellas used is M+1. After the adversary chooses the start vertex s, the umbrellas in T are labeled. The umbrella in s is labeled as Current, and the umbrella in v ( s) is labeled as γ(e), where e connects v with its parent in T. Now, we describe the strategy of the player. Suppose that currently, the playerisatv i 1 and the current request is (v i, w i ). If the weather is rainy, the

7 Carrying Umbrellas: An Online Relocation Problem on Graphs 201 player has no choice; it has to move to v i with carrying the umbrella Current. In this case, the player resets S as a single vertex {v i }. It is easily seen that the new skeleton satisfies the invariants, because only the umbrella Current is moved. The more difficult case is when the weather is sunny. Suppose that w i = 0, i.e., sunny. Depending on whether v i belongs to S or not, there are two cases. If v i belongs to S (Figure 2a), then the player moves to v i without an umbrella. Though no umbrellas are moved, labels must be changed. Let e 1,e 2,,e r be the edges encountered when we traverse from v i 1 to v i in S. The umbrella Current is relabeled as γ(e 1 ) and the umbrella γ(e k )is relabeled as γ(e k+1 ) for 1 k r 1 and finally, the umbrella γ(e r ) is relabeled as the new Current. Observe that new skeleton S still satisfies the invariants. If v i does not belong to S (Figure 2b), the edge e =(v i 1,v i ) does not lie in S. Remember that the umbrella γ(e) was at v i 1 or v i from the invariants. Ifthe umbrella γ(e) was placed at v i 1, the player moves to v i carrying the umbrella Current, and adds the vertex v i and the edge (v i 1,v i )tos. If the umbrella γ(e) was placed at v i, the player moves to v i without carrying an umbrella and adds the vertex v i and the edge (v i 1,v i )tos and additionally, swaps the labels of Current and γ(e). In both cases, it is easy to see that S still satisfies the invariants (see Figure 2b). v i 1 e 1 e 3 e 2 v i v i 1 e 4 v i (a) (a) Fig. 2. After Fig. 1, (v i, sunny) is given. (a) v i is in S. (b) v i is not in S. Theorem 3. Let G be a graph with N nodes and M edges. If u(g) M +1, the player s strategy is safe and b(g)-competitive, where b(g) is the number of vertices in the largest biconnected component in G. Proof. First, the player s strategy is safe from the invariant that the player always has the umbrella Current. Next, we show that the strategy of the player is N-competitive. Let us divide the request sequence into a number of stages, each of which contains exactly one rainy and starts with rainy. Remember that the player resets S to a single vertex at the start of every stage. The cost of Player(G) in a stage is at most N, because the cost 1 is paid only when S is set to a single vertex or becomes larger. The cost of Opt in a stage is at least one, because each stage starts with rainy. Therefore, the competitive ratio is at most N. The competitive ratio can

8 202 J.-H. Lee, C.-D. Park, and K.-Y. Chwa be refined to b(g) by observing that for one rainy phase from u to v, we only have to reset S only in the biconnected component containing u and v. Thus we have that u (G)=M +1. Unfortunately, the above competitive ratio is best possible for some graphs when u(g)=m +1. Theorem 4. For an N-node ring G with u(g)=m+1, the competitive ratio of any strategy is at least N. Proof. Omitted. 4 Directed Graphs In this section, we extend the result of the previous section to the case of digraphs. Our motivation is as follows: Let G =(V (G),A(G)) be a digraph. (For convenience, it is assumed that G is strongly connected, that is, there is a path from any vertex to any other vertex.) In the special case that G is a symmetric digraph (obtained by replacing each edge of an undirected graph by two directed arcs with reverse directions), u (G) = A(G) by theorems in Section 3 and 4. Does it hold for every digraph? It is easily seen that the answer is no. A counterexample is given in Figure 3. For a graph G made by adding directed arcs alternatively to the undirected n-star, we have that u (G) =u (n-star), irrelevant with the number of added arcs. Fig. 3. For this graph G, u (G) =u (8-star) = 8. Thus u (G) of a directed graph G seems not to be directly determined by A, in contrast with undirected graphs. This section shows upper and lower bound on u (G), which are not tight in general but reduce to E + 1 for undirected graphs. Let G be a digraph. See Figure 4. G c is made by contracting a path consisting of vertices with indegree 1 and outdegree 1. More exactly, it v 1,v 2 v k be a one-way path such that the indegree and outdegree of v i (2 i k 1) is 1, we replace it by an arc v 1,v k. This operation is called a contraction and G c is obtained by repeatedly applying to G contractions as long as possible. Let Ḡc be the undirected graph (with no parallel edges) such that V (Ḡc) =V (G c ) and Ḡ c contains an edge (u, w) if and only if Ḡ c contains an arc u, w or w, u. Observe that Ḡc is uniquely defined from G c. We call Ḡ c the underlying graph of G c. Theorem 5. Let G be a digraph. Then u (G) E(Ḡc) + V (G) V (G c ) +1.

9 Carrying Umbrellas: An Online Relocation Problem on Graphs 203 Fig. 4. (a) A graph G, (b) its contracted one G c, and (c) its underlying graph Ḡc. Proof. Suppose that u (G) = E(Ḡc) + V (G) V (G c ) +1. We present a competitive strategy. Among the vertices in G, we call the ones in G c c-vertices, the ones not in G c p-vertices. Note that the number of p-vertices is V (G) V (G c ). Roughly speaking, the player s strategy decides whether to carry umbrellas or not, depending on E(Ḡc) + 1 umbrellas placed on c-vertices Let us explain the initialization of u(g) umbrellas. E(Ḡc) + 1 umbrellas are placed on c-vertices by applying the initialization of the undirected graphs to Ḡ c. Each of V (G) V(G c ) umbrellas is placed at each p-vertices. Then each p-vertex has one and only one umbrella. Consider a phase, say j, in which it is rainy for the first time. Let v 1,v 2 v k be a one-way path in G where v 1 and v k are c-vertices and every v i (i 1,k)is a p-vertex. Without losing generality, suppose that the player moves from v i to v i+1 at phase j. Then the player carries an umbrella afterwards until it reaches v k.ifi = 1, then the player carries an umrbella from v 1 to v k, which corresponds to one rainy phase occured in Ḡc. Otherwise, that is, if 2 i k 1, the player carries an umrbella from v i to v k. By assuming that v 1 borrows an umbrella from v i and this umbrella will be returned to v i when the player goes to v i again, we can imagine as if the player carries an umrbella from v 1 to v k. Thus any case corresponds to one rainy phase occured in Ḡc. Afterwards, as in Theorem 3, we construct the skeleton S in Ḡc and decides whether to carry an umbrella or not according to S in Ḡc. Suppose that the player lies on a c-vertex v 1 and the adversary requests to move to v 2 where v 1,v 2, v k is a one-way path. If it is rainy, we also follows the routine explained above and skeleton becomes only one vertex v k. Otherwise, consider the strategy of the player on Ḡc and compute if the player carries an umbrella for the request (v 1,v k )onḡc. If the the palyer carries an umbrella on Ḡc, he also does in G and always carries an umbrella while traveling to v k. Otherwise, the player does not carry an umbrella, but if v 1 borrowed an umbrella from v i, v 1 returns it. After one rainy phase, the player can construct a full skeleton by carring an umbrella whenever visiting a c-vertex not in S. Thus the player s strategy is

10 204 J.-H. Lee, C.-D. Park, and K.-Y. Chwa V (G) -competitive. In fact, it is b(g)-competitive where b(g) is the size of the largest biconnected component in G. Lower bound can also be obtained for digraphs (but proofs are omitted): For a digraph G, let Ḡ c be the undirected graph (with no parallel edges) such that V (Ḡ c)=v (G c ) and Ḡc contains an edge (u, w) if and only if Ḡc contains both arcs u, w and w, u. Then u (G) E(Ḡ c) + V (G) V (G c ) +1.Thusthe gap between upper and lower bound on u (G) is E(Ḡc) E(Ḡ c). Observe that Theorem 5 is optimal for the graph given in Figure 4. 5 Concluding Remarks This paper is the first attempt on an online problem Carrying Umbrellas, and many questions remain open. First, finding u (G) for a digraph G seems to be interesting in a graph-theoretical viewpoint. Similarly, the characterization of the class of graphs such that u (G) = V (G) is an interesting open problem (among undirected graphs, such examples are only trees). Second, we think that the problem Carrying Umbrellas can be extended to be of practical use by adopting different relocation constraints and considering general resources rather than umbrellas. For now, however, it is mainly of theoretical interest. Finally, reducing the competitive ratio with more umbrellas is an open problem. Acknowledgements grateful to Oh-Heum Kwon for motivating this work. References 1. N. Alon, R. M. Karp, D. Peleg, and D. West. A graph-theoretic game and its application to the k-server problem. SIAM J. of Comput., 24(1):78 100, R. Beigel and W.I Gasarch. The mapmaker s dilemma. Discrete Applied Mathematics, 34(1):37 48, Ben-David, A. Borodin, R.M. Karp, G. Tardos, and A. Widgerson. On the power of randomization in online algorithms. In Proc. of 22nd STOC, pages , Hans L. Bodlaender. On the complexity of some coloring games. Int. J. of Foundation of Computer Science, 2: , A. Borodin and R. El-Yaniv. Online computation and competitive analysis. Cambridge University Press, M. Chrobak and L. Larmore. The searver problem and online game. In DIMACS Series in Discrete Mathematics and Theoretical Computer Science, volume 7, pages AMS-ACM, P. Raghavan and M. Snir. Memory versus randomization in online algorithms. In Proc. of 16th ICALP, pages , D. Sleator and R. Tarjan. Amortized efficiency of list update and paging rules. Communications of ACM, 2(28): , 1985.