BFS Tree Research Articles

Inferring the Hidden Cascade Infection over Erdös-Rényi (ER) Random Graph

Finding hidden infected nodes is extremely important when information or diseases spread rapidly in a network because hints regarding the global properties of the diffusion dynamics can be provided, and effective control strategies for mitigating such spread can be derived. In this study, to understand the impact of the structure of the underlying network, a cascade infection-recovery problem is considered over an Erdös-Rényi (ER) random graph when a subset of infected nodes is partially observed. The goal is to reconstruct the underlying cascade that is likely to generate these observations. To address this, two algorithms are proposed: (i) a Neighbor-based recovery algorithm (NBRA(α)), where 0≤α≤1 is a control parameter, and (ii) a BFS tree-source-based recovery algorithm (BSRA). The first one simply counts the number of infected neighbors for candidate hidden cascade nodes and computes the possibility of infection from the neighbors by controlling the parameter α. The latter estimates the cascade sources first and computes the infection probability from the sources. A BFS tree approximation is used for the underlying ER random graph with respect to the sources for computing the infection probability because of the computational complexity in general loopy graphs. We then conducted various simulations to obtain the recovery performance of the two proposed algorithms. As a result, although the NBRA(α) uses only local information of the neighboring infection status, it recovers the hidden cascade infection well and is not significantly affected by the average degree of the ER random graph, whereas the BSRA works well on a local tree-like structure.

Tree++: Truncated Tree Based Graph Kernels

Graph-structured data arise ubiquitously in many application domains. A fundamental problem is to quantify their similarities. Graph kernels are often used for this purpose, which decompose graphs into substructures and compare these substructures. However, most of the existing graph kernels do not have the property of scale-adaptivity, i.e., they cannot compare graphs at multiple levels of granularities. Many real-world graphs such as molecules exhibit structure at varying levels of granularities. To tackle this problem, we propose a new graph kernel called Tree++ in this paper. At the heart of Tree++ is a graph kernel called the path-pattern graph kernel. The path-pattern graph kernel first builds a truncated BFS tree rooted at each vertex and then uses paths from the root to every vertex in the truncated BFS tree as features to represent graphs. The path-pattern graph kernel can only capture graph similarity at fine granularities. In order to capture graph similarity at coarse granularities, we incorporate a new concept called super path into it. The super path contains truncated BFS trees rooted at the vertices in a path. Our evaluation on a variety of real-world graphs demonstrates that Tree++ achieves the best classification accuracy compared with previous graph kernels.

The sparsest additive spanner via multiple weighted BFS trees

Spanners are fundamental graph structures that sparsify graphs at the cost of small stretch. In particular, in recent years, many sequential algorithms constructing additive all-pairs spanners were designed, providing very sparse small-stretch subgraphs. Remarkably, it was then shown that the known (+6)-spanner constructions are essentially the sparsest possible, that is, larger additive stretch cannot guarantee a sparser spanner, which brought the stretch-sparsity trade-off to its limit. Distributed constructions of spanners are also abundant. However, for additive spanners, while there were algorithms constructing (+2) and (+4)-all-pairs spanners, the sparsest case of (+6)-spanners remained elusive.We remedy this by designing a new sequential algorithm for constructing a (+6)-spanner with the essentially-optimal sparsity of O˜(n4/3) edges. We then show a distributed implementation of our algorithm, answering an open problem in [12].A main ingredient in our distributed algorithm is an efficient construction of multiple weighted BFS trees. A weighted BFS tree is a BFS tree in a weighted graph, that consists of the lightest among all shortest paths from the root to each node. We present a distributed algorithm in the CONGEST model, that constructs multiple weighted BFS trees in |S|+D−1 rounds, where S is the set of sources and D is the diameter of the network graph.

Recognizing Graph Search Trees

Graph searches and the corresponding search trees can exhibit important structural properties and are used in various graph algorithms. The problem of deciding whether a given spanning tree of a graph is a search tree of a particular search on this graph was introduced by Hagerup and Nowak in 1985, and independently by Korach and Ostfeld in 1989 where the authors showed that this problem is efficiently solvable for DFS trees. A linear time algorithm for BFS trees was obtained by Manber in 1990. In this paper we prove that the search tree problem is also in P for LDFS, in contrast to LBFS, MCS, and MNS, where we show NP-completeness. We complement our results by providing linear time algorithms for these searches on split graphs.

Spanners for Directed Transmission Graphs

Let $P \subset \mathbb{R}^2$ be a planar $n$-point set such that each point $p \in P$ has an associated radius $r_p > 0$. The transmission graph $G$ for $P$ is the directed graph with vertex set $P$ such that for any $p, q \in P$, there is an edge from $p$ to $q$ if and only if $d(p, q) \leq r_p$. Let $t > 1$ be a constant. A $t$-spanner for $G$ is a subgraph $H \subseteq G$ with vertex set $P$ so that for any two vertices $p,q \in P$, we have $d_H(p, q) \leq t d_G(p, q)$, where $d_H$ and $d_G$ denote the shortest path distance in $H$ and $G$, respectively (with Euclidean edge lengths). We show how to compute a $t$-spanner for $G$ with $O(n)$ edges in $O(n (\log n + \log \Psi))$ time, where $\Psi$ is the ratio of the largest and smallest radius of a point in $P$. Using more advanced data structures, we obtain a construction that runs in $O(n \log^5 n)$ time, independent of $\Psi$. We give two applications for our spanners. First, we show how to use our spanner to find a BFS tree in $G$ from any given start vertex in $O(n \log n)$ time (in addition to the time it takes to build the spanner). Second, we show how to use our spanner to extend a reachability oracle to answer geometric reachability queries. In a geometric reachability query we ask whether a vertex $p$ in $G$ can "reach" a target $q$ which is an arbitrary point in the plane (rather than restricted to be another vertex $q$ of $G$ in a standard reachability query). Our spanner allows the reachability oracle to answer geometric reachability queries with an additive overhead of $O(\log n\log \Psi)$ to the query time and $O(n \log \Psi)$ to the space.

Sublinear-Time Maintenance of Breadth-First Spanning Trees in Partially Dynamic Networks

We study the problem of maintaining a breadth-first spanning tree (BFS tree) in partially dynamic distributed networks modeling a sequence of either failures or additions of communication links (but not both). We present deterministic (1+ϵ)-approximation algorithms whose amortized time (over some number of link changes) is sublinear in D , the maximum diameter of the network. Our technique also leads to a deterministic (1+ϵ)-approximate incremental algorithm for single-source shortest paths in the sequential (usual RAM) model. Prior to our work, the state of the art was the classic exact algorithm of Even and Shiloach (1981), which is optimal under some assumptions (Roditty and Zwick 2011; Henzinger et al. 2015). Our result is the first to show that, in the incremental setting, this bound can be beaten in certain cases if some approximation is allowed.

Sparse Fault-Tolerant BFS Structures

A fault-tolerant structure for a network is required for continued functioning following the failure of some of the network’s edges or vertices. This article considers breadth-first search (BFS) spanning trees and addresses the problem of designing a sparse fault-tolerant BFS structure (FT-BFS structure), namely, a sparse subgraph T of the given network G such that subsequent to the failure of a single edge or vertex, the surviving part T ′ of T still contains a BFS spanning tree for (the surviving part of) G . For a source node s , a target node t , and an edge e ∈ G , the shortest s − t path P s , t , e that does not go through e is known as a replacement path . Thus, our FT-BFS structure contains the collection of all replacement paths P s , t , e for every t ∈ V ( G ) and every failed edge e ∈ E ( G ). Our main results are as follows. We present an algorithm that for every n -vertex graph G and source node s constructs a (single edge failure) FT-BFS structure rooted at s with O ( n ċ min {Depth( s ), √n{) edges, where Depth( s ) is the depth of the BFS tree rooted at s . This result is complemented by a matching lower bound, showing that there exist n -vertex graphs with a source node s for which any edge (or vertex) FT-BFS structure rooted at s has Ω( n 3/2 ) edges. We then consider fault-tolerant multi-source BFS structures (FT-MBFS structures), aiming to provide (following a failure) a BFS tree rooted at each source s ∈ S for some subset of sources S ⊆ V . Again, tight bounds are provided, showing that there exists a poly-time algorithm that for every n -vertex graph and source set S ⊆ V of size σ constructs a (single failure) FT-MBFS structure T *( S ) from each source s i ∈ S , with O (√σ ċ n <sup;>3/2</sup;>) edges, and, on the other hand, there exist n -vertex graphs with source sets S ⊆ V of cardinality σ, on which any FT-MBFS structure from S has Ω(√σ ċ n 3/2 ) edges. Finally, we propose an O (log n ) approximation algorithm for constructing FT-BFS and FT-MBFS structures. The latter is complemented by a hardness result stating that there exists no Ω(log n ) approximation algorithm for these problems under standard complexity assumptions. In comparison with previous constructions, our algorithm is deterministic and may improve the number of edges by a factor of up to √ n for some instances. All our algorithms can be extended to deal with one vertex failure as well, with the same performance.

Silent self-stabilizing BFS tree algorithms revisited

In this paper, we revisit two fundamental results of the self-stabilizing literature about silent BFS spanning tree constructions: the Dolev et al. algorithm and the Huang and Chen’s algorithm. More precisely, we propose in the composite atomicity model three straightforward adaptations inspired from those algorithms. We then present a deep study of these three algorithms. Our results are related to both correctness (convergence and closure, assuming a distributed unfair daemon) and complexity (analysis of the stabilization time in terms of rounds and steps).

Topology Management Ensuring Reliability in Delay Sensitive Sensor Networks with Arbitrary Node Failures

The lifetime of a sensor network is influenced by the efficient utilization of the resource constrained sensor nodes. The tree-based data gathering offers good quality of service (QoS) for the running applications. However, data gathering at the sink reduces the network lifetime due to a fast failure of highly loaded nodes. Loss of connectivity and sensing coverage affect the performance of the applications that demand critical QoS. In this paper, a data gathering tree management scheme has been proposed to deal with arbitrary node failures in delay-sensitive sensor networks. A load-balanced distributed BFS tree construction procedure has been introduced for an efficient data gathering. Based on the initial tree construction, a tree maintenance scheme and an application message handler have been designed to ensure the reliable delivery of the application messages. The correctness of the proposed scheme has been verified both theoretically and with the help of simulation. The proposed scheme offers low overhead, enhanced network lifetime and good QoS in terms of delay and reliability of the application messages.

On the complexity of distributed BFS in ad hoc networks with non-spontaneous wake-ups

Distributed Computing and Networking We study time and message complexity of the problem of building a BFS tree by a spontaneously awaken node in ad hoc network. Computation is in synchronous rounds, and messages are sent via point-to-point bi-directional links. Network topology is modeled by a graph. Each node knows only its own id and the id's of its neighbors in the network and no pre-processing is allowed; therefore the solutions to the problem of spanning a BFS tree in this setting must be distributed. We deliver a deterministic distributed solution that trades time for messages, mainly, with time complexity O(D . min(D; n=f(n)) . logD . log n) and with the number of point-to-point messages sent O(n. (min(D; n=f(n))+f(n)) . logD. log n), for any n-node network with diameter D and for any monotonically non-decreasing sub-linear integer function f. Function f in the above formulas come from the threshold value on node degrees used by our algorithms, in the sense that nodes with degree at most f(n) are treated differently that the other nodes. This yields the first BFS-finding deterministic distributed algorithm in ad hoc networks working in time o(n) and with o(n2) message complexity, for some suitable functions f(n) = o(n= log2 n), provided D = o(n= log4 n).

Approximation algorithms for minimum latency data aggregation in wireless sensor networks with directional antenna

Real-time data aggregation is one of the most important issues in wireless sensor networks. Using directional antenna to transmit data can save energy and reduce interference. In this paper, we study the minimum latency data aggregation problem with the given two directional antenna models (the steering beam and the switch beam) under protocol interference model. We propose an approximation directional data aggregation algorithm to schedule data transmissions under two directional antenna models, respectively. At last, we evaluate the proposed schedule algorithms through simulations, and simulation results show that the proposed schedule’s latency is close to the depth of BFS tree, which is the lower bound of schedule latency, and the proposed schedules achieve extremely good performance.

Shortest hop multipath algorithm for wireless sensor networks

Shortest hop or distance path is one of the most common methods used for relaying messages in a wide variety of networks. It provides an efficient message relaying to destination in terms of energy and time. There are many algorithms for constructing shortest hop or distance path. However, according to our knowledge, no algorithm for constructing a shortest hop multipath for wireless sensor networks (WSNs) has yet been proposed in the literature. In this paper, we propose a novel distributed shortest hop multipath algorithm for WSNs in order to generate energy efficient paths for data dissemination or routing. The proposed algorithm generates shortest hop braided multipath to be used for fault-tolerance or load-balancing. It guarantees the BFS tree and generates near optimal paths in O ( V . D + V ) message complexity and O ( D 2 ) time complexity regarding the communication costs towards the sink after termination of algorithm.

An [formula omitted]-time self-stabilizing leader election algorithm

A self-stabilizing asynchronous distributed leader election algorithm is presented. The algorithm works for any connected unoriented (bidirectional) network with unique IDs. The solution also constructs a BFS tree of the network rooted at the elected leader. The proposed solution is silent and works under the unfair daemon. The algorithm stabilizes in O ( n ) rounds, where n is the number of processes in the network.

A SELF-STABILIZING DISTRIBUTED APPROXIMATION ALGORITHM FOR THE MINIMUM CONNECTED DOMINATING SET

Self-stabilization is a theoretical framework of non-masking fault-tolerant distributed algorithms. A self-stabilizing system tolerates any kind and any finite number of transient faults, such as message loss, memory corruption, and topology change. Because such transient faults occur so frequently in mobile ad hoc networks, distributed algorithms on them should tolerate such events. In this paper, we propose a self-stabilizing distributed approximation algorithm for the minimum connected dominating set, which can be used, for example, as a virtual backbone or routing in mobile ad hoc networks. The size of the solution by our algorithm is at most 7.6|Dopt|+1.4, where Dopt is the minimum connected dominating set. The time complexity is O(k) rounds, where k is the depth of input BFS tree.

Self-stabilizing leader election in optimal space under an arbitrary scheduler

A silent self-stabilizing asynchronous distributed algorithm, SSLE, is given for the leader election problem in a connected unoriented (bidirectional) network with unique IDs. SSLE also constructs a BFS tree on the network rooted at that leader. SSLE uses O(logn) space per process and stabilizes in O(n) rounds, against the unfair daemon, where n is the number of processes in the network.

Adaptive broadcast by fault-tolerant spanning tree switching

Adaptation is a desirable requirement in a distributed system as it helps the system to perform efficiently under different environments. For many problems, more than one protocol exists, such that one protocol performs better in one environment while the other performs better in another. In such cases, adaptive distributed systems can be designed by dynamically switching between the protocols as the environment changes. Distributed protocol switching is also important for performance enhancement, or fault-tolerance of a distributed system. In this work, we illustrate distributed protocol switching by providing a distributed algorithm for adaptive broadcast that dynamically switches from a BFS tree to a DFS tree. The proposed switching algorithm can also handle arbitrary crash failures. It ensures that switching eventually terminates in spite of failures and the desired tree (DFS tree) results as the output. We also investigate the properties that can be guaranteed on the delivery of broadcast messages under specific failure conditions. We show that under no failure, each broadcast message is eventually correctly delivered to all the nodes in spite of switching. Under arbitrary crash fault, we ensure that switching eventually terminates with the desired tree as the broadcast topology. We also investigate the specific delivery guarantees that can be provided when a single crash fault happens, both during switching and when no switching is in progress.

Space efficient and time optimal distributed BFS tree construction

In this paper, we give a simple distributed algorithm for constructing a BFS spanning tree in an almost anonymous, asynchronous, rooted network. The proposed algorithm is an improved version of an algorithm by Aspnes. The time complexity of the algorithm is optimal for this problem, i.e., O ( diam ) , where diam is the diameter of the network, and the space complexity of each process is O ( δ P ) for each process P, where δ P is the degree of P. The message complexity is O ( diam ⋅ | E | ) , where E is the set of links, and the size of each message is O ( 1 ) .

General Partitioning on Random Graphs

Consider the general partitioning (GP) problem defined as follows: Partition the vertices of a graph into k parts W1,…,Wk satisfying a polynomial time verifiable property. In particular, consider properties (introduced by T. Feder, P. Hell, S. Klein, and R. Motwani, in “Proceedings of the Annual ACM Symposium on Theory of Computing (STOC '99), 1999” and) specified by a pattern of requirements as to which Wi forms a sparse or dense subgraph and which pairs Wi, Wj form a sparse or dense or an arbitrary (no restriction) bipartite subgraph. The sparsity or density is specified by upper or lower bounds on the edge density d∈[0,1], which is the fraction of actual edges present to the maximum number of edges allowed. This problem is NP-hard even for some fixed patterns and includes as special cases well-known NP-hard problems like k-coloring (each d(Wi)=0; each d(Wi,Wj) is arbitrary), bisection (k=2; |W1|=|W2|; d(W1,W2)≤b), and also other problems like finding a clique/independent set of specified size. We show that GP is solvable in polynomial time almost surely over random instances with a planted partition of desired type, for several types of pattern requirement. The algorithm is based on the approach of growing BFS trees outlined by C. R. Subramanian (in “Proceedings of the 8th Annual European Symposium on Algorithms (ESA '00), 2000,” pp. 415–426).

Routing strategies for fast networks

Modern fast packet switching networks are being forced to rethink the routing schemes that are used in more traditional networks. The reexamination is necessitated because in these fast networks switches on the message's route can afford to make only minimal and simple operations. For example, examining a table of a size proportional to the network size is out of the question. We examine routing strategies for such networks based on flooding and predefined routes. Our concern is to get both efficient routing and an even (balanced) use of network resources. We present efficient algorithms for assigning weights to edges in a controlled flooding scheme but show that the flooding scheme is not likely to yield a balanced use of the resources. We then present efficient algorithms for choosing routes along: bfs trees and shortest paths. We show that in both cases a balanced use of network resources can be guaranteed.

Multiple Communication in Multihop Radio Networks

Two tasks of communication in a multihop synchronous radio network are considered: Point-to-point communication and broadcast (sending a message to all nodes of a network). Efficient protocols for both problems are presented. Even though the protocols are probabilistic, it is shown how to acknowledge messages deterministically. Let n, D, and $\Delta $ be the number of nodes, the diameter and the maximum degree of our network, respectively. Both protocols require a setup phase in which a BFS tree is constructed. This phase takes $O((n + D\log n)\log \Delta )$ time. After the setup, k point-to-point transmissions require $O((k + D)\log \Delta )$ time on the average. Therefore the network allows a new transmission every $O(\log \Delta )$ time slots. Also, k broadcasts require an average of $O((k + D)\log \Delta \log n)$ time. Hence the average throughput of the network is a broadcast every $O(\log \Delta \log n)$ time slots. Both protocols pipeline the messages along the BFS tree. They are always successful on the graph spanned by the BFS tree. Their probabilistic behavior refers only to the running time. Using the above protocols the ranking problem is solved in $O(n\log n\log \Delta )$ time. The performance analysis of both protocols constitutes a new application of queueing theory.