Dr. CHETHAN CHANDRA S BASAVARADDI

International Journal of Innovative Technology and Exploring Engineering, 2020

In a graph, spanning tree is a subgraph it is also a tree which relates all the vertices together. So it 'Spans' the first graph yet utilizing less edges Graph Search is a calculated plot that visits vertices or edges in a graph, in a request dependent on the availability of the graph. In graph search, edges are visited all things considered once and not all edges are visited. The ones that are visited structure a spanning tree for the vertices that are associated with the beginning vertex by a path. A spanning tree for a lot of vertices VER is a lot of edges without cycles that associates VER. So in a spanning tree, there is actually one path between any two of the vertices. This is the fundamental explanation behind the utility of DFS. DFS utilize stacks and creates insignificant spanning tree fulfilling an assortment of conditions.

In this paper we deal with BFS algorithm by modifying it with some conditions and proper labeling of vertices which results and on applying it to some small basic class of graphs. The BFS algorithm has to modify accordingly. Some graphs will result in and by direct application of BFS where some need modifications in the algorithm. The BFS algorithm starts with a root vertex called start vertex. The resulted output tree structure will be in the form of Structure or in Structure.

Algorithms, 2009

The Web Graph is a large-scale graph that does not fit in main memory, so that lossless compression methods have been proposed for it. This paper introduces a compression scheme that combines efficient storage with fast retrieval for the information in a node. The scheme exploits the properties of the Web Graph without assuming an ordering of the URLs, so that it may be applied to more general graphs. Tests on some datasets of use achieve space savings of about 10% over existing methods.

Theory of computing systems, 2018

Research on space efficient graph algorithms, particularly for stconnectivity, has a long history including the celebrated polynomial time, O(lg n) bits 1 algorithm in undirected graphs by Reingold J. JACM. 55(4) (2008), and polynomial time, n/2 (√ lg n) bits algorithm in directed graphs by Barnes et al. SICOMP. 27(5), 1273-1282 (1998). Recent works by Asano et al. ISAAC (2014) and Elmasry et al. STACS (2015), reconsidered classical fundamental graph algorithms focusing on improving the space complexity. Elmasry et al. gave, among others, an implementation of breadth first search (BFS) in a graph G with n vertices and m edges, taking the optimal O(m + n) time using O(n) bits improving the naïve O(n lg n) bits We use lg to denote logarithm to the base 2. Some of these results were announced in preliminary form in the proceedings of 22nd International

International Journal of Computer Applications, 2014

Wireless Sensor Network (WSN) is type of network which consists of a collection of tiny devices called sensor nodes. The effective communication type in sensor network is aggregative communication. In such a path is constructed between all the participant nodes and generate an aggregative path. Each node includes its data to this aggregative path and perform the communication to the sink node. In this work, we will be proposing an energy efficient method based on graph theory that can be used to find out minimum path based on some defined conditions from a source node to the destination node. Initially, a sensor area is divided into number of levels by a base station based on signal strength. The base station is placed at the corner with specific range. The nodes in the range of base station can perform direct communication with base station. The presented work, will generate and effective route under the energy, sensing range and fault criticality parameters. It is important to memo that this method will always locate minimum path and alternate path in case of node crash. To identify the effective route, a BFS based approach is suggested in this work. The work will improve the network life, reduce the energy consumption and improve the network communication.

2012

We present preliminary results of a multi-GPU code for exploring large graphs (hundreds of millions vertices and billions of edges) by using the Breadth First Search algorithm. The GPU hosts are connected by APEnet+, a custom interconnection network that has full support for NVIDIA GPUDirect peer-topeer communication, i.e. the technology allowing a third party device to directly access the GPU memory over the PCI express bus.

2005

Many emerging large-scale data science applications require searching large graphs distributed across multiple memories and processors. This paper presents a distributed breadthfirst search (BFS) scheme that scales for random graphs with up to three billion vertices and 30 billion edges. Scalability was tested on IBM BlueGene/L with 32,768 nodes at the Lawrence Livermore National Laboratory. Scalability was obtained through a series of optimizations, in particular, those that ensure scalable use of memory. We use 2D (edge) partitioning of the graph instead of conventional 1D (vertex) partitioning to reduce communication overhead. For Poisson random graphs, we show that the expected size of the messages is scalable for both 2D and 1D partitionings. Finally, we have developed efficient collective communication functions for the 3D torus architecture of BlueGene/L that also take advantage of the structure in the problem. The performance and characteristics of the algorithm are measured and reported.

Networks, 2003

Recently considerable effort has been spent on showing that Lexicographic Breadth First Search (LBFS) can be used to determine a tight bound on the diameter of graphs from various restricted classes.

2021

Breadth-First Search (BFS) is a building block used in a wide array of graph analytics and is used in various network analysis domains: social, road, transportation, communication, and much more. Over the last two decades, network sizes have continued to grow. The popularity of BFS has brought with it a need for significantly faster traversals. Thus, BFS algorithms have been designed to exploit shared-memory and shared-nothing systems–this includes algorithms for accelerators such as the GPU. GPUs offer extremely fast traversals at the cost of processing smaller graphs due to their limited memory size. In contrast, CPU shared-memory systems can scale to graphs with several billion edges but do not have enough compute resources needed for fast traversals. This paper introduces ButterFly BFS, a multi-GPU traversal algorithm that allows analyzing significantly larger networks at high rates. ButterFly BFS scales to the similar-sized graphs processed by shared-memory systems while improv...

Lecture Notes in Computer Science, 2016

Recent work by Elmasry et al. (STACS 2015) and Asano et al. (ISAAC 2014), reconsidered classical fundamental graph algorithms focusing on improving the space complexity. Elmasry et al. gave, among others, implementations of breadth first search (BFS) and depth first search (DFS) in a graph on n vertices and m edges, taking O(m + n) time using O(n) and O(n lg lg n) bits of space respectively improving the naive O(n lg n) 1 bits implementation. We continue this line of work focusing on space. Our first result is a simple data structure that can maintain any subset S of a universe of n elements using n + o(n) bits and support in constant time, apart from the standard insert, delete and membership queries, the operation findany that finds and returns any element of the set (or outputs that the set is empty). Using this we give a BFS implementation that takes O(m + n) time using at most 2n + o(n) bits. Later, we further improve the space requirement of BFS to at most 1.585n+o(n) bits albeit with a slight increase in running time to O(m lg nf (n)) time where f (n) is any extremely slow growing function of n. These improve the space by a constant factor from earlier representations. We demonstrate the use of our data structure by developing another data structure using it that can represent a sequence of n non-negative integers x1, x2,. .. xn using at most n i=1 xi + 2n + o(n i=1 xi + n) bits and, in constant time, determine whether the i-th element is 0 or decrement it otherwise. We use this data structure to output the vertices of a • directed acyclic graph in topological sorted order in O(m + n) time and O(m + n) bits, and • graph with degeneracy d in degeneracy order in O(nd) time using O(nd) bits. We also discuss an algorithm for finding a minimum weight spanning tree of a weighted undirected graph using at most n + o(n) bits. For DFS, we have two kinds of results. Specifically, • we provide an implementation for DFS that takes O(m + n) time using O(m+n) bits. This partially answers at least for sparse graphs, a question in [3] that asked whether DFS can be performed in O(m+n) time and O(n) bits. Using the DFS algorithm and other careful A preliminary version of this paper appears in the proceedings of COCOON 2016. 1 We use lg to denote logarithm to the base 2.