856 research outputs found
Dynamic Approximate All-Pairs Shortest Paths: Breaking the O(mn) Barrier and Derandomization
We study dynamic -approximation algorithms for the all-pairs
shortest paths problem in unweighted undirected -node -edge graphs under
edge deletions. The fastest algorithm for this problem is a randomized
algorithm with a total update time of and constant
query time by Roditty and Zwick [FOCS 2004]. The fastest deterministic
algorithm is from a 1981 paper by Even and Shiloach [JACM 1981]; it has a total
update time of and constant query time. We improve these results as
follows: (1) We present an algorithm with a total update time of and constant query time that has an additive error of
in addition to the multiplicative error. This beats the previous
time when . Note that the additive
error is unavoidable since, even in the static case, an -time
(a so-called truly subcubic) combinatorial algorithm with
multiplicative error cannot have an additive error less than ,
unless we make a major breakthrough for Boolean matrix multiplication [Dor et
al. FOCS 1996] and many other long-standing problems [Vassilevska Williams and
Williams FOCS 2010]. The algorithm can also be turned into a
-approximation algorithm (without an additive error) with the
same time guarantees, improving the recent -approximation
algorithm with running
time of Bernstein and Roditty [SODA 2011] in terms of both approximation and
time guarantees. (2) We present a deterministic algorithm with a total update
time of and a query time of . The
algorithm has a multiplicative error of and gives the first
improved deterministic algorithm since 1981. It also answers an open question
raised by Bernstein [STOC 2013].Comment: A preliminary version was presented at the 2013 IEEE 54th Annual
Symposium on Foundations of Computer Science (FOCS 2013
Scheduling multicasts on unit-capacity trees and meshes
This paper studies the multicast routing and admission control problem on unit-capacity tree and mesh topologies in the throughput-model. The problem is a generalization of the edge-disjoint paths problem and is NP-hard both on trees and meshes. We study both the offline and the online version of the problem: In the offline setting, we give the first constant-factor approximation algorithm for trees, and an O((log log n)^2)-factor approximation algorithm for meshes. In the online setting, we give the first polylogarithmic competitive online algorithm for tree and mesh topologies. No polylogarithmic-competitive algorithm is possible on general network topologies [Bartal,Fiat,Leonardi, 96], and there exists a polylogarithmic lower bound on the competitive ratio of any online algorithm on tree topologies [Awerbuch,Azar,Fiat,Leighton, 96]. We prove the same lower bound for meshes
Constant-time dynamic (∆+1)-coloring
We give a fully dynamic (Las-Vegas style) algorithm with constant expected amortized time per update that maintains a proper (∆ + 1)-vertex coloring of a graph with maximum degree at most ∆. This improves upon the previous O(log ∆)-time algorithm by Bhattacharya et al. (SODA 2018). We show that our result does not only have optimal running time, but is also optimal in the sense that already deciding whether a ∆-coloring exists in a dynamically changing graph with maximum degree at most ∆ takes Ω(log n) time per operation
Towards Vulnerability Discovery Using Staged Program Analysis
Eliminating vulnerabilities from low-level code is vital for securing
software. Static analysis is a promising approach for discovering
vulnerabilities since it can provide developers early feedback on the code they
write. But, it presents multiple challenges not the least of which is
understanding what makes a bug exploitable and conveying this information to
the developer. In this paper, we present the design and implementation of a
practical vulnerability assessment framework, called Melange. Melange performs
data and control flow analysis to diagnose potential security bugs, and outputs
well-formatted bug reports that help developers understand and fix security
bugs. Based on the intuition that real-world vulnerabilities manifest
themselves across multiple parts of a program, Melange performs both local and
global analyses. To scale up to large programs, global analysis is
demand-driven. Our prototype detects multiple vulnerability classes in C and
C++ code including type confusion, and garbage memory reads. We have evaluated
Melange extensively. Our case studies show that Melange scales up to large
codebases such as Chromium, is easy-to-use, and most importantly, capable of
discovering vulnerabilities in real-world code. Our findings indicate that
static analysis is a viable reinforcement to the software testing tool set.Comment: A revised version to appear in the proceedings of the 13th conference
on Detection of Intrusions and Malware & Vulnerability Assessment (DIMVA),
July 201
Solving k-center Clustering (with Outliers) in MapReduce and Streaming, almost as Accurately as Sequentially.
Center-based clustering is a fundamental primitive for data analysis and becomes very challenging for large datasets. In this paper, we focus on the popular k-center variant which, given a set S of points from some metric space and a parameter k0, the algorithms yield solutions whose approximation ratios are a mere additive term \u3f5 away from those achievable by the best known polynomial-time sequential algorithms, a result that substantially improves upon the state of the art. Our algorithms are rather simple and adapt to the intrinsic complexity of the dataset, captured by the doubling dimension D of the metric space. Specifically, our analysis shows that the algorithms become very space-efficient for the important case of small (constant) D. These theoretical results are complemented with a set of experiments on real-world and synthetic datasets of up to over a billion points, which show that our algorithms yield better quality solutions over the state of the art while featuring excellent scalability, and that they also lend themselves to sequential implementations much faster than existing ones
Perturbed Timed Automata
We consider timed automata whose clocks are imperfect. For a given perturbation error 0 \u3c ε \u3c 1, the perturbed language of a timed automaton is obtained by letting its clocks change at a rate within the interval [1 - ε, 1 + ε]. We show that the perturbed language of a timed automaton with a single clock can be captured by a deterministic timed automaton. This leads to a decision procedure for the language inclusion problem for systems modeled as products of 1-clock automata with imperfect clocks. We also prove that determinization and decidability of language inclusion are not possible for multi-clock automata, even with perturbation
Efficient Dynamic Approximate Distance Oracles for Vertex-Labeled Planar Graphs
Let be a graph where each vertex is associated with a label. A
Vertex-Labeled Approximate Distance Oracle is a data structure that, given a
vertex and a label , returns a -approximation of
the distance from to the closest vertex with label in . Such
an oracle is dynamic if it also supports label changes. In this paper we
present three different dynamic approximate vertex-labeled distance oracles for
planar graphs, all with polylogarithmic query and update times, and nearly
linear space requirements
- …