Online Graph Exploration on a Restricted Graph Class: Optimal Solutions for Tadpole Graphs

TL;DR

This paper proves that a greedy algorithm achieves an optimal competitive ratio of 2 for online exploration of tadpole graphs with arbitrary edge weights, improving understanding of exploration efficiency on this graph class.

Contribution

It demonstrates that a simple greedy approach is optimally competitive for exploring tadpole graphs with non-negative edge weights.

Findings

Greedy algorithm achieves a competitive ratio of 2.

Optimal exploration strategy for tadpole graphs established.

Results extend previous bounds to non-unit edge weights.

Abstract

We study the problem of online graph exploration on undirected graphs, where a searcher has to visit every vertex and return to the origin. Once a new vertex is visited, the searcher learns of all neighboring vertices and the connecting edge weights. The goal such an exploration is to minimize its total cost, where each edge traversal incurs a cost of the corresponding edge weight. We investigate the problem on tadpole graphs (also known as dragons, kites), which consist of a cycle with an attached path. Miyazaki et al. (The online graph exploration problem on restricted graphs, IEICE Transactions 92-D (9), 2009) showed that every online algorithm on these graphs must have a competitive ratio of 2-epsilon, but did not provide upper bounds for non-unit edge weights. We show via amortized analysis that a greedy approach yields a matching competitive ratio of 2 on tadpole graphs, for arbitrary non-negative edge weights.

Full text

We investigate the problem on tadpole graphs (also known as dragons, kites), which consist of a cycle with an attached path. The construction by Miyazaki et al. (The online graph exploration problem on restricted graphs, IEICE Transactions 92-D (9), 2009) can be extended to show that every online algorithm on these graphs must have a competitive ratio of $2-\varepsilon$, but the authors did not investigate non-unit edge weights. We show via amortized analysis that a greedy approach yields a matching competitive ratio of $2$ on tadpole graphs, for arbitrary non-negative edge weights. Moreover, we also briefly discuss the topic of advice complexity on cycle and tadpole graphs.

††journal: arXiv

1 Introduction

Exploring an unknown graph is considered to be one of the fundamental problem of robotics [1, 2]: A searcher has to visit all vertices and return to the origin. As the searcher only has information about the subgraph already explored and the adjacent vertices, the problem is commonly studied from an online perspective. In other words, the goal is to minimize the competitive ratio of the cost of the actually traversed tour versus a tour of minimum cost.

In this paper, we investigate online graph exploration on tadpole [3] graphs (also known as dragons [4] or kites [5], see [6]), which can be visualized as follows: start with a cycle and attach an endpoint of a path to one vertex of the cycle.

Background. Rosenkrantz et al. [7] proved that a greedy exploration algorithm has a competitive ratio of $\Theta(\log n)$ on general graphs with $n$ vertices. Even though their result is over 40 years old, it is not known if algorithms with a competitive ratio of $o(\log n)$ exist—the best known lower bound was $2.5-\varepsilon$ [8] for some time, recently improved to $10/3-\varepsilon$ for planar graphs [9].

However, when all edges have unit traversal cost, a depth-first search (DFS) has a competitive ratio of $\frac{2n-2}{n}<2$, with a matching lower bound of $2-\varepsilon$ for any exploration algorithm [10, 11]. For the case of $k$ different edge weights, a hierarchical DFS provides a competitive ratio of $2k$, which can be extended to a competitive ratio of $\Theta(\log n)$ for arbitrary edge weights [12]. Moreover, when considering strongly connected directed general graphs, a greedy algorithm achieves an optimal competitive ratio of $n-1$ [13].

The related problem of searching for a specific vertex was covered by Smula et al. [14, 15], and there is also work exploring graphs with multiple agents and limited memory respective pebbles, e.g., by Disser et al. [16]. In the case of multiple agents, the exploration problem on tadpoles is related to searching on three rays, where the agents do not start on the junction [17].

With the general undirected weighted case being an open problem for many decades now, some articles studied graph exploration on restricted graph classes, initiated by the ShortCut algorithm of Kalyanasundaram and Pruhs [18] for planar graphs. However, Megow et al. [12] report on a “precarious issue in the given formal implementation” of ShortCut, to which end they reformulate and improve ShortCut in their Blocking algorithm, achieving a competitive ratio of $16(2g+1)$ on graphs of genus at most $g$ (e.g., 16 on planar graphs). Very recently, Fritsch [19] showed a Blocking parameter modification to be 3-competitive on unicyclic graphs and $5/2+\sqrt{(}2)\approx 3.91$-competitive on cactus graphs.

Moreover, Megow et al. [12] show in an intricate construction that the Blocking algorithm does not have a competitive ratio of $o(\log n)$ in general. As such, there is no promising candidate algorithm known that could potentially break the $\log n$ barrier on general graphs, but also no insight on the existence of non-constant lower bounds. Regarding further graph classes, Asahiro et al. [20] showed that nearest neighbor algorithms achieve a competitive ratio of $1.5$ on cycles, also giving a lower bound of $1.25$. The latter result was improved by Miyazaki et al. [10] by utilizing weighted distance computations to reach a competitive ratio of $\frac{1+\sqrt{3}}{2}\approx 1.366$, with a matching lower bound of $\frac{1+\sqrt{3}}{2}-\varepsilon$.

Motivation. For graphs with different edge weights, until the very recent result of Fritsch, there were no results between cycles and planar graphs, leaving a rather large gap in the competitive landscape between the ratios of $1.366$ (cycles) and $16$ (planar graphs), where the latter result is also just an upper bound. We thus investigate a natural extension of the cycle, by joining the endpoint of a path to a cycle, also known as tadpole, dragon, or kite graphs [6].

Maybe interestingly, this class of graphs was also implicitly used for the lower bound construction on unit edge weight graphs in [10, 11]. We thus hope that a further investigation of these graphs will lead to a better understanding of graph exploration on special (planar) graphs.

Contribution. We prove that a greedy exploration algorithm achieves a competitive ratio of 2 on tadpole graphs, for non-negative edge weights. We also extend the construction by Miyazaki et al. [10] to prove a lower bound of $2-\epsilon$ for unit edge weight tadpole graphs, i.e., our results are tight. We also briefly discuss the topic of advice complexity on cycle and tadpole graphs.

Organization. Our article is structured as follows. We first provide a formal model in §2, followed by a lower bound proof in §3 that shows there is no tadpole exploration algorithm with a competitive ratio of $2-\varepsilon$ on unweighted graphs, extending a construction from Miyazaki et al. [10, § 4.2]. We then provide a proof in §4 that a greedy exploration results in a matching competitive ratio of 2 on tadpoles, discuss the topic of advice complexity in §5, concluding in §6.

2 Model

Graph model. We consider connected undirected graphs $G=(V,E)$ with $|V|=n$ vertices and $|E|=m$ edges, denoting an edge connecting $u$ and $v$ as $(u,v)$. Each edge $e\in E$ is equipped with a positive edge weight $c(e)$.111We can omit edge weights of 0, as these edges can be explored for free in the undirected case, i.e., one might as well “contract” these edges and only consider positive weights. In particular, all investigated graphs will be tadpole graphs, which are graphs where one vertex has degree $1$, one vertex has degree $3$, and all other vertices have degree 2. Hence, one can imagine that a tadpole graph consists of one cycle with $i$ vertices, to which a path (or, from now on, stem) of $j$ vertices is attached. As such, all tadpole graphs can be represented e.g. in the form $T_{i,j}$, with $i\geq 3$ and $j\geq 1$.

Exploration model. We assume that the searcher has unlimited computational power and memory. Each vertex is equipped with an unique identifier (ID), where exploration proceeds as follows [12, 18]: upon arriving at a vertex $v$, the searcher obtains the IDs of all adjacent vertices, as well as the weight of all incident edges. In order to move to a neighboring vertex $u$ of $v$, the searcher has to pay the edge weight of $(v,u)$, even if this edge was traversed before. The goal is to perform a closed tour (a closed walk) from the starting vertex $s\in V$ that visits all vertices in $V$, while minimizing the accumulated cost. We call algorithms that perform such closed tours exploration algorithms.

Competitive ratio. The quality of an exploration algorithm $A$ is rated by its competitive ratio. The competitive ratio $R_{A}(G)$ on a given graph $G$ is defined as $R_{A}(G)=\frac{\text{cost}_{A}(G)}{\text{cost}_{\text{opt}}(G)}$, where $\text{cost}_{A}(G)$ is the cost of the tour of the algorithm $A$ on $G$ and $\text{cost}_{\text{opt}}(G)$ is the cost for the optimal tour. A competitive ratio of 1 is optimal and given two algorithms, the one with the lower competitive ratio is better. One can find an optimal tour cost by solving the traveling salesman problem (TSP) [21] on the complete graph $G^{\prime}$ with $V(G^{\prime})=V(G)$, where for all $u,v\in V(G^{\prime}),u\neq v$, the edge weight $c((u,v))$ is the length of the shortest path between $u$ and $v$ in $G$ [7]. Lastly, the competitive ratio of $A$ on some graph class $\mathcal{G}$ is defined as the supremum of its competitive ratio over all graphs $G\in\mathcal{G}$.

3 Lower Bounds for Tadpole Graphs

To provide some first intuition, we extend the lower bound construction by Miyazaki et al. [10, § 4.2] to the case of tadpole graphs. We note that Miyazaki et al. state their theorem for general graphs, but in fact, they only require the explored graph to be either a tree or a tadpole graph. We now extend their proof such that we can promise to the searcher that the graph to be explored is a tadpole graph, while retaining lower bounds.

Theorem 1** (Extended construction from [10], § 4.2).**

For any positive constant $1>\varepsilon>0$, there is no $(2-\varepsilon)$-competitive online algorithm for unit weight tadpole graphs.

We note that our following proof construction heavily relies on [10, § 4.2]. Our adapted main proof idea is as follows:

When starting on the cycle, after the junction vertex $t$ with degree $3$ is found, the graph looks like three paths joined at $t$ to the searcher. The challenge for the searcher is now to find out which of the two paths form the cycle. However, the adversary can “force” the searcher to explore the cycle first, i.e., the searcher needs to go back to the earlier visited junction $t$. If the adversary appropriately chooses the path lengths according to the searcher’s decisions, the additional tour length required can be arbitrarily close to the optimal tour length.

We now give the promised formal proof, following Miyazaki et al.’s notation:

Proof.

Let the searcher start on a vertex $s$ of degree $2$, where an adversary will construct the tadpole graph on the go. Until the junction vertex $t$ is visited, the graph will look like two edge-disjoint paths to the searcher, consisting of the vertices $s,v_{1},v_{2},\ldots$ and $s,u_{1},u_{2},\ldots$. Initially, the vertices $v_{1},u_{1}$ are visible to the searcher, but yet unvisited.

The adversary keeps extending the paths, until the searcher reaches a distance of $k$ on one of the paths, w.l.o.g. on $u_{k}$. We set $u_{k}$ as the junction $t$ and the adversary reveals two new vertices, adjacent to $t$, namely $q_{1}$ and $p_{1}$. Denote by $v_{t_{1}}$, $t_{1}<k$, the most distant visited vertex on the opposing side of $s$, where the adversary revealed a vertex $v_{t_{1}+1}\neq t$. So far, the searcher traversed at least $k+2t_{1}$ edges. We show the current situation in Figure 1.

Next, the searcher has three visible but yet unvisited vertices left: $v_{t_{1}+1},p_{1},q_{1}$. In our construction, either $p_{1}$ or $q_{1}$ will lead to the end of the stem, but the searcher does not know which one to follow. However, the searcher could also approach the problem from “the other side” and visit $v_{t_{1}+1}$ next. If $p_{1}$ is visited, then the adversary uncovers another vertex $p_{2}$, similarly, if $q_{1}$ is visited, then the adversary uncovers $q_{2}$, and if $v_{t_{1}+1}$ is visited, then the adversary uncovers $v_{t_{1}+2}$, and so on. The adversary only needs to reveal if either type $p$ or $q$ vertices form the stem, when every vertex on the cycle is visible to the searcher. In the following, for ease of argumentation, we will make the searcher more powerful such that once all vertices on the cycle are visible to the searcher, we will reveal the whole graph to the searcher.

As the by us controlled adversary builds the graph, we now assume that there are $k\geq 4$ vertices $v_{t_{1}+1},\ldots,v_{t_{1}+k}$ between $t$ and $v_{t_{1}}$ on the cycle, leave the stem length undefined for now, just setting it to be less than $k$, and perform case distinction for the following two different cases.

Until all vertices on the cycle are visible to the searcher, assume that the searcher does not go back through the junction $t$ and the start $s$ to $v_{t_{1}}$, but just uncovers new vertices of type $p$ and $q$.

• •

W.l.o.g., we can assume that this situation occurs when the searcher is on vertex $p_{k-2}$ (where $p_{k-1}$ neighbors $p_{k}=v_{t_{1}+1}$, in turn a neighbor to $v_{t_{1}}$), where the furthest so far visited vertex of type $q$ is $q_{k^{\prime}}$ with $k-2>k^{\prime}$.222Essentially, as soon as the searcher visits a vertex of distance $k-2$ to $t$, we decide that this vertex path is of type $p$. So far, the searcher traversed at least $k+2t_{1}+k-2+2k^{\prime}$ edges. We now reveal the whole graph to the searcher and set the length of the stem to be $k^{\prime}+1$, i.e., the vertex $q_{k^{\prime}+1}$ is not yet visited. The current situation is shown in Figure 2

Now, it remains to visit the vertices $p_{k-1}=v_{t_{1}+2}$ and $v_{t_{1}+1}=p_{k}$, the stem vertex $q_{k^{\prime}+1}$, then returning to $s$. The shortest path to do so is exactly in this order, i.e., visit $p_{k-1}=v_{t_{1}+2}$ and $v_{t_{1}+1}=p_{k}$ (2 edges), then return to $t$ ($k$ edges), then visit $q_{k^{\prime}+1}$ and return to $t$ ($2(k^{\prime}+1)$ edges), then return to $s$ ($k$ edges). In total, the searcher traversed at least $k+2t_{1}+k-2+2k^{\prime}+2+k+2(k^{\prime}+1)+k=4k+2t_{1}+4k^{\prime}+2$ edges, whereas the optimal solution traverses every cycle edge once ($2k+t_{1}+1$) and every stem edge twice ($2(k^{\prime}+1)$), implying that $\texttt{OPT}=2k+t_{1}+2k^{\prime}+3$. The competitive ratio is hence $\geq 2-4/(3+2k+t_{1}+2k^{\prime})$.

As $0\leq t_{1}<k$ and $0\leq k^{\prime}<k$, for every fixed $1>\varepsilon>0$, we achieve a competitive ratio greater than $2-\varepsilon$ by e.g. selecting $k\in\mathbb{N}_{\geq 4}$ such that $\varepsilon>4/(3+2k)$, i.e., $k>-3/2+2/\varepsilon$. 2. 2.

It remains to cover the remaining case, i.e., that until all vertices on the cycle are visible to the searcher, the searcher goes at least once back through $t$ via $s$ to $v_{t_{1}}$. If the searcher is then on vertex $p_{k-2}$, we ignore the journey to $v_{t_{1}}$ (the searcher traversed the edges for free) and refer to Case 1 above. Else, w.l.o.g., assume that the two remaining unvisited vertices on the cycle are $p_{k_{1}+1}$ and $p_{k_{1}+2}$, with $k_{1}<k-2$, where the most distant vertex visited on the stem so far is (analogously as above) w.l.o.g. $q_{k_{2}}$, with $k_{2}\leq k_{1}$. We now reveal the whole graph to the searcher, finishing the stem with the unvisited (but visible) vertex $q_{k_{2}+1}$. In other words, it remains to visit $p_{k_{1}+1}$ and $p_{k_{1}+2}$, $q_{k_{2}+1}$, and return to $s$. The current situation is shown in Figure 3.

We now perform a case distinction depending on if the searcher is currently either on the vertex $p_{k_{1}+3}$ or the vertex $p_{k_{1}}$.

1. (a)

The searcher is currently on $p_{k_{1}+3}$. So far, the searcher traversed at least $k+2t_{1}+2k_{1}+2k_{2}+k+t_{1}+1+k-k_{1}-3=3k+3t_{1}+1k_{1}+2k_{2}-2$ edges. In order to reach the end of the stem on the shortest path (visiting $p_{k_{1}+1},p_{k_{1}+2}$ on the way), $k_{1}+3$ (to the junction) and then $k_{2}+1$ edges are needed. To return to $s$ on the shortest path, $k_{2}+1+k$ edges must be traversed. Hence, the total route takes at least $3k+3t_{1}+k_{1}+2k_{2}-2+k_{1}+3+2(k_{2}+1)+k=4k+3t_{1}+2k_{1}+4k_{2}+3$ edge traversals. The optimal solutions traverses every cycle edge once ($2k+t_{1}+1$) and every stem edge twice ($2(k_{2}+1)$), setting setting $\texttt{OPT}=2k+t_{1}+2k_{2}+3$. To obtain a lower bound on the competitive ratio, we observe that $4k+3t_{1}+2k_{1}+4k_{2}+3>4k+2t_{1}+4k_{2}+2$, i.e., we obtain again (as in Case 1) a competitive ratio of $\geq 2-4/(3+2k+t_{1}+2k^{\prime})$. 2. (b)

It remains to cover the case that the searcher is currently on $p_{k_{1}}$. In this case, the searcher, after being at the junction $t$, also traveled to $q_{k_{2}}$ and $p_{k_{1}+3}=v_{t_{1}+k-k_{1}-2}$. So far, the searcher traversed at least $k+2t_{1}+k_{1}+2k_{2}+2(k+t_{1}+k-k_{1}-2)=5k+4t_{1}-k_{1}+2k_{2}-4$ edges. In order to visit the last three unvisited vertices $p_{k_{1}+2}=v_{t_{1}+k-k_{1}-1}$, $p_{k_{1}+1}=v_{t_{1}+k-k_{1}}$, $q_{k_{2}+1}$ (the end of the stem), and return to $s$, all on a shortest path, the searcher does the following: First visit $p_{k_{1}+1}=v_{t_{1}+k-k_{1}}$, $p_{k_{1}+2}=v_{t_{1}+k-k_{1}-1}$ (2 edges), then the end of the stem ($2+k_{1}+k_{2}+1$ edges), then return to $s$ ($k_{2}+1+k$ edges), i.e., $k+k_{1}+2k_{2}+6$ additional edges. In total, the searcher traversed at least $5k+4t_{1}-k_{1}+2k_{2}-4+k+k_{1}+2k_{2}+6=6k+4t_{1}+4k_{2}+2$ edges. As before, the optimal solutions traverses every cycle edge once ($2k+t_{1}+1$) and every stem edge twice ($2(k_{2}+1)$), setting $\texttt{OPT}=2k+t_{1}+2k_{2}+3$. By observing that $6k+4t_{1}+4k_{2}+2\geq 4k+2t_{1}+4k_{2}+2$, we can again repeat the arguments from Case 1, selecting $k\in\mathbb{N}_{\geq 4}$ with $k>-3/2+1/\varepsilon$.

This completes the proof by case distinction. ∎

On the algorithmic side, a depth-first search achieves a matching competitive ratio for unit weight graphs, but has no guarantees for weighted graphs. We show that a greedy approach yields matching upper bounds for weighted graphs.

4 Greedy Exploration of Tadpole Graphs

In this section, we will utilize an amortized analysis to prove that a greedy exploration is at most $2$-competitive on tadpole graphs. We first formalize the notion of a greedy exploration algorithm in §4.1 along with some preliminary definitions and a simple upper cost bound, and then present our proof in §4.2.

4.1 Greedy Algorithm Preliminaries

We first define how a greedy algorithm explores the graph, and then introduce the notions of a step and charging edges for a step. Afterwards, we show how these definitions yield a simple first upper cost bound. We will utilize these definitions in the proof of the optimal upper bound statement in §4.2.

Definition 2**.**

A greedy exploration algorithm proceeds as follows, until every vertex is visited: From all vertices that are known but have not yet been visited, pick a vertex $w$ to which the best known path is shortest, and visit $w$ via this shortest path. Once all vertices have been visited, return to the starting vertex $s$ along a shortest path.

Step by step. It will be useful to introduce the notion of a step of the algorithm, where a step is the decision which previously unvisited vertex to visit next, plus the actual visit itself. As such, if a graph has $n$ vertices, a greedy online exploration algorithm takes $n-1$ steps and then return to the starting vertex $s$. For consistency, we consider the return to $s$ as a step as well, i.e., an exploration algorithm for $n$ vertices will perform $n$ steps in total.

Charging an edge for the next step. Consider the situation that the searcher is currently on a vertex $v$ with an unvisited neighbor $w$. If $v$ has more than one unvisited neighbor, let $w$ be the one that connects to $v$ with the cheapest edge. In the next step, a greedy exploration algorithm currently on a vertex $v$ will either $a)$ visit a yet unvisited neighboring vertex $w$ by traversing $e=(w,v)$ or $b)$ visit a yet unvisited vertex $w^{\prime}$ by a path $P$ that does not contain $(w,v)$, where not necessarily $w^{\prime}\neq w$. Due to the greedy nature of the exploration algorithm, in case $b)$ the cost of $P$ will be at most the cost of $e$, i.e., $c(P)\leq c(e)$ (Fig. 4). Similarly, in case $a)$ the cost $c(e)$ is cheaper than any other path to a yet unvisited vertex. Hence, for an amortized analysis, in such a situation we can say that we charge the cost of the next step to the edge $(w,v)$.

However, an exploration algorithm could also find itself in the situation that after performing a step, all neighboring vertices have been explored. In this case, there is no incident edge to charge:

Charging the actual path. Consider the situation that the searcher is currently on a vertex $v$ without an unvisited neighbor or that all vertices have already been visited, but $v\neq s$. Then, for the next step (which can also be the return to $s$), we say that we charge the cost of the actually taken path to said path, i.e., the cost of each traversed edge.

A first upper cost bound. We now combine both charging ideas for a first simple upper bound, to give some intuition for the upcoming proof in §4.2. To this end, we ask the question how often we cannot charge an edge for the next step—but rather have to charge the actual path taken. By definition, this can only be the case if there is no unvisited neighbor $w$ of the current vertex $v$. Such a situation can occur only in two cases:

The searcher is not on $s$ and at the end of the stem, or 2. 2.

the searcher is on the cycle, and all cycle vertices have been visited.

Regarding the first case, if the end of the stem is $s$, then we will only be on $s$ at the beginning (where we have an unvisited neighbor) or upon completion of the algorithm.

For the second case, assume not all cycle vertices have been visited, but that on the current node $v$ (at the beginning of a step), the searcher has no unvisited neighbors. We now show by contradiction that this cannot be the case. Denote the neighbors of the current vertex $v$ on the cycle by $w^{\prime}$ and $w^{\prime\prime}$: when they were visited for the first time, it was either because they were $s$ or because they were at the end of a step. Similarly, $v$ was visited for the first time at the end of a step. However, in order to visit both $w^{\prime},w^{\prime\prime}$ without visiting $v$, all vertices between $w^{\prime},w^{\prime\prime}$ on the cycle must have been visited, a contradiction.

Hence, both cases will only occur at most once until the algorithm has completed its exploration, as the searcher will not choose an already explored vertex for the endpoint of a step (unless it is the return to $s$ in the last step). As thus, charging a path will only happen twice, and for the second time, it is the return to $s$, i.e., the final step.

Here it is important to note that the greedy algorithm will only charge an edge $e=(x,y)$ when it connects the current node (w.l.o.g. $x$) to an unvisited node $y$. It can thus never charge an edge $e=(x,y)$ twice333We note that we defined charging a path differently than charging an edge, even if the path is of length $1$., as the searcher will only be on $x$ once at the beginning of a step. Hence, a greedy exploration algorithm will charge every edge at most once, and charge at most two paths, i.e., the total exploration cost is at most three times all edge weights in the tadpole graph. We will next improve this simple bound.

4.2 Achieving 2-competitiveness on Tadpoles via a Greedy Algorithm

Our first simple upper bound at the end of §4.1 is still far from the desired 2-competitiveness: In our amortized analysis, we would like to include the cost of an edge only twice as often as an optimal solution uses it. Furthermore, an optimal solution might skip a very expensive cycle edge. To this end, we first investigate the optimal tour shapes and costs.

Shape of the optimal tour. Observe that the optimal tour for a tadpole graph consists of $a)$ the optimal walk through the cycle [20] and $b)$ twice the attached path (stem). Thus, an optimal tour has one of the following two shapes:

Traverse all the edges in the cycle once and all edges in the stem twice. 2. 2.

Traverse all the edges in the cycle, except for one, twice, and the stem twice. The excluded edge $e_{\infty}$ has a weight of at least the remaining cycle.

To break ties, we say that Shape 1 is optimal, in case both have the same cost. As such, we assume in the second case that $e_{\infty}$ has a weight greater than the remaining cycle.

Cost of the optimal tour. For our analysis, denote the $|E|=m$ edges in the tadpole graph by $e_{1},\ldots,e_{m}$, where we set $i)$ the stem edges to be $e_{1},\ldots e_{j}$, $1\leq j\leq m-3$ and the cycle edges to be $e_{j+1},\ldots,e_{m}$, and $ii)$ $e_{m}=e_{\infty}$ in the case of Shape 2. It follows that:

An optimal tour of Shape 1 has a cost of $\sum_{i=1}^{j}{2c(e_{i})}+\sum_{i=j+1}^{m}{1c(e_{i})}$, 2. 2.

an optimal tour of Shape 2 has a cost of $\sum_{i=1}^{m-1}{2c(e_{i})}$.

Using the above optimal tour costs, we now prove the promised upper bound:

Theorem 3**.**

A greedy exploration algorithm has a competitive ratio of $2$ on weighted tadpole graphs.

Proof.

We prove the theorem statement by case distinction for tadpole graphs of Shape 1 or of Shape 2. We begin with Shape 2.

Shape 2. We show the theorem statement for Shape 2 by proving that a greedy exploration algorithm incurs a cost of at most $2\left(\sum_{i=1}^{m-1}{2c(e_{i})}\right)$.

First observe that the greedy exploration algorithm will never traverse the edge $e_{\infty}$, as its weight is greater than the remaining cycle edges combined.

We now consider the incurred costs of the greedy algorithm until it is, at the end of a step, on a vertex incident to $e_{\infty}$ or on a vertex with no unvisited neighbors. Note that this situation will happen up to three times, twice when visiting the endpoints of the edge $e_{\infty}$ and once when on the end of the stem.

Let this situation occur for the first time after ${t_{1}}$ steps. So far, in each step ${h}$, $1\leq h\leq t_{1}$, we can charge the cost of the step to some edge $e_{a_{h}}\in E$, with $e_{a_{h}}\neq e_{a_{h^{\prime}}}$ for $h\neq h^{\prime}$.444We introduce the notation $e_{a_{h}}$ as the edge $e_{a_{h}}$ can be different from the edge $e_{h}$. Recall that we either traverse the edge $e_{a_{h}}$ directly with cost $c(e_{a_{h}})$ or traverse a path with cost at most $c(e_{a_{h}})$, see Figure 4. Hence, the cost of step ${h}$ is at most $c(e_{a_{h}})$, with $e_{a_{h}}\neq e_{\infty}$, and after ${t_{1}}$ steps we incur costs of at most $\sum_{i={1}}^{{t_{1}}}{c(e_{a_{i}})}$, with $\{e_{a_{1}},\ldots,e_{a_{t_{1}}}\}\subset\{e_{1},\ldots,e_{m-1}\}$. Note that if ${t_{1}}=0$, the cost so far is 0.

We now consider the cost of step ${t_{1}}+1$. We can upper bound its cost by $\sum_{i=1}^{m-1}{c(e_{i})}$, which suffices for the rest of the analysis.

We next consider the second time when we are on one of the endpoints of $e_{\infty}$ or on the end of the stem, after $t_{2}\geq t_{1}+1$ steps. Using our charging technique, we can bound the cost incurred after step $t_{1}+1$ to and including step $t_{2}$ by $\sum_{i={t_{1}+2}}^{{t_{2}}}{c(e_{a_{i}})}$, for $t_{2}>t_{1}+1$, with $\{e_{a_{1}},\ldots,e_{a_{t_{1}}}\}\cap\{e_{a_{t_{1}+2}},\ldots,e_{a_{t_{2}}}\}=\emptyset$ and $\{e_{a_{t_{1}+2}},\ldots,e_{a_{t_{2}}}\}\subset\{e_{1},\ldots,e_{m-1}\}$, as we charge every edge at most once. If $t_{2}=t_{1}+1$, then this cost is 0.

For step $t_{2}+1$, we again upper bound its cost being at most $\sum_{i=1}^{m-1}{c(e_{i})}$, which suffices for the rest of the analysis.

We now consider the third and last time when we are on one of the endpoints of $e_{\infty}$ or on the end of the stem, after $t_{3}\geq t_{2}+1$ steps. As above, we can bound the cost incurred after step $t_{2}+1$ to and including step $t_{3}$ by $\sum_{i={t_{2}+2}}^{{t_{3}}}{c(e_{a_{i}})}$, for $t_{3}>t_{2}+1$, with $\left(\{e_{a_{1}},\ldots,e_{a_{t_{1}}}\}\cup\{e_{a_{t_{1}+2}},\ldots,e_{a_{t_{2}}}\}\right)\cap\{e_{a_{t_{2}+2}},\ldots,e_{a_{t_{3}}}\}=\emptyset$ and $\{e_{a_{t_{2}+2}},\ldots,e_{a_{t_{3}}}\}\subset\{e_{1},\ldots,e_{m-1}\}$, as again, we charge every edge at most once. If $t_{3}=t_{2}+1$, then this cost is 0.

Once both endpoints of $e_{\infty}$ and the end of the stem are visited (the case after step $t_{3}$), it remains to return to $s$, i.e., in step $t_{3}+1$. We again upper bound its cost to being at most $\sum_{i=1}^{m-1}{c(e_{i})}$. When we sum up all costs, we incur the cost of each edge $e\neq e_{\infty}$ at most once, plus $3\left(\sum_{i=1}^{m-1}{c(e_{i})}\right)$. In other words, the greedy algorithm has a cost of at most $4\left(\sum_{i=1}^{m-1}{c(e_{i})}\right)=2\left(\sum_{i=1}^{m-1}2{c(e_{i})}\right)$, which completes the analysis for Shape 2.555Recall that we never charge an edge twice and for Shape 2, we never traverse $e_{\infty}$. It remains to investigate Shape 1.

Shape 1. We show the theorem statement for Shape 1 by proving that a greedy algorithm incurs a cost of at most $2\left(\sum_{i=1}^{j}{2c(e_{i})}+\sum_{i=j+1}^{m}{1c(e_{i})}\right)$, where the edges $e_{1},\ldots,e_{j}$ form the stem of the tadpole graph. We will analyze Shape 1 by case distinction, depending which of the following situations occur:

1. (1)

The starting vertex $s$ is not the end of the stem. 2. (2)

The starting vertex $s$ is the end of the stem.

Case (1) is divided into two subcases:

1. (1a)

The searcher visits the end of the stem before visiting all vertices on the cycle. 2. (1b)

The searcher visits all vertices on the cycle before visiting the end of the stem.

The underlying idea for this case distinction is as follows: until the searcher visits the end of the stem or has visited all vertices in the cycle, there is always an unvisited neighbor $w$ such that from the current vertex $v$, we can charge the so far uncharged edge $e=(v,w)$ for the cost of the next step with cost at most $c(e)$.

• •

We start with Case (1a), where the searcher visits the end of the stem (not being $s$), before visiting all vertices on the cycle.

In this case, assume the searcher performed $t_{1}$ steps so far. In each step $1\leq h\leq t_{1}$, the searcher can charge the cost of the step to an incident edge $e_{a_{h}}$, where $e_{a_{h}}\neq e_{a_{h}^{\prime}}$ for $h\neq h^{\prime}$, i.e., with a cost of at most $c(e_{a_{h}})$.

Next, consider the step $t_{2}>t_{1}$ where the searcher visits for the first time after step $t_{1}$ a yet unvisited vertex $v_{t_{2}}$ on the cycle, possibly the junction $t$. The cost of the steps $t_{1}+1,\ldots,t_{2}$ is exactly the cost of traversing all stem edges once $(c(e_{1})+\ldots+c(e_{j}))$ plus the cost of traversing the shortest path between $t$ and $v_{t_{2}}$, being zero cost for $t=v_{t_{2}}$ and else consisting of the pairwise distinct cycle edges $e_{b_{1}},\ldots,e_{b_{k}}$.

We now consider the steps $t_{2}+1$ to $t_{3}$, where after step $t_{3}$ the searcher has no incident edge to charge, i.e., all vertices on the cycle are visited. Using the charging scheme, the cost of the steps can be bounded by the summed up cost of $t_{3}-t_{2}$ further pairwise distinct cycle edges $e_{a_{t_{2}+1}},\ldots,e_{a_{t_{3}}}$, with $\{e_{a_{t_{2}+1}},\ldots,e_{a_{t_{3}}}\}\cap\{e_{a_{1}},\ldots,e_{t_{1}}\}=\emptyset$, as here we just charge edges we have not charged in the steps $1,\ldots,t_{1}$.

It remains to return to $s$ in step $t_{3}+1$. Let the summed up cost of all cycle edges be $C$. Observe that we can bound the cost of step $t_{3}+1$ by the summed up cost of all stem edges $e_{1},\ldots,e_{j}$ plus at most $0.5C$. The latter holds as the shortest path between any two vertices on the cycle has always a cost of at most $0.5C$. Analogously, it holds that $0.5C\geq\sum_{i=1}^{k}{c(e_{b_{i}})}$.

We now consider the total cost incurred in this case, where it holds that $\sum_{i=1}^{t_{1}}{c(e_{a_{i}})}+\sum_{i=t_{2}+1}^{t_{3}}{c(e_{a_{i}})}\leq\sum_{i=1}^{m}{c(e_{i})}$, as we charge each tadpole edge at most once in the steps $1,\ldots,t_{1},t_{2}+1,\ldots,t_{3}$. For the steps $t_{1}+1$ to $t_{2}$, the total cost is $\sum_{i=1}^{j}{c(e_{i})}+\sum_{i=1}^{k}{c(e_{b_{i}})}$, with $\sum_{i=1}^{k}{c(e_{b_{i}})}\leq 0.5C$. With the final step $t_{3}+1$ incurring a cost of at most $0.5C+\sum_{i=1}^{j}{c(e_{i})}$ it holds that: $\sum_{i=1}^{m}{c(e_{i})}+\sum_{i=1}^{j}{c(e_{i})}+0.5C+0.5C+\sum_{i=1}^{j}{c(e_{i})}=\sum_{i=1}^{m}{c(e_{i})}+2\left(\sum_{i=1}^{j}{c(e_{i})}\right)+\sum_{i=j+1}^{m}{c(e_{i})}\leq 2\left(\sum_{i=1}^{j}{2c(e_{i})}+\sum_{i=j+1}^{m}{1c(e_{i})}\right)$ .

• •

We now cover the Case (1b), where we do not start at the end of the stem, and visit all vertices on the cycle before visiting the end of the stem. Assume that the searcher so far performed $t_{1}$ steps, where we charge $t_{1}$ pairwise distinct edges for a total cost of at most $\sum_{i=1}^{m}{c(e_{i})}$.

Next, assume that the searcher reached the end of the stem by step $t_{2}$. Observe that in the steps $t_{1}+1,\ldots,t_{2}$, the searcher simply walks to the end of the stem on a simple shortest path, as all cycle vertices are already explored. The incurred costs are at most $0.5C+\sum_{i=1}^{j}{c(e_{i})}$.

It remains to return to the starting vertex $s$. Again, we can bound the cost of doing so by at most $0.5C+\sum_{i=1}^{j}{c(e_{i})}$.

The total incurred costs are at most $\sum_{i=1}^{m}{c(e_{i})}+2\left(\sum_{i=1}^{j}{c(e_{i})}\right)+C=3\left(\sum_{i=1}^{j}{c(e_{i})}\right)+2\left(\sum_{i=j+1}^{m}{c(e_{i})}\right)\leq 2\left(\sum_{i=1}^{j}{2c(e_{i})}+\sum_{i=j+1}^{m}{1c(e_{i})}\right)$ .

• •

It remains to cover the Case (2) where the searcher starts on the end of the stem. In this case, it will take $n-1$ steps until the last vertex (on the cycle) is visited. For each step, a different edge will be charged, leading to a cost bounded by $\sum_{i=1}^{m}{c(e_{i})}$. Afterwards, the searcher returns to $s$ on a shortest path, where we can again bound the cost by $\sum_{i=1}^{m}{c(e_{i})}$.

As such, we showed 2-competitiveness for all cases in both Shape 1 and Shape 2. ∎

5 Beyond 2-Competitiveness with Advice

In order to obtain an improved competitive ratio, one can leverage the model of advice complexity for graph exploration [22, 23]. Herein, an all-knowing oracle can equip the searcher with a bit string before initial execution (the advice), which the exploration algorithm can leverage for improved performance.

2 bits of advice for tadpole graphs. Already 2 bits of advice suffice to obtain a competitive ratio of $\frac{1+\sqrt{3}}{2}\approx 1.366$, where, if the searcher does not start on the junction, the first bit indicates if the searcher starts on the stem or not. In case the searcher does not start on the stem and not on the junction, then the second bit can be used to indicate which neighboring vertex of the junction forms the beginning of the stem, as the vertices have unique identifiers. To this end, as the oracle knows the deterministic algorithm of the searcher, it knows which two choices remain at the junction, where a choice from a local ordering of the 2 identifiers can be performed with 1 bit. Lastly, if the searcher starts on the junction, then the 2 bits can be used to indicate which choice leads to the stem. Equipped with these 2 bits, the searcher acts as follows.

When starting on the stem (not on the junction), one proceeds in an arbitrary direction until either the end of the stem is reached, in which case one turns around towards the junction, or until the junction is reached. In that case, the $\frac{1+\sqrt{3}}{2}$ competitive cycle exploration algorithm by Miyazaki et al. [10] is used (where we use the junction vertex $t$ as the starting point), after which the searcher proceeds on a shortest path to $s$, possibly after visiting the end of the stem and returning to $s$. By doing so, the searcher traverses every edge of the stem twice (which is optimal), and explores the cycle itself with a competitive ratio of $\frac{1+\sqrt{3}}{2}$. Hence, the total competitive ratio is at most $\frac{1+\sqrt{3}}{2}$.

When not starting on the stem and not on the junction, the searcher runs the $\frac{1+\sqrt{3}}{2}$-competitive algorithm of Miyazaki et al. [10] as well, but when reaching the junction for the first time, the searcher explores the stem by traversing every stem edge twice (using the second advice bit), and then continues with the cycle exploration. Again, the competitive ratio is at most $\frac{1+\sqrt{3}}{2}$.

When starting on the junction, the searcher uses the 2 bits to explore the stem first and return to $s$ (each stem edge twice) and then uses the $\frac{1+\sqrt{3}}{2}$-competitive algorithm of Miyazaki et al. [10] for the cycle exploration, finishing the case distinction. We cast our insights into the following theorem:

Theorem 4**.**

2 bits of advice suffice to explore weighted tadpole graphs with a competitive ratio of $\frac{1+\sqrt{3}}{2}$.

Before giving an advice scheme that provides optimal exploration for tadpole graphs, we first present how to obtain optimal exploration for cycles.

Optimality for cycles. In order to obtain $1$-competitiveness for cycles, it suffices to mark the edge $e_{\infty}$ for Shape 2 (traverse all edges except $e_{\infty}$ twice) respectively to indicate if the current graph is of Shape 1 (traverse all edges in the cycle exactly once). As the oracle knows all actions of the deterministic searcher ahead of time, it knows in which order the $m$ edges will be made visible to the searcher. In each step, only one edge will be revealed, except at the start, where we assume that the edge incident to the neighbor with lower identifier is the first in this order.

We now show how $\lceil\log_{2}(n)\rceil$ bits suffice to mark the edge and also indicate Shape 1, on cycle graphs, where $n=m$ holds.

In order to indicate Shape 1, we simply mark an edge incident to $s$ with lowest weight, which cannot be $e_{\infty}$, as $e_{\infty}$ has a greater weight than the remaining cycle, and the searcher traverses every edge once, being optimal for Shape 1.

Else, the searcher knows that Shape 2 was indicated, and traverses the cycle in a deterministic direction (e.g., starting with the neighbor with a lower identifier), until the edge $e_{\infty}$ is revealed. Then, the searcher turns around, explores the cycle until the edge $e_{\infty}$ appears again, and returns to the start, being optimal for Shape 2. Hence the following theorem holds:

Theorem 5**.**

$\lceil\log_{2}(n)\rceil$* bits of advice suffice to explore weighted cycle graphs with a competitive ratio of $1$.*

The usage of 2 additional bits, as before, could now be leveraged to obtain a competitive ratio of 1 on tadpole graphs, i.e., with $\lceil\log_{2}(n)\rceil+2$ bits. However, we can improve this result to only require 1 extra bit.

Optimality for tadpoles. We now assume that Shape 1 is indicated if all bits from the first $\lceil\log_{2}(n)\rceil$ bits of advice are set to zero, and that else Shape 2 is indicated to the searcher.666Unlike in cycles, in tadpole graphs, the starting node $s$ could be on the stem and hence marking the cheaper incident edge for Shape 1 does not suffice, as both incident edges could have the same weight. We now show how $\lceil\log_{2}(n)\rceil+1$ bits of advice suffice for optimality on tadpole graphs.

In the case of Shape 2, the searcher can virtually remove $e_{\infty}$ from the graph, as for the cycle, and the remaining graph essentially consists of three stems. Note that due to using $\lceil\log_{2}(n)\rceil+1$ bits, we have sufficient bits to indicate which revealed edge is $e_{\infty}$, even while reserving advice with the first $\lceil\log_{2}(n)\rceil$ bits as zero for Shape 1.

The searcher can detect all three ends of the stems (one is of degree 1 and the other two are endpoints of $e_{\infty}$). When the searcher reaches each end of the stem, the searcher simply backtracks. At the junction, the searcher may encounter two unknown edges, but either one may be traversed first, so no additional advice is needed.

In the case of Shape 1, the first $\lceil\log_{2}(n)\rceil$ bits of advice are set to zero (there is no edge to avoid traversing) and we need to use one additional bit of advice at the junction, to indicate in which direction (of the two) the searcher should proceed next. The searcher’s strategy is as follows:

• •

At the beginning, the searcher departs in any direction.

• •

When the searcher is at the junction for the first time after the beginning, the searcher follows the one bit of advice.

• •

When the searcher reaches the end of the stem, the searcher backtracks.

In case the starting vertex is on the stem (except for the junction), the extra bit of advice may be arbitrary (or may be ignored), because both of the new two edges at the junction are on the cycle. In case the starting vertex is on the cycle (except for the junction), the advice bit indicates the edge on the stem and the searcher traverses the stem first. Finally, suppose that the starting vertex is the junction. If the edge chosen at the beginning is on the stem, then the searcher will know this fact when he reaches the end of the stem. If the chosen edge is on the cycle, then he will know this fact when he comes back to the junction, so he may go towards the third (unknown) edge. In either case, the additional one bit may be ignored. We again cast our insights into the following theorem:

Theorem 6**.**

$\lceil\log_{2}(n)\rceil+1$* bits of advice suffice to explore weighted tadpole graphs with a competitive ratio of $1$.*

6 Conclusion and Outlook

We studied the online exploration of tadpole graphs, showing that a greedy exploration achieves a competitive ratio of 2. Our results also hold on weighted graphs, with a matching lower bound of $2-\varepsilon$ already on unit weight tadpoles. The latter extends the results of Miyazaki et al.’s [10, § 4.2] lower bound, which required the graph to be either a tree or a tadpole.

Moreover, we have also presented the first non-trivial graph class where a greedy graph exploration is optimal from a competitive point of view, and provided first insights into the advice complexity of cycle and tadpole graphs.

We see our work as a step towards charting the landscape of graph exploration, a problem which continues to puzzle researchers for many decades. Next research directions could be the investigation of more broad graph classes, such as lollipop graphs, barbell graphs, or wheel graphs, or the bound improvements on unicyclic and cactus graphs, with the hope that a better understanding of these specific graph structures will bring us closer to bridging the large gap for exploration on general graphs.

**Bibliographical note.

**A preliminary version of the results in this article appeared in [24].

**Acknowledgements.

**We would like to thank Nicole Megow for her feedback on the related work. We would also like to thank anonymous reviewers for their helpful comments, which among other details, lead to a better presentation of the upper bound proof. Moreover, it was also pointed out to us that Miyazaki et al.’s [10, § 4.2] lower bound proof required that the graph be either a tadpole or a tree, and we could hence strengthen their result such that the lower bound construction only requires tadpole graphs. Lastly, an anonymous reviewer also provided us with a proof on how the advice complexity for tadpole graphs could be lowered from $\lceil\log_{2}(n)\rceil+2$ to $\lceil\log_{2}(n)\rceil+1$ bits, for which we would like to express our thanks as well.