# Different Speeds Suffice for Rendezvous of Two Agents on Arbitrary Graphs

## Abstract

We consider the rendezvous problem for two robots on an arbitrary connected graph with *n* vertices and all its edges of length one. Two robots are initially located on two different vertices of the graph and can traverse its edges with different but constant speeds. The robots do not know their own speed. During their movement they are allowed to meet on either vertices or edges of the graph. Depending on certain conditions reflecting the knowledge of the robots we show that a rendezvous algorithm is always possible on a general connected graph.

More specifically, we give new rendezvous algorithms for two robots as follows. (1) *In unknown topologies.* We provide a polynomial time rendezvous algorithm based on *universal exploration sequences*, assuming that *n* is known to the robots. (2) *In known topologies.* In this case we prove the existence of more efficient rendezvous algorithms by considering the special case of the two-dimensional torus.

### Keywords

Graph Mobile agents Rendezvous Speeds Universal exploration sequence## 1 Introduction

Rendezvous is an important primitive in distributed computing which enables remote and mobile entities in a distributed network to meet, coordinate and exchange information. It is also important in robotics for establishing connectivity and exchanging information in a geometric environment which is being traversed by the robots. As such it has been the focus of numerous studies from dynamic symmetry breaking problem [20], operations research [2], and distributed computing in general [16] and specific [15] distributed topologies.

In this paper we study the rendezvous problem under a deterministic model first introduced in [11] concerning rendezvous in a ring topology of two robots which have different speeds but are otherwise identical. The authors in [11] give an optimal time rendezvous algorithm (expressed as a function of the speed ratio *c* and size *n* of the ring) in a ring network for two robots which do not know their own speeds. This line of research has been extended to randomized rendezvous in [14] and to deterministic rendezvous for many agents in a ring in [12]. In this paper we study for the first time the rendezvous problem for two robots having speed ratio \(c>1\) in the most general setting of an arbitrary graph of *n* nodes.

### 1.1 Model

In the sequel the terms *agent* and *robot* will be considered interchangeable. We generalize to arbitrary graphs the model first introduced in [11]. There are two mobile agents placed at different nodes of an unknown arbitrary network. The network is modelled as a simple undirected connected graph with all its edges of equal length and the agents are deterministic mobile entities with unlimited memory; from the computational point of view they are modelled as Turing machines. The agents are anonymous (i.e., they do not have labels) and identical except for their speeds which are unknown to them. Each agent moves at all times at its own same fixed speed. The speed of an agent is the inverse of the time it takes that agent to traverse one unit of length in the network. For simplicity we set as unit speed, the speed required by the slow robot to traverse a unit length edge of the graph, in which case, the length of an edge is also the time it takes the slow robot to traverse it. Thus, without loss of generality, we normalize the speed of the slowest agent to 1, and denote by \(c>1\) the speed of the faster agent.

The agents start the execution of the rendezvous algorithm simultaneously. An agent can detect when it encounters another agent at a node or inside an edge. The agents have to meet at a node or inside an edge of the graph. We consider two situations below, one in which the topology of the network is unknown to the agents and one in which it is known. They cannot mark the visited nodes in any way. The nodes of the network are anonymous but the edges incident to a node *v* have distinct labels in \(\{0, ..., d-1\}\), where *d* is the degree of *v*. Therefore, every undirected edge \(\{u, v\}\) of the graph has two labels, which are called its port numbers at *u* and at *v*. The port numbering is local, i.e., there is no relation between port numbers at *u* and at *v*. An agent entering a node *u* learns the port of entry and the degree of the node and can see the exit port-labels at *u*. An agent at a node *u* can decide to stop or move to an adjacent node by selecting an exit port-label leaving *u*. The movement of an agent is always at its own constant speed. The edges of the network are of the same length which we normalize to 1. As the agents move, they can count the visited nodes. We note here that in the model of [11] each agent is equipped with a pedometer and by using it, an agent is capable of measuring the distance travelled and take decisions depending on its value. However, the algorithms in our model only use the agent’s capability to count the visited nodes and detect whether an agent occupies a node or not (in order to select its next destination). Hence the agents in our model can only take decisions (stop or change direction) at a node and not inside an edge. The agents cannot communicate at all (except when they meet) and each agent does not know either its own or the other agent’s speed.

When discussing running-time and feasibility of rendezvous, we take an adversarial model where the adversary can choose the network, the initial position of each agent and their speeds. The network can be considered as a graph where all edges have the same length given by the adversary. Although, as we mentioned above, we normalize the distance of every edge to 1 for the sake of the presentation, our algorithms work when the edges of the network have been associated with any (same) distance value.

The time complexity of an algorithm solving the rendezvous problem for two agents with different speeds and ratio \(c>1\) in an arbitrary network of size *n*, is defined as the worst case time to rendezvous, taken over all pairs of initial positions of the two agents, over all networks (of a particular type) of size *n* and over all pairs of different speeds with ratio *c*.

### 1.2 Related Work

The rendezvous problem for mobile agents (or robots) has been studied extensively in many topologies (or domains) and under various assumptions on system synchronicity and capabilities of the agents [7, 8, 9, 15]. A critical distinction in the models is whether the agents must all run the same algorithm, which is generally known as the *symmetric rendezvous problem* [3]. If agents can execute different algorithms, generally known as the *asymmetric rendezvous problem*, then the problem is typically much easier, though not always trivial.

In quite a few of those models, rendezvous cannot be achieved without symmetry breaking. For example, in the simple case of two deterministic identical agents on a ring graph, rendezvous cannot be achieved since the agents, no matter how they move, they will always maintain the same distance apart. Even in cases where rendezvous can be achieved without it, breaking symmetry often leads to much more efficient algorithms. One studied method for breaking symmetry is to use random bits to make probabilistic choices. An extensive survey of randomized rendezvous in various scenarios can be found in [4]. Although such algorithms may provide reasonable expected time to rendezvous, in most cases they have poor worst-case behaviour. Another studied symmetry breaking mechanism is to let the agents drop tokens and count inter-token distances [18]. In arbitrary anonymous graphs with identical agents, the problem was solved (when it is feasible) in [6], for synchronous agents. A third studied symmetry breaking mechanism is to let agents have distinct labels [9, 19]. In the asynchronous case, an almost complete solution for rendezvous in networks using distinct labels has been provided in [10].

In asynchronous scenarios the speed of any agent’s traversal is controlled by an adversary. Hence even the traversals of the same edge by the same agent at two different times, take finite, but maybe different times. Under this assumption rendezvous in a node cannot be guaranteed even in very simple graphs, and therefore the rendezvous requirement in that case is usually relaxed to allow the agents to meet at a node or inside an edge. In our model, although any two traversals of the same edge by the same agent last the same fixed time, this time is controlled by the adversary (by selecting the speed of the agent and the length of the edges) and it is not the same for the two agents. It is easy to see that rendezvous in the same node also cannot be guaranteed even in simple networks (e.g., rings). Hence we also adopt in our model the relaxed requirement for rendezvous, i.e., allow the agents to meet at a node or inside an edge. Note that in our model since the agents initially have exactly the same information about themselves and the network, they cannot assign to themselves distinct labels. Hence the agents must exploit their different speeds (whose values are unknown to the agents) in order to meet.

The difference in speed between two otherwise identical agents, is a source of asymmetry that has recently received more attention. While agent speeds have been considered as a problem parameter before, the traditional assumption for synchronous agents has been that all agents move at a common fixed speed. Even when agent speed has been allowed to vary, as in [5], agents have typically had a uniform range of possible speeds and have been required to choose their speed deterministically, maintaining the symmetry of the problem.

The rendezvous problem is also related to the exploration problem, since both agents have to traverse (explore) some (the same) node or edge in order to meet. The exploration problem of an anonymous arbitrary network by an agent has been extensively studied. An important tool for exploration of anonymous arbitrary networks is the *Universal Traversal Sequence (UTS)* which has been suggested in [1]. A UTS for *n*-vertex graphs is a predetermined sequence of instructions that when executed on any *n*-vertex graph, from any starting vertex, defines a walk that visits all the vertices of the graph. The authors of [1] showed the existence of a UTS of a polynomial length for any graph of at most *n* nodes. However, to date it remains unknown whether a UTS of a polynomial length can be constructed in polynomial time. In [13] a tool closely related to UTS was proposed, called *Universal Exploration Sequence (UXS)*. Roughly speaking, exploration sequences can replace traversal sequences when backtracking is allowed. Reingold showed in [17] that a UXS of a polynomial length can be constructed in log-space and therefore in polynomial time. In [19], they defined and constructed in polynomial time the so called *strongly* universal exploration sequence, which is a possibly infinite sequence \(\sigma \) with the property that every contiguous subsequence of \(\sigma \) of some fixed length *p*(*n*) (where *p*(*n*) is a polynomial) is a UXS for any graph of at most *n* nodes.

### 1.3 Outline and Results of the Paper

Section 2 studies rendezvous in unknown topologies and includes preliminaries on Universal Exploration Sequences in Subsect. 2.1, and a rendezvous algorithm for known *n* in Subsect. 2.2. Section 3 deals with rendezvous when the network topology is known; we discuss rendezvous in a torus.

## 2 Rendezvous in Unknown Topologies

In this section we present algorithms for accomplishing rendezvous in unknown graph topologies by using universal exploration sequences. We begin by mentioning relevant results on universal exploration sequences and then proceed to give a new rendezvous algorithm that solves the problem in any graph consisting of *n* nodes, when *n* is known.

### 2.1 Preliminaries on Universal Exploration Sequences

Let us briefly explain the notion of the universal exploration sequence. Let \((a_1, a_2, ..., a_k)\) be a sequence of integers and let *G* be a graph and *u* be a node of *G*. Let also \(w=succ(v,x)\) be the node reached by taking the exit-port *x* from node *v*. A sequence of nodes \((u_0, \ldots , u_{k+1})\) of *G* can be obtained as follows: \(u_0 = u\), \(u_1 = succ(u_0, 0)\); for any \(1 \le i \le k\), \(u_{i+1} = succ(u_i, (p+a_i) \mod d(u_i))\), where *p* is the entry-port number at \(u_i\) corresponding to the edge \(\{u_{i-1}, u_i\}\). A sequence \((a_1, a_2, \ldots , a_k)\) which can be applied to any node *u* of a graph *G* and produces a sequence of nodes containing all nodes of *G* is called a *Universal Exploration Sequence (UXS)* for graph *G*. A UXS for a class of graphs is a UXS for all graphs in this class. The following important result, based on universal exploration sequences introduced by Kouckỳ [13], is due to Reingold [17].

### Proposition 1

**(**[17]**).** For any positive integer *n*, a Universal Exploration Sequence \(Y(n) = (a_1,a_2, \ldots , a_M)\) can be constructed in polynomial time with respect to *n* (thus, the agents will be using \(O(\log n)\) bits of memory) for the class of all graphs with at most *n* nodes, where *M* is polynomial in *n*.

The length of such a log-space constructive universal exploration sequence is on the order of at least \(n^{100}\) in Reingold’s [17] original implementation (though still polynomial in *n*). Aleliunas et al. proved in [1] the existence of Universal *Traversal* Sequences of shorter length.

### Proposition 2

**(**[1]**).** For any positive integers *n*, *d*, \(d < n\), there exists a universal traversal sequence of length \(O(n^3d^2 \log n)\) for the family of all graphs with at most *n* nodes and maximum degree at most *d*.

Kouckỳ has shown in [13] in exactly the same way as in Proposition 2, a similar result for universal exploration sequences. Note that the traversal (or exploration) sequences in Proposition 2 above are not necessarily constructible in logarithmic memory^{1} (and hence not constructible in polynomial time).

Given any positive integer *n*, the UXS leads one agent to visit all nodes of any graph of size at most *n*, starting from any node of the graph, using at most *T*(*n*) edge traversals, where *T* is some polynomial. Upon entering a node of degree *d* by some port *p*, the agent can compute the port *q* by which it has to exit; more precisely \(q=(p+x_i) \bmod d\), where \(x_i\) is the corresponding term of the UXS.

### 2.2 Rendezvous in Arbitrary Graphs When *n* is Known

Suppose that the two agents only know the size *n* of the graph. We will show that they can rendezvous within at most polynomial time with respect to *n*. To this end, we first need to convert a UXS *U* to a walk that traverses all edges of the graph; let us call such a walk *Full Edge Traversal (FET)*. This can be easily done by having each robot traversing back and forth all incident edges of each node visited by *U* before it continues with the next term of *U*. Let \(\mathcal{{S}}_U\) be this modified sequence. The total number of edge traversals in \(\mathcal{{S}}_U\) is \(|\mathcal{{S}}_U| \le |U| + 2(n-1)|U|\). If we additionally instruct the agents to traverse back and forth exactly \(n-1\) incident edges of each node (if a node has \(t<n-1\) incident edges, then the agent additionally traverses one edge, randomly chosen, back and forth \((n-1)-t\) times), then the total number of edge traversals is exactly \(|U| + 2(n-1)|U|\).

### Proposition 3

Given an arbitrary graph *G* consisting of *n* nodes and a universal exploration sequence *U* of *G*, of length |*U*|, an agent knowing *U* can construct and follow a full edge traversal \(\mathcal{{S}}_U\) of *G* of length *O*(*n*|*U*|).

We will now show how to achieve rendezvous between two robots of different speeds that are able to compute and follow a full edge traversal with a known bound on its length.

### Theorem 1

Consider an arbitrary graph *G* consisting of *n* nodes, and two anonymous agents that have different speeds and (except for their speeds) are identical. The agents start moving at the same time on their own constant speeds and they know *n*.

- 1.
If the agents follow full edge traversals \(\mathcal{{S}}_c\) and \(\mathcal{{S}}_1\), respectively, where \(|\mathcal{{S}}_c| = |\mathcal{{S}}_1| = B(n)\), then rendezvous is always possible within time at most \(O \left( \frac{B(n)}{c-1} \right) \).

- 2.
If the agents can construct a universal exploration sequence of length

*T*(*n*) then rendezvous is always possible within time at most \( O \left( \frac{n \cdot T(n)}{c-1} \right) \).

### Proof

^{2}.

*B*(

*n*). Therefore the fast robot will catch up with slow robot while the latter is still traversing its chosen edge provided that

zig-zags a chosen edge in the time interval \([3iB(n), 3iB(n)+2B(n)]\),

traverses the graph in the time interval \([3iB(n) + 2B(n), 3iB(n)+3B(n)]\),

zig-zags a chosen edge in the time interval \([\frac{3jB(n)}{c}, \frac{3jB(n)+2B(n)}{c}]\),

traverses the graph in the time interval \([\frac{3jB(n) + 2B(n)}{c}, \frac{3jB(n)+3B(n)}{c}]\),

*j*the fast robot starts its FET after the slow robot (which is at a round

*i*) has started traversing back and forth its chosen edge and the fast robot finishes its FET before the slow robot finishes its zig-zags, then the two robots will meet. Hence the robots meet when:

*c*when \(1< c < \frac{3}{2}\) and therefore for any such value of

*c*there is a round

*i*for which relation (3) is satisfied. The number of rounds needed for relation (3) to be satisfied (and thus the robots to meet) can be calculated by the second part of relation (3):

Combining Theorem 1 with the result of Proposition 2 we derive easily the following corollary.

### Corollary 1

Consider an arbitrary graph *G* consisting of *n* nodes, and two anonymous agents having different speeds with ratio \(c>1\). The agents start moving at the same time on their own constant speeds and they know *n*. There is an algorithm which accomplishes rendezvous in at most \(O\left( \frac{n^6 \log n}{c-1}\right) \) time. \(\square \)

**Comments**: One could possibly think of whether the algorithm could be modified in order to work for unknown *n* (e.g., by letting the agents test varying values of *n* in an appropriate manner). Unfortunately, since the number of zig-zags depends on *B*(*n*), there seems to be no obvious way to make the algorithm work correctly; in particular, the agents would not generally test the same *n* at the same time and therefore their delays due to zig-zags would vary considerably.

## 3 Rendezvous in a \(n \times m\) Torus When the Agents Do Not Know *n* or *m*

In this section we investigate whether rendezvous can be done faster when more knowledge is available about the network topology. We focus on rendezvous in a \(n \times m\) torus when the agents do not know *n* or *m*. As usual there are two robots with different speeds starting from arbitrary vertices. Let us imagine that the two robots are located on a \(n \times m\) torus with *n* rows, *m* columns, and thus a total of *nm* vertices. The first result presented in this section assumes no knowledge of *n* or *m*; the only requirement is \(\gcd (n,m)=1\). For the second result knowledge of \(\mathrm {lcm}(n,m)\) and \(\gcd (n,m)\) is assumed.

### 3.1 Rendezvous in a \(n \times m\) Torus When \(\gcd (n,m) =1\)

*n*rows,

*m*columns, and

*nm*vertices. Further assume that \(\gcd (n,m) =1\). Construct a sequence of coordinates starting from any arbitrary vertex (

*x*,

*y*) as follows:

\(\triangleright \)\(x_0 \leftarrow x\); \(y_0 \leftarrow y\)

- \(\triangleright \)
**for**\(i= 0,1, \ldots \)**set**\( x_{i+1} \leftarrow x_i +1 \bmod m\)

\( y_{i+1} \leftarrow y_i +1 \bmod n\)

For each \(i = 0,1, \ldots \) consider the L-shaped walk (L-walk in short) \(L_i\) defined as follows: \(L_i = \langle (x_i, y_i), (x_{i + 1}, y_i ), (x_{i + 1} , y_{i + 1}) \rangle \). That is, \(L_i\) starts at point \(P_i=(x_i,y_i)\), continues to point \(C_i=(x_{i+1},y_i)\) and ends at point \(P_{i+1}=(x_{i+1},y_{i+1})\), thus traversing two edges, the first ‘horizontal’ and the second ‘vertical’.

Let us now consider the following simple algorithm: Each robot follows the trajectory resulting from the concatenation of walks \(L_0, L_1, \ldots \). Then the following theorem holds:

### Theorem 2

Consider a \(n \times m\) torus with *n* rows, *m* columns, and *nm* vertices. Further assume that \(\gcd (n,m) =1\). Then rendezvous between two robots with different speeds, 1 and \(c>1\), can be accomplished in time \( \frac{2nm}{c-1}\).

### Proof

Suppose that each robot follows the trajectory resulting from the concatenation of walks \(L_0, L_1, \ldots \). We will show that every vertex of the torus appears in this trajectory as starting point of some L-walk, and as middle point of some other L-walk. Indeed, by definition we get that \((x_i, y_i ) = (x_0 + i \bmod m , y_0 + i \bmod n)\). Therefore, for any \(x_i,x_j \in \{0,\ldots ,m-1\}, y_i,y_j \in \{0,\ldots ,n-1\}\) it holds \((x_i, y_i ) = (x_j , y_j)\) if and only if, \(i \equiv j \bmod m\) and \(i \equiv j \bmod n\). Since \(\gcd (n,m) = 1\), by applying the Chinese Remainder Theorem we get that \(i \equiv j \bmod (nm)\).

To sum up we have shown that the trajectory \(L_0, L_1, \ldots , L_{nm-1}\) starting from the vertex (*x*, *y*) must traverse all the vertices of the torus and also return to its original position. Moreover the length of this trajectory is exactly 2*mn*. In fact, each vertex is visited twice, once as a starting point of some L-walk (and ending point of the previous one) and once as middle point of some other L-walk. This is not unnecessary; the fact that each point is visited as a starting of some trajectory is crucial, as it guarantees that both robots follow exactly the same trajectory, differing only in their starting point.

Therefore, both robots move along the same cycle of length 2*mn*, in the same direction. Thus, directly applying the result of the analysis of this rendezvous algorithm of [11] (i.e., when the robots move in the same direction, not knowing the length of the cycle or *c*), we obtain the claimed bound \( \frac{2nm}{c-1} \). This concludes the proof of Theorem 2. \(\square \)

### 3.2 Rendezvous in a \(n \times m\) Torus When \(\gcd (n,m) >1\)

Assuming \(\gcd (n,m) = 1\), the previous trajectory passes from every vertex of the torus (see the proof of Theorem 2) and the success of the previous algorithm heavily relies on this.

If \(\gcd (n,m) = d > 1\) then the trajectory \(L_0, L_1, \ldots , L_{\mathrm {lcm}(n,m)-1}\) returns to the initial point \(P_0\). It thus visits only \(2\;\mathrm {lcm}(n,m)\) nodes (and an equal number of edges). Therefore, the previous algorithm does not work in this case. A different algorithm which works when \(\gcd (n,m) > 1\) is presented below.

Consider coordinates similar to those previously defined (the superscript refers to the round number, with respect to the algorithm defined below). Recall that (*x*, *y*) are the initial coordinates of a robot.

\(\triangleright \)\(x^{(0)}_0 \leftarrow x\); \(y^{(0)}_0 \leftarrow y\)

- \(\triangleright \)
**for**\(k= 0,1,\ldots \), \(i= 0,1,\ldots ,\)**set**\(x^{(k)}_{i+1} \leftarrow x^{(k)}_i +1 \bmod m\)

\(y^{(k)}_{i+1} \leftarrow y^{(k)}_i +1 \bmod n\)

- \(\triangleright \)
**for**\(k= 0,1,\ldots \),**set**\(x^{(k+1)}_{0} \leftarrow x^{(k)}_0 +1 \bmod m\)

\(y^{(k+1)}_{0} \leftarrow y^{(k)}_0 \)

### Theorem 3

Consider an \(n \times m\) torus with *n* rows, *m* columns, and *nm* vertices. Further assume that \(\gcd (n,m)\) and \(\mathrm {lcm}(n,m)\) are known and that \(\gcd (n,m) >1\). Two robots with different speeds, 1 and \(c>1\), can rendezvous in time \(O \left( \frac{nm}{c-1} \right) \).

### Proof

*d*edge-disjoint cycles, and that the cycle corresponding to \(T^{(k)}\) coincides with the cycle corresponding to \(T^{(k+d)}\). Indeed, we can extend arguments used in the proof of Theorem 2 as follows. We first observe that \((x^{(k)}_i, y^{(k)}_i ) = (x^{(k)}_0 + i \bmod m , y^{(k)}_0 + i \bmod n)\). Therefore for any \(x^{(k)}_i,x^{(k)}_j \in \{0,\ldots ,m-1\}, y^{(k)}_i,y^{(k)}_j \in \{0,\ldots ,n-1\}\) it holds \((x^{(k)}_i, y^{(k)}_i ) = (x^{(k)}_j , y^{(k)}_j)\) iff:

*x*-coordinate of the starting point of \(T^{(k')}\) is equal to the

*x*-coordinate of the starting point of \(T^{(k)}\) shifted by \(k'-k \bmod m\), while their

*y*-coordinates coincide. Clearly, the above condition holds iff:

This means that, as already mentioned, every *d* rounds a robot repeats the same cycle, usually starting from a different point of the cycle each time (if \(m=d\), trajectories \(T^{(k)}\) and \(T^{(k+d)}\) are completely identical). In addition, cycles \(T^{(k)}\) and \(T^{(k+t)}\) with \(t \bmod d \ne 0\) are completely disjoint with respect to starting points of their L-walks, hence are edge-disjoint.

Consequently, during a number of \(d=\gcd (n,m)\) rounds a robot visits all vertices of the torus twice (once as a starting point and once as a middle point of some L-walk) and traverses all edges of the torus. Note that all edges are traversed once, except for horizontal edges \((P^{(i)}_0, P^{(i+1)}_0)\) which are traversed twice, the second time providing a transfer of the robot to a different cycle.

Therefore, the concatenation of trajectories \(T^{(i)}, 0\le i\le d-1\) performed in the second step of the algorithm is in fact a full edge traversal (FET) of length \(\gcd (n,m)(2\mathrm {lcm}(n,m)+1) = 2nm+\gcd (n,m)\), and by applying Theorem 1 we get the claim.

Note that the fact that \(T^{(k)}\) is not (in most cases) completely identical to \(T^{(k+d)}\) (due to different starting point) does not affect rendezvous time, since all edges of the torus are traversed. This completes the proof of Theorem 3. \(\square \)

## 4 Open Questions

It would be interesting to investigate rendezvous algorithms for two robots which require even less knowledge. In particular, it would be nice to remove the requirement of knowledge of the size of the graph, potentially by using an appropriate guessing strategy. Another important open question would be to address the case of equal speeds, possibly by introducing delays after certain number of rounds. Finally, the study of rendezvous for many robots of different speeds would also be of great interest.

## Footnotes

- 1.
In fact they are (deterministically) constructible in polylogarithmic space, but to date it is unknown whether a universal traversal (or exploration) sequence of length \(O(n^3d^2 \log n)\) can be constructed in polynomial time.

- 2.
This algorithm builds on an idea proposed (without its analysis) by an unknown reviewer based on an algorithm appearing in an earlier version of this paper.

### References

- 1.Aleliunas, R., Karp, R.M., Lipton, R.J., Lovasz, L., Rackoff, C.: Random walks, universal traversal sequences, and the complexity of maze problems. In: FOCS, pp. 218–223. IEEE (1979)Google Scholar
- 2.Alpern, S.: The rendezvous search problem. SIAM J. Control Optim.
**33**(3), 673–683 (1995)MathSciNetCrossRefMATHGoogle Scholar - 3.Alpern, S.: Rendezvous search: a personal perspective. Oper. Res.
**50**(5), 772–795 (2002)MathSciNetCrossRefMATHGoogle Scholar - 4.Alpern, S., Gal, S.: The Theory of Search Games and Rendezvous. Kluwer Academic Publishers, New York (2002). International Series in Operations Research and Management ScienceMATHGoogle Scholar
- 5.Czyzowicz, J., Ilcinkas, D., Labourel, A., Pelc, A.: Asynchronous deterministic rendezvous in bounded terrains. TCS
**412**(50), 6926–6937 (2011)MathSciNetCrossRefMATHGoogle Scholar - 6.Czyzowicz, J., Kosowski, A., Pelc, A.: How to meet when you forget: log-space rendezvous in arbitrary graphs. Distrib. Comput.
**25**(2), 165–178 (2012)CrossRefMATHGoogle Scholar - 7.Czyzowicz, J., Kosowski, A., Pelc, A.: Deterministic rendezvous of asynchronous bounded-memory agents in polygonal terrains. Theor. Comput. Syst.
**52**(2), 179–199 (2013)MathSciNetCrossRefMATHGoogle Scholar - 8.Marco, G., Gargano, L., Kranakis, E., Krizanc, D., Pelc, A., Vaccaro, U.: Asynchronous deterministic rendezvous in graphs. Theoret. Comput. Sci.
**355**(3), 315–326 (2006)MathSciNetCrossRefMATHGoogle Scholar - 9.Dessmark, A., Fraigniaud, P., Kowalski, D., Pelc, A.: Deterministic rendezvous in graphs. Algorithmica
**46**, 69–96 (2006)MathSciNetCrossRefMATHGoogle Scholar - 10.Dieudonné, Y., Pelc, A., Villain, V.: How to meet asynchronously at polynomial cost. In: Proceedings of the ACM Symposium on Principles of Distributed Computing, PODC 2013, pp. 92–99 (2013)Google Scholar
- 11.Feinerman, O., Korman, A., Kutten, S., Rodeh, Y.: Fast rendezvous on a cycle by agents with different speeds. In: Chatterjee, M., Cao, J., Kothapalli, K., Rajsbaum, S. (eds.) ICDCN 2014. LNCS, vol. 8314, pp. 1–13. Springer, Heidelberg (2014). doi:10.1007/978-3-642-45249-9_1 CrossRefGoogle Scholar
- 12.Huus, E., Kranakis, E.: Rendezvous of many agents with different speeds in a cycle. In: Papavassiliou, S., Ruehrup, S. (eds.) ADHOC-NOW 2015. LNCS, vol. 9143, pp. 195–209. Springer, Heidelberg (2015). doi:10.1007/978-3-319-19662-6_14 CrossRefGoogle Scholar
- 13.Koucky, M.: Universal traversal sequences with backtracking. J. Comput. Syst. Sci.
**65**, 717–726 (2002)MathSciNetCrossRefMATHGoogle Scholar - 14.Kranakis, E., Krizanc, D., MacQuarrie, F., Shende, S.: Randomized rendezvous on a ring for agents with different speeds. In: Proceedings of the 15th International Conference on Distributed Computing and Networking (ICDCN) (2015)Google Scholar
- 15.Kranakis, E., Krizanc, D., Markou, E.: The mobile agent rendezvous problem in the ring: an introduction. Synthesis Lectures on Distributed Computing Theory Series. Morgan and Claypool Publishers, San Rafael (2010)Google Scholar
- 16.Pelc, A.: Deterministic rendezvous in networks: a comprehensive survey. Networks
**59**, 331–347 (2012)MathSciNetCrossRefGoogle Scholar - 17.Reingold, O.: Undirected connectivity in log-space. J. ACM
**55**(4), 17 (2008)MathSciNetCrossRefMATHGoogle Scholar - 18.Sawchuk, C.: Mobile Agent Rendezvous in the Ring. Ph.D. thesis, Carleton University (2004)Google Scholar
- 19.Ta-Shma, A., Zwick, U.: Deterministic rendezvous, treasure hunts, strongly universal exploration sequences. ACM Trans. Algorithms
**10**(3), 12 (2014)MathSciNetCrossRefMATHGoogle Scholar - 20.Yu, X., Yung, M.: Agent rendezvous: a dynamic symmetry-breaking problem. In: Meyer, F., Monien, B. (eds.) ICALP 1996. LNCS, vol. 1099, pp. 610–621. Springer, Heidelberg (1996). doi:10.1007/3-540-61440-0_163 CrossRefGoogle Scholar