2,955 research outputs found
Maximum Skew-Symmetric Flows and Matchings
The maximum integer skew-symmetric flow problem (MSFP) generalizes both the
maximum flow and maximum matching problems. It was introduced by Tutte in terms
of self-conjugate flows in antisymmetrical digraphs. He showed that for these
objects there are natural analogs of classical theoretical results on usual
network flows, such as the flow decomposition, augmenting path, and max-flow
min-cut theorems. We give unified and shorter proofs for those theoretical
results.
We then extend to MSFP the shortest augmenting path method of Edmonds and
Karp and the blocking flow method of Dinits, obtaining algorithms with similar
time bounds in general case. Moreover, in the cases of unit arc capacities and
unit ``node capacities'' the blocking skew-symmetric flow algorithm has time
bounds similar to those established in Even and Tarjan (1975) and Karzanov
(1973) for Dinits' algorithm. In particular, this implies an algorithm for
finding a maximum matching in a nonbipartite graph in time,
which matches the time bound for the algorithm of Micali and Vazirani. Finally,
extending a clique compression technique of Feder and Motwani to particular
skew-symmetric graphs, we speed up the implied maximum matching algorithm to
run in time, improving the best known bound
for dense nonbipartite graphs.
Also other theoretical and algorithmic results on skew-symmetric flows and
their applications are presented.Comment: 35 pages, 3 figures, to appear in Mathematical Programming, minor
stylistic corrections and shortenings to the original versio
New and simple algorithms for stable flow problems
Stable flows generalize the well-known concept of stable matchings to markets
in which transactions may involve several agents, forwarding flow from one to
another. An instance of the problem consists of a capacitated directed network,
in which vertices express their preferences over their incident edges. A
network flow is stable if there is no group of vertices that all could benefit
from rerouting the flow along a walk.
Fleiner established that a stable flow always exists by reducing it to the
stable allocation problem. We present an augmenting-path algorithm for
computing a stable flow, the first algorithm that achieves polynomial running
time for this problem without using stable allocation as a black-box
subroutine. We further consider the problem of finding a stable flow such that
the flow value on every edge is within a given interval. For this problem, we
present an elegant graph transformation and based on this, we devise a simple
and fast algorithm, which also can be used to find a solution to the stable
marriage problem with forced and forbidden edges.
Finally, we study the stable multicommodity flow model introduced by
Kir\'{a}ly and Pap. The original model is highly involved and allows for
commodity-dependent preference lists at the vertices and commodity-specific
edge capacities. We present several graph-based reductions that show
equivalence to a significantly simpler model. We further show that it is
NP-complete to decide whether an integral solution exists
Algebraic Approaches to Stochastic Optimization
The dissertation presents algebraic approaches to the shortest path and maximum flow problems in stochastic networks. The goal of the stochastic shortest path problem is to find the distribution of the shortest path length, while the goal of the stochastic maximum flow problem is to find the distribution of the maximum flow value. In stochastic networks it is common to model arc values (lengths, capacities) as random variables. In this dissertation, we model arc values with discrete non-negative random variables and shows how each arc value can be represented as a polynomial. We then define two algebraic operations and use these operations to develop both exact and approximating algorithms for each problem in acyclic networks. Using majorization concepts, we show that the approximating algorithms produce bounds on the distribution of interest; we obtain both lower and upper bounding distributions. We also obtain bounds on the expected shortest path length and expected maximum flow value. In addition, we used fixed-point iteration techniques to extend these approaches to general networks. Finally, we present a modified version of the Quine-McCluskey method for simplification of Boolean expressions in order to simplify polynomials used in our work
Minimum Path Cover: The Power of Parameterization
Computing a minimum path cover (MPC) of a directed acyclic graph (DAG) is a
fundamental problem with a myriad of applications, including reachability.
Although it is known how to solve the problem by a simple reduction to minimum
flow, recent theoretical advances exploit this idea to obtain algorithms
parameterized by the number of paths of an MPC, known as the width. These
results obtain fast [M\"akinen et al., TALG] and even linear time [C\'aceres et
al., SODA 2022] algorithms in the small-width regime.
In this paper, we present the first publicly available high-performance
implementation of state-of-the-art MPC algorithms, including the parameterized
approaches. Our experiments on random DAGs show that parameterized algorithms
are orders-of-magnitude faster on dense graphs. Additionally, we present new
pre-processing heuristics based on transitive edge sparsification. We show that
our heuristics improve MPC-solvers by orders-of-magnitude
A survey of parallel execution strategies for transitive closure and logic programs
An important feature of database technology of the nineties is the use of parallelism for speeding up the execution of complex queries. This technology is being tested in several experimental database architectures and a few commercial systems for conventional select-project-join queries. In particular, hash-based fragmentation is used to distribute data to disks under the control of different processors in order to perform selections and joins in parallel. With the development of new query languages, and in particular with the definition of transitive closure queries and of more general logic programming queries, the new dimension of recursion has been added to query processing. Recursive queries are complex; at the same time, their regular structure is particularly suited for parallel execution, and parallelism may give a high efficiency gain. We survey the approaches to parallel execution of recursive queries that have been presented in the recent literature. We observe that research on parallel execution of recursive queries is separated into two distinct subareas, one focused on the transitive closure of Relational Algebra expressions, the other one focused on optimization of more general Datalog queries. Though the subareas seem radically different because of the approach and formalism used, they have many common features. This is not surprising, because most typical Datalog queries can be solved by means of the transitive closure of simple algebraic expressions. We first analyze the relationship between the transitive closure of expressions in Relational Algebra and Datalog programs. We then review sequential methods for evaluating transitive closure, distinguishing iterative and direct methods. We address the parallelization of these methods, by discussing various forms of parallelization. Data fragmentation plays an important role in obtaining parallel execution; we describe hash-based and semantic fragmentation. Finally, we consider Datalog queries, and present general methods for parallel rule execution; we recognize the similarities between these methods and the methods reviewed previously, when the former are applied to linear Datalog queries. We also provide a quantitative analysis that shows the impact of the initial data distribution on the performance of methods
Recommended from our members
Minimum Cost Flows in Graphs with Unit Capacities
We consider the minimum cost flow problem on graphs with unit capacities and its special cases. In previous studies, special purpose algorithms exploiting the fact that capacities are one have been developed.
In contrast, for maximum flow with unit capacities, the best bounds are proven for slight modifications of classical blocking flow and push-relabel algorithms.
In this paper we show that the classical cost scaling algorithms of Goldberg and Tarjan (for general integer capacities) applied to a problem with unit capacities achieve or improve the best known bounds.
For weighted bipartite matching we establish a bound of O(sqrt{rm}log C) on a slight variation of this algorithm. Here r is the size of the smaller side of the bipartite graph, m is the number of edges, and C is the largest absolute value of an arc-cost. This simplifies a result of [Duan et al. 2011] and improves the bound, answering an open question of [Tarjan and Ramshaw 2012]. For graphs with unit vertex capacities we establish a novel O(sqrt{n}mlog(nC)) bound. We also give the first cycle canceling algorithm for minimum cost flow with unit capacities. The algorithm naturally generalizes the single source shortest path algorithm of [Goldberg 1995]
- …