8,339 research outputs found
Space-Efficient Parallel Algorithms for Combinatorial Search Problems
We present space-efficient parallel strategies for two fundamental
combinatorial search problems, namely, backtrack search and branch-and-bound,
both involving the visit of an -node tree of height under the assumption
that a node can be accessed only through its father or its children. For both
problems we propose efficient algorithms that run on a -processor
distributed-memory machine. For backtrack search, we give a deterministic
algorithm running in time, and a Las Vegas algorithm requiring
optimal time, with high probability. Building on the backtrack
search algorithm, we also derive a Las Vegas algorithm for branch-and-bound
which runs in time, with high probability. A
remarkable feature of our algorithms is the use of only constant space per
processor, which constitutes a significant improvement upon previous algorithms
whose space requirements per processor depend on the (possibly huge) tree to be
explored.Comment: Extended version of the paper in the Proc. of 38th International
Symposium on Mathematical Foundations of Computer Science (MFCS
Node-weighted Steiner tree and group Steiner tree in planar graphs
We improve the approximation ratios for two optimization problems in planar graphs. For node-weighted Steiner tree, a classical network-optimization problem, the best achievable approximation ratio in general graphs is Θ [theta] (logn), and nothing better was previously known for planar graphs. We give a constant-factor approximation for planar graphs. Our algorithm generalizes to allow as input any nontrivial minor-closed graph family, and also generalizes to address other optimization problems such as Steiner forest, prize-collecting Steiner tree, and network-formation games.
The second problem we address is group Steiner tree: given a graph with edge weights and a collection of groups (subsets of nodes), find a minimum-weight connected subgraph that includes at least one node from each group. The best approximation ratio known in general graphs is O(log3 [superscript 3] n), or O(log2 [superscript 2] n) when the host graph is a tree. We obtain an O(log n polyloglog n) approximation algorithm for the special case where the graph is planar embedded and each group is the set of nodes on a face. We obtain the same approximation ratio for the minimum-weight tour that must visit each group
Fast Structuring of Radio Networks for Multi-Message Communications
We introduce collision free layerings as a powerful way to structure radio
networks. These layerings can replace hard-to-compute BFS-trees in many
contexts while having an efficient randomized distributed construction. We
demonstrate their versatility by using them to provide near optimal distributed
algorithms for several multi-message communication primitives.
Designing efficient communication primitives for radio networks has a rich
history that began 25 years ago when Bar-Yehuda et al. introduced fast
randomized algorithms for broadcasting and for constructing BFS-trees. Their
BFS-tree construction time was rounds, where is the network
diameter and is the number of nodes. Since then, the complexity of a
broadcast has been resolved to be rounds. On the other hand, BFS-trees have been used as a crucial building
block for many communication primitives and their construction time remained a
bottleneck for these primitives.
We introduce collision free layerings that can be used in place of BFS-trees
and we give a randomized construction of these layerings that runs in nearly
broadcast time, that is, w.h.p. in rounds for any constant . We then use these
layerings to obtain: (1) A randomized algorithm for gathering messages
running w.h.p. in rounds. (2) A randomized -message
broadcast algorithm running w.h.p. in rounds. These
algorithms are optimal up to the small difference in the additive
poly-logarithmic term between and . Moreover, they imply the
first optimal round randomized gossip algorithm
Parallel Peeling Algorithms
The analysis of several algorithms and data structures can be framed as a
peeling process on a random hypergraph: vertices with degree less than k are
removed until there are no vertices of degree less than k left. The remaining
hypergraph is known as the k-core. In this paper, we analyze parallel peeling
processes, where in each round, all vertices of degree less than k are removed.
It is known that, below a specific edge density threshold, the k-core is empty
with high probability. We show that, with high probability, below this
threshold, only (log log n)/log(k-1)(r-1) + O(1) rounds of peeling are needed
to obtain the empty k-core for r-uniform hypergraphs. Interestingly, we show
that above this threshold, Omega(log n) rounds of peeling are required to find
the non-empty k-core. Since most algorithms and data structures aim to peel to
an empty k-core, this asymmetry appears fortunate. We verify the theoretical
results both with simulation and with a parallel implementation using graphics
processing units (GPUs). Our implementation provides insights into how to
structure parallel peeling algorithms for efficiency in practice.Comment: Appears in SPAA 2014. Minor typo corrections relative to previous
versio
- …