Non-tree Edges Research Articles

Minimum spanning tree cycle intersection problem on outerplanar graphs

We study the minimum spanning tree cycle intersection (MSTCI) problem on outerplanar graphs in this paper. Consider a connected simple graph G=(V,E) and any spanning tree T=(V,ET) of G, it is well-known that each non-tree edge e∈E∖ET induces a fundamental cycle in T∪{e}. We say that two distinct fundamental cycles intersect if they share at least one edge. The MSTCI problem seeks a spanning tree such that the number of pairwise cycle intersections is minimized. We provide a linear-time algorithm to solve the problem on outerplanar graphs by exploiting the cycle-cut duality on plane graphs. Besides, we show that the minimum cycle intersection number is bounded by O(n) for outerplanar graphs with n vertices.

Cycles and new bounds for the chromatic number

In 1976, Bondy proved that the chromatic number of a graph G is at most its circumference, the length of a longest cycle. In 1992, Tuza proved that, for any integer k≥2, if a graph G contains no cycle of length congruent to 1 modulo k, then χ(G)≤k.In this paper, we use a DFS tree of a connected graph G to give proper colorings of V(G), based on the non-tree edges of the corresponding DFS tree and the cycle lengths of G. This method allows us to obtain improvements of the bounds proposed by Bondy and Tuza, respectively. Moreover, the hypotheses of most theorems presented in this paper can be checked in polynomial time.

Coloring down: 3/2-approximation for special cases of the weighted tree augmentation problem

In this paper, we investigate the weighted tree augmentation problem (TAP), where the goal is to augment a tree with a minimum cost set of edges such that the graph becomes two edge connected. First we show that in weighted TAP, we can restrict our attention to trees which are binary and where all the non-tree edges go between two leaves of the tree. We then give a top-down coloring algorithm that differs from known techniques for approximating TAP.The algorithm we describe always gives a 2-approximation starting from any feasible fractional solution to the natural tree cut covering LP. When the structure of the fractional solution is such that all the edges with non-zero weight are at least α, then this algorithm achieves a 21+α-approximation.We also investigate a variant of TAP where every tree edge must belong to a cycle of length three (triangle) in the solution. We give a Θ(log⁡n)-approximation algorithm for this problem in the weighted case in n-node graphs and a 4-approximation in the unweighted case.

A Simple and Efficient Algorithm for Finding Minimum Spanning Tree Replacement Edges

Given an undirected, weighted graph, the minimum spanning tree (MST) is a tree that connects all of the vertices of the graph with minimum sum of edge weights. In real world applications, network designers often seek to quickly find a replacement edge for each edge in the MST. For example, when a traffic accident closes a road in a transportation network, or a line goes down in a communication network, the replacement edge may reconnect the MST at lowest cost. In the paper, we consider the case of finding the lowest cost replacement edge for each edge of the MST. A previous algorithm by Tarjan takes $O(m \alpha(m, n))$ time and space, where $\alpha(m, n)$ is the inverse Ackermann's function. Given the MST and sorted non-tree edges, our algorithm is the first practical algorithm that runs in $O(m+n)$ time and $O({m+n})$ space to find all replacement edges. Additionally, since the most vital edge is the tree edge whose removal causes the highest cost, our algorithm finds it in linear time.

Phase connectivity in pore-network models for capillary-driven flow

Pore-network representations of permeable media provide the framework for explicit simulation of capillary-driven immiscible displacement governed by invasion-percolation theory. The most demanding task of a pore-network flow simulation is the identification of trapped defending phase clusters at every displacement step, i.e. the phase connectivity problem. Instead of employing the conventional adjacency list we represent the connectivity of a phase cluster as a tree accompanied by a set of adjacent non-tree edges. In this graph representation, a decrease in phase connectivity due to a pore displacement event corresponds to deletion of either a tree or a non-tree edge. Deletion of a tree edge invokes a computationally intensive search for a possible reconnection of the resulting subtrees by an adjacent non-tree edge. The tree representation facilitates a highly efficient execution of the reconnection search. Invasion-percolation simulations of secondary water floods under different wetting conditions in pore-networks of different origin and size confirm the efficiency of the proposed phase connectivity algorithm. Moreover, a systematic simulation study of runtime growth with increasing model size on regular lattice networks demonstrates a consistent orders-of-magnitude speed-up compared to conventional simulations. Consequently, the proposed algorithm proves to be a powerful tool for invasion-percolation simulations on large multi-scale networks and for extensive stochastic analysis of typical single-scale pore-networks.

Linear time distributed swap edge algorithms

In this paper, we consider the all best swap edges problem in a distributed environment. We are given a 2-edge connected positively weighted network X, where all communication is routed through a rooted spanning tree T of X. If a tree edge e={x,y} fails, the communication network will be disconnected. However, since X is 2-edge connected, communication can be restored by replacing e by non-tree edge e′, called a swap edge of e, whose ends lie in different components of T∖{e}. Of all possible swap edges of e, we would like to choose the best, according to four different objective functions.Overall, the problem is to identify the best swap edge for every tree edge, so that in case of any edge failure, the best swap edge can be activated quickly. There are solutions to this problem for a number of cases in the literature. A major concern for all these solutions is to minimize the number of messages. However, especially in fault-transient environments, time is a crucial factor. In this paper we present a novel technique that addresses this problem from a time perspective; in fact, we present a distributed solution that works in linear time with respect to the height h of T for a number of different criteria, while retaining the optimal number of messages and O(δx) space per each processor x of degree δx.To the best of our knowledge, there is no prior algorithm for the all best swap edges problem whose asymptotic complexity matches ours in all three measures: time, space, and number of messages.

Data Structures for Weighted Matching and Extensions to b -matching and f -factors

This article shows the weighted matching problem on general graphs can be solved in time O ( n ( m + n log n )) for n and m the number of vertices and edges, respectively. This was previously known only for bipartite graphs. The crux is a data structure for blossom creation. It uses a dynamic nearest-common-ancestor algorithm to simplify blossom steps, so they involve only back edges rather than arbitrary nontree edges. The rest of the article presents direct extensions of Edmonds’ blossom algorithm to weighted b -matching and f -factors. Again, the time bound is the one previously known for bipartite graphs: for b -matching the time is O (min { b ( V ), n log n }( m + n log n )), and for f -factors the time is O (min { f ( V ), m log n }( m + n log n )), where b ( V ) and f ( V ) both denote the sum of all degree constraints. Several immediate applications of the f -factor algorithm are given: The generalized shortest path structure of Reference [19], i.e., the analog of the shortest-paths tree for conservative undirected graphs, is shown to be a version of the blossom structure for f -factors. This structure is found in time O (| N |( m + n log n )) for N , the set of negative edges (0 < | N | < n ). A shortest T -join is found in time O ( n ( m + n log n )) or O (| T |( m + n log n )) when all costs are nonnegative. These bounds are all slight improvements of previously known ones, and are simply achieved by proper initialization of the f -factor algorithm.

GLOUDS: Representing tree-like graphs

The Graph Level Order Unary Degree Sequence (GLOUDS) is a new succinct data structure for directed graphs that are “tree-like,” in the sense that the number of “additional” edges (w.r.t. a spanning tree) is not too high. The algorithmic idea is to represent a BFS-spanning tree of the graph (consisting of n nodes) with a well known succinct data structure for trees, named LOUDS, and enhance it with additional information that accounts for the non-tree edges. In practical tests, our data structure performs well for graphs containing up to m=5n edges, while still having competitive running times for listing adjacent nodes.

Efficient Edge‐swapping heuristics for the reload cost spanning tree problem

The reload cost spanning tree problem (RCSTP) is an NP‐hard problem, where we are given a set of nonnegative pairwise demands between nodes, each edge is colored and a reload cost is incurred when a color change occurs on the path between a pair of demand nodes. The goal is to find a spanning tree with minimum total reload cost. We propose a tree–nontree edge swap neighborhood for the RCSTP and an efficient way to search this neighborhood using preprocessed information. We then embed this edge swap neighborhood within a local search and a tabu search heuristic. We also discuss an initial solution procedure that is used by the local search and tabu search heuristic in a multistart framework. On a test set of 630 instances (that includes benchmark instances from Gamvros et al. [6]), the local search solution improves upon the initial solution in 416 instances by an average of 23.62%, and the tabu search solution improves upon the local search solution in 364 instances by an average of 35.79%. Out of 495 test instances from this set that we know the optimal solutions for, the initial solution is optimal 113 times, the local search solution is optimal 224 times, and the tabu search solution is optimal 481 times. On a second set of benchmark instances from Khalil and Singh [9], the tabu search solution improves upon the best known solution in 32 out of 44 instances. © 2015 Wiley Periodicals, Inc. NETWORKS, Vol. 65(4), 380–394 2015

A Faster Computation of All the Best Swap Edges of a Shortest Paths Tree

We consider a two-edge connected, non-negatively real-weighted graph G with n vertices and m edges, and a single-source shortest paths tree (SPT) of G rooted at an arbitrary vertex. If an edge of the SPT is temporarily removed, a widely recognized approach to reconnect the vertices disconnected from the root consists of joining the two resulting subtrees by means of a single non-tree edge, called a swap edge. This allows to reduce consistently the set-up and computational costs which are incurred if one instead rebuilds a new optimal SPT from scratch. In the past, several optimality criteria have been considered to select a best possible swap edge, and here we restrict our attention to arguably the two most significant measures: the minimization of either the maximum or the average distance between the root and the disconnected vertices. For the former criteria, we present an $$O(m \log \alpha (m,n))$$O(mlog?(m,n)) time algorithm--where $$\alpha $$? is the inverse of the Ackermann function--to find a best swap edge for every edge of the SPT, thus improving onto the previous $$O(m \log n)$$O(mlogn) time algorithm. Concerning the latter criteria, we provide an $$O(m+n \log n)$$O(m+nlogn) time algorithm for the special but important case where G is unweighted, which compares favourably with the $$O\left( m+n \, \alpha (n,n)\log ^2n\right) $$Om+n?(n,n)log2n time bound that one would get by using the fastest algorithm known for the weighted case--once this is suitably adapted to the unweighted case.

A scalable approach to computing representative lowest common ancestor in directed acyclic graphs

LCA computation for vertex pairs in trees can be achieved in constant time after linear-time preprocessing. However, extension of these techniques to compute LCA for vertex-pairs in DAGs has been not possible due to the non-tree edges in a DAG. In this paper, we present an algorithm for computing the LCA for vertex pairs in a DAG which treats the DAGʼs spanning tree and its non-tree edges separately. Our approach enables us to tap the efficiency of existing LCA algorithms for trees. Furthermore, our algorithm decomposes the DAG into a set of component trees called clusters which significantly reduces the preprocessing necessary to incorporate non-tree edges in the LCA computation. Our algorithm seamlessly interpolates the performance graph between the best reported algorithms for trees and the best reported algorithms for DAGs depending on the incidence of non-tree edges in the DAG. Using the proposed techniques, it is possible to achieve near-linear preprocessing and constant query time for sparse DAGs.

Data Structures and Algorithms for Counting Problems on Graphs using GPU

The availability and utility of large numbers of Graphical Processing Units (GPUs) have enabled parallel computations using extensive multi-threading. Sequential access to global memory and contention at the size-limited shared memory have been main impediments to fully exploiting potential performance in architectures having a massive number of GPUs. After performing extensive study of data structures and complexity analysis of various data access methodologies, we propose novel memory storage and retrieval techniques that enable parallel graph computations to overcome the above issues. More specifically, given a graph G = (V,E) and an integer k <= |V |, we provide both storage techniques and algorithms to count the number of: a) connected subgraphs of size k; b) k cliques; and c) k independent sets, all of which can be exponential in number. Our storage techniques are based on creating a breadth-first search tree and storing it along with non-tree edges in a novel way. Our experiments solve the above mentioned problems by using both naive and advanced data structures on the CPU and GPU. Speedup is achieved by solving the problems on the GPU even using a brute-force approach as compared to the implementations on the CPU. Utilizing the knowledge of BFS-tree properties, the performance gain on the GPU increases and ultimately outperforms the CPU by a factor of at least 5 for graphs that completely fit in the shared memory and by a factor of 10 for larger graphs stored using the global memory. The counting problems mentioned above have many uses, including the analysis of social networks.

The Inverse Spanning Tree of a Fuzzy Graph Based on Credibility Measure

An inverse spanning tree problem is to make the least modification on the edge weights such that a predetermined spanning tree is a minimum spanning tree. In this paper, based on the notion of fuzzy α-minimum spanning tree, the inverse spanning tree problem with fuzzy edge weights is discussed and formulated as a fuzzy programming model with some chance constraints. It shows that when all the edge weights are assumed to be independent fuzzy variables with regular credibility distributions, the proposed model can be reformulated into a traditional nonlinear programming according to the equivalent condition of fuzzy α-minimum spanning tree characterized by a set of constraints on non-tree edges and their tree paths. Moreover, if all the fuzzy weights are triangular fuzzy numbers, a linear programming problem can be obtained and solved efficiently with the help of some well developed software packages.

MetNetGE: interactive views of biological networks and ontologies

BackgroundLinking high-throughput experimental data with biological networks is a key step for understanding complex biological systems. Currently, visualization tools for large metabolic networks often result in a dense web of connections that is difficult to interpret biologically. The MetNetGE application organizes and visualizes biological networks in a meaningful way to improve performance and biological interpretability.ResultsMetNetGE is an interactive visualization tool based on the Google Earth platform. MetNetGE features novel visualization techniques for pathway and ontology information display. Instead of simply showing hundreds of pathways in a complex graph, MetNetGE gives an overview of the network using the hierarchical pathway ontology using a novel layout, called the Enhanced Radial Space-Filling (ERSF) approach that allows the network to be summarized compactly. The non-tree edges in the pathway or gene ontology, which represent pathways or genes that belong to multiple categories, are linked using orbital connections in a third dimension. Biologists can easily identify highly activated pathways or gene ontology categories by mapping of summary experiment statistics such as coefficient of variation and overrepresentation values onto the visualization. After identifying such pathways, biologists can focus on the corresponding region to explore detailed pathway structure and experimental data in an aligned 3D tiered layout. In this paper, the use of MetNetGE is illustrated with pathway diagrams and data from E. coli and Arabidopsis.ConclusionsMetNetGE is a visualization tool that organizes biological networks according to a hierarchical ontology structure. The ERSF technique assigns attributes in 3D space, such as color, height, and transparency, to any ontological structure. For hierarchical data, the novel ERSF layout enables the user to identify pathways or categories that are differentially regulated in particular experiments. MetNetGE also displays complex biological pathway in an aligned 3D tiered layout for exploration.

Swapping a failing edge of a shortest paths tree by minimizing the average stretch factor

We consider a two-edge connected, undirected graph G = ( V , E ) , with n nodes and m non-negatively real weighted edges, and a single source shortest paths tree (SPT) T of G rooted at an arbitrary node r . If an edge in T is temporarily removed, it makes sense to reconnect the nodes disconnected from the root by adding a single non-tree edge, called a swap edge, instead of rebuilding a new optimal SPT from scratch. In the past, several optimality criteria have been considered to select a best possible swap edge. In this paper we focus on the most prominent one, that is the minimization of the average distance between the root and the disconnected nodes. To this respect, we present an O ( m log 2 n ) time and O ( m ) space algorithm to find a best swap edge for every edge of T , thus improving for m = o ( n 2 / log 2 n ) the previously known O ( n 2 ) time and space complexity algorithm.

Efficient detection and resolution of OR deadlocks in distributed systems

This paper proposes a distributed algorithm for resolving deadlocks under the OR request model. The algorithm builds a distributed spanning tree by propagating probes. An encoding scheme is devised to deduce the ancestor–descendant relationship between tree nodes, so that the initiator of the algorithm collects only non-tree edge information to detect deadlock, whereas the current algorithms require all the edge information for deadlock detection. The proposed algorithm resolves all deadlocks reachable from the initiator. Its performance in terms of number of messages and execution time is better than or comparable to that of the existing algorithms. We further showed through analytic evaluation that the suggested algorithm substantially shortens deadlock detection time.