A Simple and Fast Min-Cut Algorithm

Fully Dynamic Algorithms for Maintaining Shortest Paths Trees

Exact and heuristic algorithms for the weighted total domination problem

Consider a complete weighted bipartite graph G in which each left vertex u has two real numbers intercept and slope, each right vertex v has a real number quality, and the weight of any edge (u, v) is defined as the intercept of u plus the slope of u times the quality of v. Let m (resp., n) denote the number of left (resp., right) vertices, and assume that m geq n. We develop a fast algorithm for computing a maximum weight matching (MWM) of such a graph. Our algorithm begins by computing an MWM of the subgraph induced by the n right vertices and an arbitrary subset of n left vertices; this step is straightforward to perform in O(n log n) time. The remaining m - n left vertices are then inserted into the graph one at a time, in arbitrary order. As each left vertex is inserted, the MWM is updated. It is relatively straightforward to process each such insertion in O(n) time; our main technical contribution is to improve this time bound to O(sqrt{n} log^2 n). This result has an application related to unit-demand auctions. It is well known that the VCG mechanism yields a suitable solution (allocation and prices) for any unit-demand auction. The graph G may be viewed as encoding a special kind of unit-demand auction in which each left vertex u represents a unit-demand bid, each right vertex v represents an item, and the weight of an edge (u, v) represents the offer of bid u on item v. In this context, our fast insertion algorithm immediately provides an O(sqrt{n} log^2 n)-time algorithm for updating a VCG allocation when a new bid is received. We show how to generalize the insertion algorithm to update (an efficient representation of) the VCG prices within the same time bound.

We consider a balance-constrained stochastic bottleneck spanning tree problem (BCSBSTP) where edge weights are independently distributed but may follow arbitrary continuous distributions. The goal is to minimize a threshold variable that may be exceeded by the maximum edge weight at certain risk, subject to the minimum edge weight being no less than a fixed threshold with a probability guarantee. We characterize these two requirements as chance constraints, which are typically used for bounding the risk of undesirable random outcomes. Given independently distributed edge weights, we reformulate BCSBSTP as a mixed-integer nonlinear program, approximated by two mixed-integer linear programs based on special ordered set of type one (SOS1) and special ordered set of type two (SOS2) variables. By relaxing the probabilistic guarantee on the minimum edge weight in BCSBSTP, we also consider a stochastic bottleneck spanning tree problem (SBSTP), of which optimal tree solutions are approximated via a bisection algorithm in pseudopolynomial time. We demonstrate computational results of our models and algorithms by testing randomly generated instances with edge weights following a diverse set of independent distributions.

We consider the problem of, given an undirected graph G with a nonnegative weight on each edge, finding a basis of the cycle space of G of minimum total weight, where the total weight of a basis is the sum of the weights of its cycles. Minimum cycle bases are of interest in a variety of fields. In [13] Horton proposed a first polynomial-time algorithm where a minimum cycle basis is extracted from a polynomial-size subset of candidate cycles in O(m 3 n) by using Gaussian elimination. In a different approach, due to de Pina [7] and refined in [15], the cycles of a minimum cycle basis are determined sequentially in O(m 2 n + m n 2 logn). A more sophisticated hybrid algorithm proposed in [18] has the best worst-case complexity of O(m 2 n / logn + m n 2).In this work we revisit Horton’s and de Pina’s approaches and we propose a simple hybrid algorithm which improves the worst-case complexity to O(m 2 n / logn). We also present a very efficient related algorithm that relies on an adaptive independence test à la de Pina. Computational results on a wide set of instances show that the latter algorithm outperforms the previous algorithms by one or two order of magnitude on medium-size instances and allows to solve instances with up to 3000 vertices in a reasonable time.KeywordsSpan TreeDeterministic AlgorithmCycle BasisIncidence VectorFundamental CycleThese 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.

A Simple Parallel Algorithm for the Single-Source Shortest Path Problem on Planar Digraphs

We study paths of time-length $t$ of a continuous-time random walk on $\mathbb{Z}^{2}$ subject to self-interaction that depends on the geometry of the walk range and a collection of random, uniformly positive and finite edge weights. The interaction enters through a Gibbs weight at inverse temperature $\beta$; the “energy” is the total sum of the edge weights for edges on the outer boundary of the range. For edge weights sampled from a translation-invariant, ergodic law, we prove that the range boundary condensates around an asymptotic shape in the limit $t\to\infty$ followed by $\beta\to\infty$. The limit shape is a minimizer (unique, modulo translates) of the sum of the principal harmonic frequency of the domain and the perimeter with respect to the first-passage percolation norm derived from (the law of) the edge weights. A dense subset of all norms in $\mathbb{R}^{2}$, and thus a large variety of shapes, arise from the class of weight distributions to which our proofs apply.

Given a network G=(V,E), edge weights w(.), and a set of terminals S⊆V, the minimum-weight Steiner tree problem is to find a tree in G that spans S with minimum weight. Most provable heuristics treat the network G is a metric; This assumption, in a distributed setting, cannot be easily achieved without a subtle overhead. We give a simple distributed algorithm based on a minimum spanning tree heuristic that returns a solution whose cost is within a factor of two of the optimal. The algorithm runs in time O(|V|log|V|) on a synchronous network. We also show that another heuristic based on iteratively finding shortest paths gives a Θ(log |V|)-approximation using a novel charging scheme based on low-congestion routing on trees. Both algorithms work for unit-cost and general cost cases. The algorithms also have applications in finding multicast trees in wireless ad hoc networks.

This article presents a fast algorithm for a class of parametric assignment problems. Moreover, it is shown how this algorithm can be applied to a problem arising in the so‐called max‐algebra which results as an analogue of classical linear algebra by replacing the classical addition and multiplication by a ⊕ b = max(a,b) and a ⊗ b = a + b, respectively. An instance of the linear parametric assignment problem is given by a bipartite graph G = (U,V,E) with 2n vertices, m edges and affine‐linear parametric edge weights cλ(i,j) = c(i,j) − b(i,j)λ for (i,j) ∈ E. The task is to find an assignment with minimum weight with respect to the parametric weights cλ for all values of λ. We develop an algorithm which solves the special case for which b(i,j) ∈ {0, 1} for all (i,j) ∈ E in 𝒪(mn+n2 log n) time. Our algorithm can be extended to solve the special parametric assignment problem which arises in connection with computing the essential terms of the so‐called characteristic max‐polynomial. The resulting algorithm runs in 𝒪(n3) time and thus improves upon the best‐known algorithm for computing the characteristic max‐polynomial due to Burkard and Butkovič (Appl Math 130 (2003), 367–380) by a factor of n. © 2009 Wiley Periodicals, Inc. NETWORKS, 2010

We consider the capacitated multi-source multicast tree routing problem (CMMTR) in an undirected graph G = (V,E) with a vertex set V, an edge set E and an edge weight w(e) ≥ 0, e ∈ E. We are given a source set S ⊆ V with a weight g(e) ≥ 0, e ∈ S, a terminal set M ⊆ V-S with a demand function q : M → R+, and a real number κ > 0, where g(s) means the cost for opening a vertex s ∈ S as a source in a multicast tree. Then the CMMTR asks to find a subset S′ ⊆ S, a partition {Z1,Z2,₀,Zl} of M, and a set of subtrees T1,T2,₀,Tl of G such that, for each i, Σt∈Ziq(t) ≤ κ and Ti spans Zi ∪ {s} for some s ∈ S′. The objective is to minimize the sum of the opening cost of S′ and the constructing cost of {Ti}, i.e., Σs∈S′g(s) + Σi=1lw(Ti), where w(Ti) denotes the sum of weights of all edges in Ti. In this paper, we propose a (2ρUFL + ρST)-approximation algorithm to the CMMTR, where ρUFL and ρST are any approximation ratios achievable for the uncapacitated facility location and the Steiner tree problems, respectively. When all terminals have unit demands, we give a ((3/2)ρUFL + (4/3)ρST -approximation algorithm.

In this work we consider the m-d-UMST problem. The m-d-UMST is to find m edge-disjoint spanning trees with the given diameter d of a minimal weight in given n-vertex weighted Undirected graph \(G = (V, E)\). We give an \(O(n^2)\)-time approximation algorithm solving this problem. Then we prove its asymptotic optimality in the case of complete undirected graphs. We also assume that weights of graph edges are independent random variables identically distributed from the class of biased exponential distribution.KeywordsGiven-diameter minimal spanning treeProbabilistic analysisAsymptotic optimalityBiased exponential distribution

We present two new algorithms for solving the All Pairs Shortest Paths (APSP) problem for weighted directed graphs. Both algorithms use fast matrix multiplication algorithms. The first algorithm solves the APSP problem for weighted directed graphs in which the edge weights are integers of small absolute value in O/spl tilde/(n/sup 2+/spl mu//) time, where /spl mu/ satisfies the equation /spl omega/(1,/spl mu/,1)=1+2/spl mu/ and /spl omega/(1,/spl mu/,1) is the exponent of the multiplication of an n/spl times/n/sup /spl mu// matrix by an n/sup /spl mu///spl times/n matrix. The currently best available bounds on /spl omega/(1,/spl mu/,1), obtained by Coppersmith and Winograd, and by Huang and Pan, imply that /spl mu/ 0 is an error parameter and W is the largest edge weight in the graph, after the edge weights are scaled so that the smallest non-zero edge weight in the graph is 1. It returns estimates of all the distances in the graph with a stretch of at most 1+/spl epsiv/. Corresponding paths can also be found efficiently.

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).

Edge weights and vertex colours

In this paper we propose an experimental study model S3P2 of a fast fully dynamic programming algorithm design technique in finite directed graphs with few distinct nonnegative real edge weights. The Bellman-Ford’s approach for shortest path problems has come out in various implementations. In this paper the approach once again is re-investigated with adjacency matrix selection in associate least running time. The model tests proposed algorithm against arbitrarily but positive valued weighted digraphs introducing notion of Prograph that speeds up finding the shortest path over previous implementations. Our experiments have established abstract results with the intention that the proposed algorithm can consistently dominate other existing algorithms for Single Source Shortest Path Problems. A comparison study is also shown among Dijkstra’s algorithm, Bellman-Ford algorithm, and our algorithm.