34,968 research outputs found
Deterministic and Probabilistic Binary Search in Graphs
We consider the following natural generalization of Binary Search: in a given
undirected, positively weighted graph, one vertex is a target. The algorithm's
task is to identify the target by adaptively querying vertices. In response to
querying a node , the algorithm learns either that is the target, or is
given an edge out of that lies on a shortest path from to the target.
We study this problem in a general noisy model in which each query
independently receives a correct answer with probability (a
known constant), and an (adversarial) incorrect one with probability .
Our main positive result is that when (i.e., all answers are
correct), queries are always sufficient. For general , we give an
(almost information-theoretically optimal) algorithm that uses, in expectation,
no more than queries, and identifies the target correctly with probability at
leas . Here, denotes the
entropy. The first bound is achieved by the algorithm that iteratively queries
a 1-median of the nodes not ruled out yet; the second bound by careful repeated
invocations of a multiplicative weights algorithm.
Even for , we show several hardness results for the problem of
determining whether a target can be found using queries. Our upper bound of
implies a quasipolynomial-time algorithm for undirected connected
graphs; we show that this is best-possible under the Strong Exponential Time
Hypothesis (SETH). Furthermore, for directed graphs, or for undirected graphs
with non-uniform node querying costs, the problem is PSPACE-complete. For a
semi-adaptive version, in which one may query nodes each in rounds, we
show membership in in the polynomial hierarchy, and hardness
for
A Sidetrack-Based Algorithm for Finding the k Shortest Simple Paths in a Directed Graph
We present an algorithm for the k shortest simple path problem on weighted
directed graphs (kSSP) that is based on Eppstein's algorithm for a similar
problem in which paths are allowed to contain cycles. In contrast to most other
algorithms for kSSP, ours is not based on Yen's algorithm and does not solve
replacement path problems. Its worst-case running time is on par with
state-of-the-art algorithms for kSSP. Using our algorithm, one may find O(m)
simple paths with a single shortest path tree computation and O(n + m)
additional time per path in well-behaved cases, where n is the number of nodes
and m is the number of edges. Our computational results show that on random
graphs and large road networks, these well-behaved cases are quite common and
our algorithm is faster than existing algorithms by an order of magnitude.
Further, the running time is far better predictable due to very small
dispersion
A forward-backward single-source shortest paths algorithm
We describe a new forward-backward variant of Dijkstra's and Spira's
Single-Source Shortest Paths (SSSP) algorithms. While essentially all SSSP
algorithm only scan edges forward, the new algorithm scans some edges backward.
The new algorithm assumes that edges in the outgoing and incoming adjacency
lists of the vertices appear in non-decreasing order of weight. (Spira's
algorithm makes the same assumption about the outgoing adjacency lists, but
does not use incoming adjacency lists.) The running time of the algorithm on a
complete directed graph on vertices with independent exponential edge
weights is , with very high probability. This improves on the previously
best result of , which is best possible if only forward scans are
allowed, exhibiting an interesting separation between forward-only and
forward-backward SSSP algorithms. As a consequence, we also get a new all-pairs
shortest paths algorithm. The expected running time of the algorithm on
complete graphs with independent exponential edge weights is , matching
a recent algorithm of Demetrescu and Italiano as analyzed by Peres et al.
Furthermore, the probability that the new algorithm requires more than
time is exponentially small, improving on the probability bound
obtained by Peres et al
Advances in Learning Bayesian Networks of Bounded Treewidth
This work presents novel algorithms for learning Bayesian network structures
with bounded treewidth. Both exact and approximate methods are developed. The
exact method combines mixed-integer linear programming formulations for
structure learning and treewidth computation. The approximate method consists
in uniformly sampling -trees (maximal graphs of treewidth ), and
subsequently selecting, exactly or approximately, the best structure whose
moral graph is a subgraph of that -tree. Some properties of these methods
are discussed and proven. The approaches are empirically compared to each other
and to a state-of-the-art method for learning bounded treewidth structures on a
collection of public data sets with up to 100 variables. The experiments show
that our exact algorithm outperforms the state of the art, and that the
approximate approach is fairly accurate.Comment: 23 pages, 2 figures, 3 table
On Generalizations of Network Design Problems with Degree Bounds
Iterative rounding and relaxation have arguably become the method of choice
in dealing with unconstrained and constrained network design problems. In this
paper we extend the scope of the iterative relaxation method in two directions:
(1) by handling more complex degree constraints in the minimum spanning tree
problem (namely, laminar crossing spanning tree), and (2) by incorporating
`degree bounds' in other combinatorial optimization problems such as matroid
intersection and lattice polyhedra. We give new or improved approximation
algorithms, hardness results, and integrality gaps for these problems.Comment: v2, 24 pages, 4 figure
Recognizing Partial Cubes in Quadratic Time
We show how to test whether a graph with n vertices and m edges is a partial
cube, and if so how to find a distance-preserving embedding of the graph into a
hypercube, in the near-optimal time bound O(n^2), improving previous O(nm)-time
solutions.Comment: 25 pages, five figures. This version significantly expands previous
versions, including a new report on an implementation of the algorithm and
experiments with i
- …