Efficient Deterministic Algorithms for Finding a Minimum Cycle Basis in Undirected Graphs

The perception of cyclic structures is a crucial step in the analysis of graphs. To describe the cycle vector space of a graph, a minimum cycle basis can be computed in polynomial time using an algorithm of [Horton, 1987]. But the set of cycles corresponding to a minimum basis is not always relevant for analyzing the cyclic structure of a graph. This restriction is due to the fact that a minimum cycle basis is generally not unique for a given graph. Therefore, the smallest canonical set of cycles which describes the cyclic structure of a graph is the union of all the minimum cycle bases. This set of cycles is called the set of relevant cycles and denoted by ${\cal C_R}$. A relevant cycle can also be defined as a cycle which is not the sum of shorter cycles. A polynomial algorithm is presented that computes a compact representation of the potentially exponential-sized set ${\cal C_R}$ in $O(\nu m^3)$ (where $\nu$ denotes the cyclomatic number). This compact representation consists of a polynomial number of relevant cycle prototypes from which all the relevant cycles can be listed in $O(n\,|{\cal C_R}|)$. A polynomial method is also given that computes the number of relevant cycles without listing all of them.

We give the first known optimal algorithm that computes a minimum cycle basis for any weighted outerplanar graph. Specifically, for any n-node edge-weighted outerplanar graph G, we give an O(n)-time algorithm to obtain an O(n)-space compact representation Z(?) for a minimum cycle basis ? of G. Each cycle in ? can be computed from Z(?) in O(1) time per edge. Our result works for directed and undirected outerplanar graphs G.

Efficient computation of shortest cycles which form a homology basis under \(\mathbb {Z}_2\)-additions in a given simplicial complex \(\mathcal {K}\) has been researched actively in recent years. When the complex \(\mathcal {K}\) is a weighted graph with n vertices and m edges, the problem of computing a shortest (homology) cycle basis is known to be solvable in \(O(m^2n/\log n+ n^2m)\)-time. Several works [1, 2] have addressed the case when the complex \(\mathcal {K}\) is a 2-manifold. The complexity of these algorithms depends on the rank g of the one-dimensional homology group of \(\mathcal {K}\). This rank g has a lower bound of \(\varTheta (n)\), where n denotes the number of simplices in \(\mathcal {K}\), giving an \(O(n^4)\) worst-case time complexity for the algorithms in [1, 2]. This worst-case complexity is improved in [3] to \(O(n^\omega + n^2g^{\omega -1})\) for general simplicial complexes where \(\omega < 2.3728639\) [4] is the matrix multiplication exponent. Taking \(g=\varTheta (n)\), this provides an \(O(n^{\omega +1})\) worst-case algorithm. In this paper, we improve this time complexity. Combining the divide and conquer technique from [5] with the use of annotations from [3], we present an algorithm that runs in \(O(n^\omega +n^2g)\) time giving the first \(O(n^3)\) worst-case algorithm for general complexes. If instead of minimal basis, we settle for an approximate basis, we can improve the running time even further. We show that a 2-approximate minimal homology basis can be computed in \(O(n^{\omega }\sqrt{n \log n})\) expected time. We also study more general measures for defining the minimal basis and identify reasonable conditions on these measures that allow computing a minimal basis efficiently.

We present a linear time algorithm for computing an implicit linear space representation of a minimum cycle basis (MCB) in weighted partial 2-trees, i.e., graphs of treewidth two. The implicit representation can be made explicit in a running time that is proportional to the size of the MCB.

Given a graph G, and terminal vertices s and t, the Tracking Paths problem asks to compute a set of minimum number of vertices to be marked as trackers, such that the sequence of trackers encountered in each s-t path is unique. Tracking Paths is NP-hard in both directed and undirected graphs in general. In this paper we give a collection of polynomial time algorithms for some restricted versions of Tracking Paths. We prove that Tracking Paths is polynomial time solvable for undirected chordal graphs and tournament graphs. We also show that Tracking Paths is NP-hard in graphs with bounded maximum degree Delta ge 6, and give a 2(Delta +1)-approximate algorithm for this case. Further, we give a polynomial time algorithm which, given an undirected graph G, a tracking set Tsubseteq V(G), and a sequence of trackers pi , returns the unique s-t path in G that corresponds to pi , if one exists. Finally we analyze the version of tracking s-t paths where paths are tracked using edges instead of vertices, and we give a polynomial time algorithm for the same.

Graph algorithms play an important role in several fields of sciences and engineering. Prominent among them are the All-Pairs-Shortest-Paths (APSP) and related problems. Indeed there are several efficient implementations for such problems on a variety of modern multi- and many-core architectures. It can be noticed that for several graph problems, parallelism offers only a limited success as current parallel architectures have severe short-comings when deployed for most graph algorithms. At the same time, some of these graphs exhibit clear structural properties due to their sparsity. This calls for particular solution strategies aimed at scalable processing of large, sparse graphs on modern parallel architectures. In this paper, we study the applicability of an ear decomposition of graphs to problems such as all-pairs-shortestpaths and minimum cost cycle basis. Through experimentation, we show that the resulting solutions are scalable in terms of both memory usage and also their speedup over best known current implementations. We believe that our techniques have the potential to be relevant for designing scalable solutions for other computations on large sparse graphs.

The problem of finding a fundamental cycle basis with minimum total cost in a graph arises in many application fields. In this paper we present some integer linear programming formulations and we compare their performances, in terms of instance size, CPU time required for the solution, and quality of the associated lower bound derived by solving the corresponding continuous relaxations. Since only very small instances can be solved to optimality with these formulations and very large instances occur in a number of applications, we present a new constructive heuristic and compare it with alternative heuristics.

A branch-and-price algorithm for the Steiner tree packing problem

We present an algorithm which calculates a minimum cut and its weight in an undirected graph with nonnegative real edge weights, n vertices and m edges, in time O(max(log n, min(m/n,δG/e)) n2), where e is the minimal edge weight, and δG is the minimal weighted degree. For integer edge weights this time is further improved to O(δG n2) and O(λG n2). In both cases these bounds are improvements of the previously known best bounds of deterministic algorithms. These were O(nm + n2 log n) for real edge weights and O(nM + n2) and O(M + λG n2) for integer weights, where M is the sum of all edge weights.

We present a method for solving the transshipment problem - also known as uncapacitated minimum cost flow - up to a multiplicative error of $1 + \varepsilon$ in undirected graphs with non-negative edge weights using a tailored gradient descent algorithm. Using $\tilde{O}(\cdot)$ to hide polylogarithmic factors in $n$ (the number of nodes in the graph), our gradient descent algorithm takes $\tilde O(\varepsilon^{-2})$ iterations, and in each iteration it solves an instance of the transshipment problem up to a multiplicative error of $\operatorname{polylog} n$. In particular, this allows us to perform a single iteration by computing a solution on a sparse spanner of logarithmic stretch. Using a randomized rounding scheme, we can further extend the method to finding approximate solutions for the single-source shortest paths (SSSP) problem. As a consequence, we improve upon prior work by obtaining the following results: (1) Broadcast CONGEST model: $(1 + \varepsilon)$-approximate SSSP using $\tilde{O}((\sqrt{n} + D)\varepsilon^{-3})$ rounds, where $ D $ is the (hop) diameter of the network. (2) Broadcast congested clique model: $(1 + \varepsilon)$-approximate transshipment and SSSP using $\tilde{O}(\varepsilon^{-2})$ rounds. (3) Multipass streaming model: $(1 + \varepsilon)$-approximate transshipment and SSSP using $\tilde{O}(n)$ space and $\tilde{O}(\varepsilon^{-2})$ passes. The previously fastest SSSP algorithms for these models leverage sparse hop sets. We bypass the hop set construction; computing a spanner is sufficient with our method. The above bounds assume non-negative edge weights that are polynomially bounded in $n$; for general non-negative weights, running times scale with the logarithm of the maximum ratio between non-zero weights.

A faster algorithm to recognize undirected path graphs

We present several new efficient algorithms for approximating the girth, g, of weighted and unweighted n-vertex, m-edge undirected graphs. For undirected graphs with polynomially bounded, integer, non-negative edge weights, we provide an algorithm that for every integer k ≥ 1, runs in Õ(m + n1 + 1/k log g) time and returns a cycle of length at most 2kg. For unweighted, undirected graphs we present an algorithm that for every k ≥ 1, runs in Õ(n1 + 1/k) time and returns a cycle of length at most 2k[g/2], an almost k-approximation. Both algorithms provide trade-offs between the running time and the quality of the approximation. We also obtain faster algorithms for approximation factors better than 2, and improved approximations when the girth is odd or small (e.g., 3 and 4).

Array dataflow analysis is a valuable tool for supercomputer compilers. However, the worst-case asymptotic time complexities for modern array dataflow analysis techniques are either not well understood or alarmingly high. For example, the Omega Test uses a subset of the 222O(n) language of Presburger Arithmetic for analysis of affine dependences; its use of uninterpreted function symbols for nonaffine terms introduces additional sources of complexity. Even traditional data dependence analysis of affine dependences is equivalent to integer programming, and is thus NP-complete. These worst-case complexities have raised questions about the wisdom of using array dataflow analysis in a production compiler, despite empirical data that show that various tests run quickly in practice. In this paper, we demonstrate that a polynomial-time algorithm can produce accurate information about the presence of loop-carried array dataflow. We first identify a subdomain of Presburger Arithmetic that can be manipulated (by the Omega Library) in polynomial time; we then describe a modification to prevent exponential blowup of the Omega Library's algorithm for manipulating function symbols. Restricting the Omega Test to these polynomial cases can, in principle, reduce the accuracy of the dataflow information produced. We therefore present the results of our investigation of the effects of these restrictions on the detection of loop-carried array dataflow dependences (which prevent parallelization). These restrictions block parallelization of only a few unimportant loop nests in the approximately 18000 lines of benchmark code we studied. The use of our subdomain of Presburger Arithmetic also gives a modest reduction in analysis time, even with our current unoptimized implementation, as long as we do not employ our modified algorithms for function symbols. The data collected in our empirical studies also suggest directions for improving both accuracy and efficiency.

Given an undirected graph with two different nonnegative costs associated with every edge e (say, w e for the weight and l e for the length of edge e) and a budget L, consider the problem of finding a spanning tree of total edge length at most L and minimum total weight under this restriction. This constrained minimum spanning tree problem is weakly NP-hard. We present a polynomial-time approximation scheme for this problem. This algorithm always produces a spanning tree of total length at most (1 + ε)L and of total weight at most that of any spanning tree of total length at most L, for any fixed ε >0. The algorithm uses Lagrangean relaxation, and exploits adjacency relations for matroids.KeywordsApproximation AlgorithmSpan TreeLagrangean RelaxationUnrelated Parallel MachineMinimum Span Tree ProblemThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

We study the minimum weight basis problem on matroid when elements' weights are uncertain. For each element we only know a set of possible values (an uncertainty area) that contains its real weight. In some cases there exist bases that are uniformly optimal, that is, they are minimum weight bases for every possible weight function obeying the uncertainty areas. In other cases, computing such a basis is not possible unless we perform some queries for the exact value of some elements. Our main result is a polynomial time algorithm for the following problem. Given a matroid with uncertainty areas and a query cost function on its elements, find the set of elements of minimum total cost that we need to simultaneously query such that, no matter their revelation, the resulting instance admits a uniformly optimal base. We also provide combinatorial characterizations of all uniformly optimal bases, when one exists; and of all sets of queries that can be performed so that after revealing the corresponding weights the resulting instance admits a uniformly optimal base.