This work considers the problem of the noisy binary search in a sorted array. The noise is modeled by a parameter p that dictates that a comparison can be incorrect with probability p, independently of other queries. We state two types of upper bounds on the number of queries: the worst-case and expected query complexity scenarios. The bounds improve the ones known to date, i.e., our algorithms require fewer queries. Additionally, they have simpler statements, and work for the full range of parameters. All query complexities for the expected query scenarios are tight up to lower order terms. For the problem where the target prior is uniform over all possible inputs, we provide an algorithm with expected complexity upperbounded by (log₂ n + log₂ δ^{-1} + 3)/I(p), where n is the domain size, 0 ≤ p < 1/2 is the noise ratio, and δ > 0 is the failure probability, and I(p) is the information gain function. As a side-effect, we close some correctness issues regarding previous work. Also, en route, we obtain new and improved query complexities for the search generalized to arbitrary graphs. This paper continues and improves the lines of research of Burnashev-Zigangirov [Prob. Per. Informatsii, 1974], Ben-Or and Hassidim [FOCS 2008], Gu and Xu [STOC 2023], and Emamjomeh-Zadeh et al. [STOC 2016], Dereniowski et al. [SOSA@SODA 2019].

Abstract Depth first search is a natural algorithmic technique for constructing a closed route that visits all vertices of a graph. The length of such a route equals, in an edge-weighted tree, twice the total weight of all edges of the tree and this is asymptotically optimal over all exploration strategies. This paper considers a variant of such search strategies where the length of each route is bounded by a positive integer B (e.g. due to limited energy resources of the searcher). The objective is to cover all the edges of a tree T using the minimum number of routes, each starting and ending at the root and each being of length at most B. To this end, we analyze the following natural greedy tree traversal process that is based on decomposing a depth first search traversal into a sequence of limited length routes. Given any arbitrary depth first search traversal R of the tree T, we cover R with routes $$R_1,\ldots ,R_l$$ R 1 , … , R l , each of length at most B such that: $$R_i$$ R i starts at the root, reaches directly the farthest point of R visited by $$R_{i-1}$$ R i - 1 , then $$R_i$$ R i continues along the path R as far as possible, and finally $$R_i$$ R i returns to the root. We call the above algorithm piecemeal-DFS and we prove that it achieves the asymptotically minimal number of routes l, regardless of the choice of R. Our analysis also shows that the total length of the traversal (and thus the traversal time) of piecemeal-DFS is asymptotically minimum over all energy-constrained exploration strategies. The fact that R can be chosen arbitrarily means that the exploration strategy can be constructed in an online fashion when the input tree T is not known in advance. Each route $$R_i$$ R i can be constructed without any knowledge of the yet unvisited part of T. Surprisingly, our results show that depth first search is efficient for energy constrained exploration of trees, even though it is known that the same does not hold for energy constrained exploration of arbitrary graphs.

We consider a generalization of binary search in linear orders to the domain of weighted trees. The goal is to design an adaptive search strategy whose aim is to locate an unknown target vertex of a given tree. Each query to a vertex v incurs a non-negative cost ω(v) (that can be interpreted as the duration of the query) and returns a feedback that either v is the target or the edge incident to v is given that is on the path towards the target. The goal of the algorithm is to find a strategy that minimizes the worst-case total cost. We propose a constant-factor approximation algorithm for trees with a monotonic cost function. Such function is defined as follows: there exists a vertex r such that for any two vertices u,v on any path connecting r with a leaf it holds that if u is closer to r than v, then ω(u) ≥ ω(v). The best known approximation algorithm for general weight functions has the ratio of O{√{log n}} [Dereniowski et al. ICALP 2017] and it remains as a challenging open question whether constant-factor approximation is achievable in such case. This gives our first motivation towards considering monotonic cost functions and the second one lies in the potential applications.

Abstract A robot modeled as a deterministic finite automaton has to build a structure from material available to it. The robot navigates in the infinite oriented grid $${\mathbb {Z}} \times {\mathbb {Z}}$$ Z × Z . Some cells of the grid are full (contain a brick) and others are empty. The subgraph of the grid induced by full cells, called the shape , is initially connected. The (Manhattan) distance between the furthest cells of the shape is called its span . The robot starts at a full cell. It can carry at most one brick at a time. At each step it can pick a brick from a full cell, move to an adjacent cell and drop a brick at an empty cell. The aim of the robot is to construct the most compact possible structure composed of all bricks, i.e., a nest . That is, the robot has to move all bricks in such a way that the span of the resulting shape be the smallest. Our main result is the design of a deterministic finite automaton that accomplishes this task and subsequently stops, for every initially connected shape, in time $$O(sn)$$ O ( s n ) , where s is the span of the initial shape and $$n$$ n is the number of bricks. We show that this complexity is optimal.

We present some characterizations of characteristic graphs of row and/or column symmetric channels. We also give a polynomial-time algorithm that decides whether there exists a discrete symmetric channel whose characteristic graph is equal to a given input graph. In addition, we show several applications of our results.

A robot modeled as a deterministic finite automaton has to build a structure from material available to it. The robot navigates in the infinite oriented grid $\mathbb{Z} \times \mathbb{Z}$. Some cells of the grid are full (contain a brick) and others are empty. The subgraph of the grid induced by full cells, called the field, is initially connected. The (Manhattan) distance between the farthest cells of the field is called its span. The robot starts at a full cell. It can carry at most one brick at a time. At each step it can pick a brick from a full cell, move to an adjacent cell and drop a brick at an empty cell. The aim of the robot is to construct the most compact possible structure composed of all bricks, i.e., a nest. That is, the robot has to move all bricks in such a way that the span of the resulting field be the smallest. Our main result is the design of a deterministic finite automaton that accomplishes this task and subsequently stops, for every initially connected field, in time $O(sz)$, where $s$ is the span of the initial field and $z$ is the number of bricks. We show that this complexity is optimal.

Abstract We consider the following on-line pursuit-evasion problem. A team of mobile agents called searchers starts at an arbitrary node of an unknown network. Their goal is to execute a search strategy that guarantees capturing a fast and invisible intruder regardless of its movements using as few searchers as possible. We require that the strategy is connected and monotone, that is, at each point of the execution the part of the graph that is guaranteed to be free of the fugitive is connected and whenever some node gains a property that it cannot be occupied by the fugitive, the strategy must operate in such a way to keep this property till its end. As a way of modeling two-dimensional shapes, we restrict our attention to networks that are embedded into partial grids: nodes are placed on the plane at integer coordinates and only nodes at distance one can be adjacent. Agents do not have any knowledge about the grapha priori, but they recognize the direction of the incident edge (up, down, left or right). We give an on-line algorithm for the searchers that allows them to compute a connected and monotone strategy that guarantees searching any unknown partial grid with the use of $O(\sqrt {n})$ O(n) searchers, wherenis the number of nodes in the grid. As for a lower bound, there exist partial grids that require ${\varOmega }(\sqrt {n})$ Ω(n) searchers. Moreover, we prove that for each on-line searching algorithm there is a partial grid that forces the algorithm to use ${\varOmega }(\sqrt {n})$ Ω(n) searchers but $O(\log n)$ O(logn) searchers are sufficient in the off-line scenario. This gives a lower bound on ${\varOmega }(\sqrt {n}/\log n)$ Ω(n/logn) in terms of achievable competitive ratio of any on-line algorithm.

In this work we consider two two-criteria optimization problems: given an input graph, the goal is to find its interval (or chordal) supergraph that minimizes the number of edges and its clique number simultaneously. For the interval supergraph, the problem can be restated as simultaneous minimization of the path width pw(G) and the profile p(G) of the input graph G. We prove that for an arbitrary graph G and an integer t ∈ {1, … , pw(G) + 1}, there exists an interval supergraph G′ of G such that for its clique number it holds $\omega (G^{\prime })\leq (1+\frac {2}{t})(\textup {\texttt {pw}}({G})+ 1)$ and the number of its edges is bounded by |E(G′)| ≤ (t + 2)p(G). In other words, the pathwidth and the profile of a graph can be simultaneously minimized within the factors of $1+\frac {2}{t}$ (plus a small constant) and t + 2, respectively. Note that for a fixed t, both upper bounds provide constant factor approximations. On the negative side, we show an example that proves that, for some graphs, there is no solution in which both parameters are optimal. In case of finding a chordal supergraph, the two corresponding graph parameters that reflect its clique size and number of edges are the treewidth and fill-in. We obtain that the treewidth and the fill-in problems are also ‘orthogonal’ in the sense that for some graphs, a solution that minimizes one of those parameters cannot minimize the other. As a motivating example, we recall graph searching games which illustrates a need of simultaneous minimization of these pairs of graph parameters.

In this work we consider the edge searching problem for vertex-weighted graphs with arbitrarily fast and invisible fugitive. The weight function $${\omega }$$ provides for each vertex $$v$$ the minimum number of searchers required to guard $$v$$ , i.e., the fugitive may not pass through $$v$$ without being detected only if at least $${\omega }(v)$$ searchers are present at $$v$$ . This problem is a generalization of the classical edge searching problem, in which one has $${\omega }\equiv 1$$ . We assume that with a graph $$G$$ to be searched, there is associated a partition $$(V_1,\ldots ,V_t)$$ of its vertex set such that edges are allowed only within each $$V_i$$ and between two consecutive $$V_i$$ ’s. We provide an algorithm for distributed monotone connected edge searching of such graphs, where the searchers are initially placed on an arbitrary vertex of $$G$$ and have no a priori knowledge on $$G$$ , but they have a sense of direction that lets them recognize whether an edge incident to already explored vertex in $$V_i$$ leads to a vertex in one of $$V_{i-1}, V_i$$ or $$V_{i+1}$$ . Starting from any vertex the algorithm uses at most $$3\cdot \max _{i=1,\ldots ,t}{\omega }(V_i)+1$$ searchers, where $${\omega }(V_i) = \sum _{v\in V_i}{\omega }(v)$$ . We also prove that this algorithm is best possible up to a small additive constant, that is, each distributed searching algorithm in worst case must use $$3\cdot \max _{i=1,\ldots ,t}{\omega }(V_i)-1$$ searchers for some graphs.

The rotor-router mechanism was introduced as a deterministic alternative to the random walk in undirected graphs. In this model, a set of k identical walkers is deployed in parallel, starting from a chosen subset of nodes, and moving around the graph in synchronous steps. During the process, each node maintains a cyclic ordering of its outgoing arcs, and successively propagates walkers which visit it along its outgoing arcs in round-robin fashion, according to the fixed ordering. We consider the cover time of such a system, i.e., the number of steps after which each node has been visited by at least one walk, regardless of the starting locations of the walks. In the case of k=1, [Yanovski et al., 2003] and [Bampas et al., 2009] showed that a single walk achieves a cover time of exactly Theta(mD) for any n-node graph with m edges and diameter D, and that the walker eventually stabilizes to a traversal of an Eulerian circuit on the set of all directed edges of the graph. For k>1 parallel walks, no similar structural behaviour can be observed. In this work we provide tight bounds on the cover time of k parallel rotor walks in a graph. We show that this cover time is at most (mD/log(k)) and at least Theta(mD/k) for any graph, which corresponds to a speedup of between Theta(log(k)) and Theta(k) with respect to the cover time of a single walk. Both of these extremal values of speedup are achieved for some graph classes. Our results hold for up to a polynomially large number of walks, k=O(poly(n)).

We consider the problem of leader election among mobile agents operating in an arbitrary network modeled as an undirected graph. Nodes of the network are unlabeled and all agents are identical. Hence the only way to elect a leader among agents is by exploiting asymmetries in their initial positions in the graph. Agents do not know the graph or their positions in it, hence they must gain this knowledge by navigating in the graph and share it with other agents to accomplish leader election. This can be done using meetings of agents, which is difficult because of their asynchronous nature: an adversary has total control over the speed of agents. When can a leader be elected in this adversarial scenario and how to do it? We give a complete answer to this question by characterizing all initial configurations for which leader election is possible and by constructing an algorithm that accomplishes leader election for all configurations for which this can be done.

We consider the problem of covering the edges of a graph by a sequence of matchings subject to the constraint that each edge e appears in at least a given fraction r ( e ) of the matchings. Although it can be determined in polynomial time whether such a sequence of matchings exists or not [Grötschel et al., Combinatorica (1981), 169–197], we show that several questions about the length of the sequence are computationally intractable. Therefore, as is commonly done [Golumbic, Algorithmic graph theory and perfect graphs, 2004], we restrict our investigation to a special class of graphs. In recent work [Birand et al., INFOCOM 2010 Proceedings, 2010], two of the authors dealt with so‐called OLoP ( Overall Local Pooling ) graphs, a class of graphs for which similar matching‐related problems are tractable (namely, in an online distributed wireless network scheduling setting). We therefore focus on these graphs and generalize the results to a larger class of graphs which we call GOLoP graphs. In particular, we show that deciding whether a given GOLoP graph has a matching sequence of length at most k can be done in linear time. In case the answer is affirmative, we show how to construct, in quadratic time, the matching sequence of length at most k . Finally, we prove that, for GOLoP graphs, the length of a shortest sequence does not exceed a constant times the least common denominator of the fractions r ( e ), leading to a pseudopolynomial‐time algorithm for minimizing the length of the sequence. We show that the constant equals 1 for OLoP graphs and, following Seymour [Seymour, Proc. London Math. Soc., 1979], conjecture that the constant is as small as 2 for general graphs. We then show that this conjecture holds for all graphs with at most 10 vertices. © 2013 Wiley Periodicals, Inc. NETWORKS, Vol 62(3), 165–182 2013

It is proven that the connected pathwidth of any graph $G$ is at most $2\cdot\textup{pw}(G)+1$, where $\textup{pw}(G)$ is the pathwidth of $G$. The method is constructive, i.e., it yields an efficient algorithm that for a given path decomposition of width $k$ computes a connected path decomposition of width at most $2k+1$. The running time of the algorithm is $O(dk^2)$, where $d$ is the number of “bags” in the input path decomposition. The motivation for studying connected path decompositions comes from the connection between the pathwidth and the search number of a graph. One of the advantages of the above bound for connected pathwidth is an inequality $\textup{\texttt{cs}}(G)\leq 2\textup{\texttt{s}}(G)+3$, where $\textup{\texttt{cs}}(G)$ and $\textup{\texttt{s}}(G)$ are the connected search number and the search number of $G$, respectively. Moreover, the algorithm presented in this work can be used to convert a given search strategy using $k$ searchers into a (monotone) connected one using $2k+3$ searchers and starting at an arbitrary homebase.

It is proven that the connected pathwidth of any graph G is at most 2*pw(G)+1, where pw(G) is the pathwidth of G. The method is constructive, i.e. it yields an efficient algorithm that for a given path decomposition of width k computes a connected path decomposition of width at most 2k+1. The running time of the algorithm is O(dk^2), where d is the number of `bags' in the input path decomposition. The motivation for studying connected path decompositions comes from the connection between the pathwidth and some graph searching games. One of the advantages of the above bound for connected pathwidth is an inequality $csn(G) <= 2*sn(G)+3$, where $csn(G)$ is the connected search number of a graph $G$ and $sn(G)$ is its search number, which holds for any graph $G$. Moreover, the algorithm presented in this work can be used to convert efficiently a given search strategy using $k$ searchers into a connected one using $2k+3$ searchers and starting at arbitrary homebase.