19 research outputs found
Searching a Tree with Permanently Noisy Advice
We consider a search problem on trees using unreliable guiding instructions. Specifically, an agent starts a search at the root of a tree aiming to find a treasure hidden at one of the nodes by an adversary. Each visited node holds information, called advice, regarding the most promising neighbor to continue the search. However, the memory holding this information may be unreliable. Modeling this scenario, we focus on a probabilistic setting. That is, the advice at a node is a pointer to one of its neighbors. With probability q each node is faulty, independently of other nodes, in which case its advice points at an arbitrary neighbor, chosen uniformly at random. Otherwise, the node is sound and points at the correct neighbor. Crucially, the advice is permanent, in the sense that querying a node several times would yield the same answer. We evaluate efficiency by two measures: The move complexity denotes the expected number of edge traversals, and the query complexity denotes the expected number of queries.
Let Delta denote the maximal degree. Roughly speaking, the main message of this paper is that a phase transition occurs when the noise parameter q is roughly 1/sqrt{Delta}. More precisely, we prove that above the threshold, every search algorithm has query complexity (and move complexity) which is both exponential in the depth d of the treasure and polynomial in the number of nodes n. Conversely, below the threshold, there exists an algorithm with move complexity O(d sqrt{Delta}), and an algorithm with query complexity O(sqrt{Delta}log Delta log^2 n). Moreover, for the case of regular trees, we obtain an algorithm with query complexity O(sqrt{Delta}log n log log n). For q that is below but close to the threshold, the bound for the move complexity is tight, and the bounds for the query complexity are not far from the lower bound of Omega(sqrt{Delta}log_Delta n).
In addition, we also consider a semi-adversarial variant, in which an adversary chooses the direction of advice at faulty nodes. For this variant, the threshold for efficient moving algorithms happens when the noise parameter is roughly 1/Delta. Above this threshold a simple protocol that follows each advice with a fixed probability already achieves optimal move complexity
Primal-Dual Schemes for Online Matching in Bounded Degree Graphs
We explore various generalizations of the online matching problem in a bipartite graph G as the b-matching problem [Kalyanasundaram and Pruhs, 2000], the allocation problem [Buchbinder et al., 2007], and the AdWords problem [Mehta et al., 2007] in a beyond-worst-case setting. Specifically, we assume that G is a (k, d)-bounded degree graph, introduced by Naor and Wajc [Naor and Wajc, 2018]. Such graphs model natural properties on the degrees of advertisers and queries in the allocation and AdWords problems. While previous work only considers the scenario where k ? d, we consider the interesting intermediate regime of k ? d and prove a tight competitive ratio as a function of k,d (under the small-bid assumption) of ?(k,d) = 1 - (1-k/d)?(1-1/d)^{d - k} for the b-matching and allocation problems. We exploit primal-dual schemes [Buchbinder et al., 2009; Azar et al., 2017] to design and analyze the corresponding tight upper and lower bounds. Finally, we show a separation between the allocation and AdWords problems. We demonstrate that ?(k,d) competitiveness is impossible for the AdWords problem even in (k,d)-bounded degree graphs
A Collection of Constraint Programming Models for the Three-Dimensional Stable Matching Problem with Cyclic Preferences
We introduce five constraint models for the 3-dimensional stable matching problem with cyclic preferences and study their relative performances under diverse configurations. While several constraint models have been proposed for variants of the two-dimensional stable matching problem, we are the first to present constraint models for a higher number of dimensions. We show for all five models how to capture two different stability notions, namely weak and strong stability. Additionally, we translate some well-known fairness notions (i.e. sex-equal, minimum regret, egalitarian) into 3-dimensional matchings, and present how to capture them in each model.
Our tests cover dozens of problem sizes and four different instance generation methods. We explore two levels of commitment in our models: one where we have an individual variable for each agent (individual commitment), and another one where the determination of a variable involves pairing the three agents at once (group commitment). Our experiments show that the suitability of the commitment depends on the type of stability we are dealing with. Our experiments not only led us to discover dependencies between the type of stability and the instance generation method, but also brought light to the role that learning and restarts can play in solving this kind of problems
pBWT: Achieving succinct data structures for parameterized pattern matching and related problems
The fields of succinct data structures and compressed text indexing have seen quite a bit of progress over the last two decades. An important achievement, primarily using techniques based on the Burrows-Wheeler Transform (BWT), was obtaining the full functionality of the suffix tree in the optimal number of bits. A crucial property that allows the use of BWT for designing compressed indexes is order-preserving suffix links. Specifically, the relative order between two suffixes in the subtree of an internal node is same as that of the suffixes obtained by truncating the furst character of the two suffixes. Unfortunately, in many variants of the text-indexing problem, for e.g., parameterized pattern matching, 2D pattern matching, and order-isomorphic pattern matching, this property does not hold. Consequently, the compressed indexes based on BWT do not directly apply. Furthermore, a compressed index for any of these variants has been elusive throughout the advancement of the field of succinct data structures. We achieve a positive breakthrough on one such problem, namely the Parameterized Pattern Matching problem. Let T be a text that contains n characters from an alphabet , which is the union of two disjoint sets: containing static characters (s-characters) and containing parameterized characters (p-characters). A pattern P (also over ) matches an equal-length substring S of T i the s-characters match exactly, and there exists a one-to-one function that renames the p-characters in S to that in P. The task is to find the starting positions (occurrences) of all such substrings S. Previous index [Baker, STOC 1993], known as Parameterized Suffix Tree, requires (n log n) bits of space, and can find all occ occurrences in time O(jPj log +occ), where = jj. We introduce an n log +O(n)-bit index with O(jPj log +occlog n log ) query time. At the core, lies a new BWT-like transform, which we call the Parame- terized Burrows-Wheeler Transform (pBWT). The techniques are extended to obtain a succinct index for the Parameterized Dictionary Matching problem of Idury and Schaer [CPM, 1994]
Struktury danych i algorytmy dynamiczne dla grafów planarnych
Obtaining provably efficient algorithms for the most basic graph problems like finding (shortest)
paths or computing maximum matchings, fast enough to handle real-world-scale graphs (i.e.,
consisting of millions of vertices and edges), is a very challenging task. For example, in a very
general regime of strongly-polynomial algorithms (see, e.g., [65]), we still do not know how
to compute shortest paths in a real-weighted sparse directed graph significantly faster than in
quadratic time, using the classical, but somewhat simple-minded, Bellman-Ford method.
One way to circumvent this problem is to consider more restricted computation models for
graph algorithms. If, for example, we restrict ourselves to graphs with integral edge weights, we
can improve upon the Bellman-Ford algorithm [14, 31]. Although these results are very deep
algorithmically, their theoretical efficiency is still very far from the only known trivial linear
lower bound on the actual time complexity of the negatively-weighted shortest path problem.
Another approach is to develop algorithms specialized for certain graph classes that appear
in practice. Planar graphs constitute one of the most important and well-studied such classes.
Many of the real-world networks can be drawn on a plane with no or few edge crossings. The
examples include not very complex road networks and graphs considered in the domain of VLSI
design. Complex road networks, although far from being planar, share with planar graphs some
useful properties, like the existence of small separators [20]. Special cases of planar graphs, such
as grids, appear often in the area of image processing (e.g., [7]).
And indeed, if we restrict ourselves to planar graphs, many of the classical polynomial-time
graph problems, in particular computing shortest paths [35, 58] and maximum flows [4, 5, 21]
in real-weighted graphs, can be solved either optimally or in nearly-linear time. The very
rich combinatorial structure of planar graphs often allows breaking barriers that appear in
the respective problems for general graphs by using techniques from computational geometry
(e.g., [27]), or by applying sophisticated data structures, such as dynamic trees [4, 10, 21, 66].
In this thesis, we focus on the data-structural aspect of planar graph algorithmics. By this,
we mean that rather than concentrating on particular planar graph problems, we study more
abstract, “low-level” problems. Efficient algorithms for these problems can be used in a blackbox manner to design algorithms for multiple specific problems at once. Such an approach
allows us to improve upon many known complexity upper bounds for different planar graph
problems simultaneously, without going into the specifics of these problems.
We also study dynamic algorithms for planar graphs, i.e., algorithms that maintain certain
information about a dynamically changing graph (such as “is the graph connected?”) much more
efficiently than by recomputing this information from scratch after each update. We consider
the edge-update model where the input graph can be modified only by adding or removing
1
single edges. A graph algorithm is called fully-dynamic if it supports both edge insertions and
edge deletions, and partially dynamic if it supports either only edge insertions (then we call it
incremental) or only edge deletions (then it is called decremental).
When designing dynamic graph algorithms, we care about the update time, i.e., the time
needed by the algorithm to adapt to an elementary change of the graph, and query time, i.e., the
time needed by the algorithm to recompute the requested portion of the maintained information.
Sometimes, especially in partially dynamic settings, it is more convenient to measure the total
update time, i.e., the total time needed by the algorithm to process any possible sequence
of updates. For some dynamic problems, it is worth focusing on a more restricted explicit
maintenance model where the entire maintained information is explicitly updated (so that the
user is notified about the update) after each change. In this model the query procedure is trivial
and thus we only care about the update time.
Note that there is actually no clear distinction between dynamic graph algorithms and graph
data structures, since dynamic algorithms are often used as black-boxes to obtain efficient static
algorithms (e.g., [26]). For example, the incremental connectivity problem, where one needs to
process queries about the existence of a path between given vertices, while the input undirected
graph undergoes edge insertions, is actually equivalent to the disjoint-set data structure problem,
also called the union-find data structure problem (see, e.g., [15]).
We concentrate mostly on the decremental model and obtain very efficient decremental
algorithms for problems on unweighted planar graphs related to reachability and connectivity.
We also apply our dynamic algorithms to static problems, thus confirming once again the datastructural character of these results.
In the following, let G = (V, E) denote the input planar graph with n vertices. For clarity
of this summary, assume G is a simple graph. Then, by planarity, it has O(n) edges. When we
talk about general graphs, we denote by m the number of edges of the graph.
2 Contracting a Planar Graph
The first part of the thesis is devoted to the data-structural aspect of contracting edges in planar
graphs. Edge contraction is one of the fundamental graph operations. Given an undirected
graph and its edge e, contracting the edge e consists in removing it from the graph and merging
its endpoints. The notion of contraction has been used to describe a number of prominent graph
algorithms, including Edmonds’ algorithm for computing maximum matchings [19], or Karger’s
minimum cut algorithm [44].
Edge contractions are of particular interest in planar graphs, as a number of planar graph
properties can be described using contractions. For example, it is well-known that a graph
is planar precisely when it cannot be transformed into K5 or K3,3 by contracting edges, or
removing vertices or edges (see e.g., [17]). Moreover, contracting an edge preserves planarity.
We would like to have at our disposal a data structure that performs contractions on the
input planar graph and still provides access to the most basic information about our graph,
such as the sizes of neighbors sets of individual vertices and the adjacency relation. While
contraction operation is conceptually very simple, its efficient implementation is challenging.
This is because it is not clear how to represent individual vertices’ adjacency lists so that
adjacency list merges, adjacency queries, and neighborhood size queries are all efficient. By
using standard data structures (e.g., balanced binary search trees), one can maintain adjacency
lists of a graph subject to contractions in polylogarithmic amortized time. However, in many
planar graph algorithms this becomes a bottleneck.
As an example, consider the problem of computing a 5-coloring of a planar graph. There
exists a very simple algorithm based on contractions [53] that only relies on a folklore fact that
2
a planar graph has a vertex of degree no more than 5. However, linear-time algorithms solving
this problem use some more involved planar graph properties [23, 53, 60]. For example, the
algorithm by Matula et al. [53] uses the fact that every planar graph has either a vertex of
degree at most 4 or a vertex of degree 5 adjacent to at least four vertices, each having degree
at most 11. Similarly, although there exists a very simple algorithm for computing a minimum
spanning tree of a planar graph based on edge contractions, various different methods have been
used to implement it efficiently [23, 51, 52].
The problem of maintaining a planar graph under contractions has been studied before. In
their book, Klein and Mozes [46] showed that there exists a (a bit more general) data structure
maintaining a planar graph under edge contractions and deletions, and answering adjacency
queries in O(1) worst-case time. The update time is O(log n). This result is based on the work
of Brodal and Fagerberg [8], who showed how to maintain a bounded-outdegree orientation of
a dynamic planar graph so that the edge set updates are supported in O(log n) amortized time.
Gustedt [32] showed an optimal solution to the union-find problem in the case when at any
time the actual subsets form disjoint and connected subgraphs of a given planar graph G. In
other words, in this problem the allowed unions correspond to the edges of a planar graph and
the execution of a union operation can be seen as a contraction of the respective edge.
Our Results
We show a data structure that can efficiently maintain a planar graph subject to edge contractions in linear total time, assuming the standard word-RAM model with word size Ω(log n). It
can report groups of parallel edges and self-loops that emerge. It also supports constant-time
adjacency queries and maintains the neighbor lists and degrees explicitly. The data structure
can be used as a black-box to implement planar graph algorithms that use contractions.
As an example, our data structure can be used to give clean and conceptually simple lineartime implementations of algorithms for computing 5-coloring or minimum spanning tree.
More importantly, by using our data structure, we give improved algorithms for a few
problems in planar graphs. In particular, we obtain optimal algorithms for decremental 2-edgeconnectivity (see, e.g., [30]), finding a unique perfect matching [26], and computing maximal
3-edge-connected subgraphs [12].
In order to obtain our result, we first partition the graph into small pieces of roughly logarithmic size (using so-called r-divisions [24]). Then we solve our problem recursively for each
of the pieces, and separately using a simple-minded approach for the subgraph induced by o(n)
vertices contained in multiple pieces (the so-called boundary vertices). Such an approach proved
successful in obtaining optimal data structures for the planar union-find problem [32] and decremental connectivity [50]. In fact, our data-structural problem can be seen as a generalization
of the former problem. However, maintaining the status of each edge e of the initial graph G
(i.e., whether e has become a self-loop or a parallel edge) subject to edge contractions, and
supporting constant-time adjacency queries without resorting to randomization, turn out to be
serious technical challenges. Overcoming these difficulties is our main contribution of this part
of the thesis.
3 Decremental Reachability
The second part of this thesis is devoted to dynamic reachability problems in planar graphs. In
the dynamic reachability problem we are given a (directed) graph G subject to edge updates and
the goal is to design a data structure that would allow answering queries about the existence of
a path between a pair of query vertices u, v ∈ V .
3
Two variants of dynamic reachability are studied most often. In the all-pairs variant, our
data structure has to support queries between arbitrary pairs of vertices. This variant is also
called the dynamic transitive closure problem, since a path u → v exists in G if uv is an edge
of the transitive closure of G.
In the single-source reachability problem, a source vertex s ∈ V is fixed from the very
beginning and the only allowed queries are about the existence of a path s → v, where v ∈ V .
If we work with undirected graphs, the dynamic reachability problem is called the dynamic
connectivity problem. Note that in the undirected case a path u → v exists in G if and only if
a path v → u exists in G.
State of the Art
Dynamic reachability in general directed graphs turns out to be a very challenging problem.
First of all, it is computationally much more demanding than its undirected counterpart. For
undirected graphs, fully-dynamic all-pairs algorithms with polylogarithmic amortized update
and query bounds are known [36, 38, 71]. For directed graphs, on the other hand, in most
settings (either single-source or all-pairs, either incremental, decremental or fully-dynamic) the
best known algorithm has either polynomial update time or polynomial query time. The only
exception is the incremental single-source reachability problem, for which a trivial extension of
depth-first search [68] achieves O(1) amortized update time.
One of the possible reasons behind such a big gap between the undirected and directed
settings is that one needs only linear time to compute the connected components of an undirected
graph, and thus there exists a O(n)-space static data structure that can answer connectivity
queries in undirected graphs in O(1) time. On the other hand, the best known algorithm for
computing the transitive closure runs in Oe(min(n
ω
, nm)) = Oe(n
2
)
1
time [11, 59].
So far, the best known bounds for fully-dynamic reachability are as follows. For dynamic
transitive closure, there exist a number of algorithms with O(n
2
) update time and O(1) query
time [16, 61, 64]. These algorithms, in fact, maintain the transitive closure explicitly. There also
exist a few fully-dynamic algorithms that are better for sparse graphs, each of which has Ω(n)
amortized update time and query time which is o(n) but still polynomial in n [62, 63, 64]. For
the single-source variant, the only known non-trivial (i.e., other than recompute-from-scratch)
algorithm has O(n
1.53) update time and O(1) query time [64].
Algorithms with O(nm) total update time are known for both incremental [39] and decremental [48, 62] transitive closure. Note that for sparse graphs this bound is only poly-logarithmic
factors away from the best known static transitive closure upper bound [11].
All the known partially-dynamic single-source reachability algorithms work in the explicit
maintenance model. As mentioned before, for incremental single-source reachability, an optimal
(in the amortized sense) algorithm is known. Interestingly, the first algorithms with O(mn1−
)
total update time (where > 0) have been obtained only recently [33, 34]. The best known
algorithm to date has Oe(m
√
n) total update time and is due to Chechik et al. [13].
Dynamic reachability has also been previously studied for planar graphs. Diks and Sankowski
[18] showed a fully-dynamic transitive closure algorithm with Oe(
√
n) update and query times,
which works under the assumption that the graph is plane embedded and the inserted edges
can only connect vertices sharing some adjacent face. Łącki [48] showed that one can maintain
the strongly connected components of a planar graph under edge deletions in O(n
√
n) total
time. By known reductions, it follows that there exists a decremental single-source reachability
algorithm for planar graphs with O(n
√
n) total update time. Note that this bound matches the
recent best known bound for general graphs [13] up to polylogarithmic factors.
1We denote by Oe(f(n)) the order O(f(n) polylog n)
Online Service with Delay
In this paper, we introduce the online service with delay problem. In this
problem, there are points in a metric space that issue service requests
over time, and a server that serves these requests. The goal is to minimize the
sum of distance traveled by the server and the total delay in serving the
requests. This problem models the fundamental tradeoff between batching
requests to improve locality and reducing delay to improve response time, that
has many applications in operations management, operating systems, logistics,
supply chain management, and scheduling.
Our main result is to show a poly-logarithmic competitive ratio for the
online service with delay problem. This result is obtained by an algorithm that
we call the preemptive service algorithm. The salient feature of this algorithm
is a process called preemptive service, which uses a novel combination of
(recursive) time forwarding and spatial exploration on a metric space. We hope
this technique will be useful for related problems such as reordering buffer
management, online TSP, vehicle routing, etc. We also generalize our results to
servers.Comment: 30 pages, 11 figures, Appeared in 49th ACM Symposium on Theory of
Computing (STOC), 201
Improved and Deterministic Online Service with Deadlines or Delay
We consider the problem of online service with delay on a general metric
space, first presented by Azar, Ganesh, Ge and Panigrahi (STOC 2017). The best
known randomized algorithm for this problem, by Azar and Touitou (FOCS 2019),
is -competitive, where is the number of points in the metric
space. This is also the best known result for the special case of online
service with deadlines, which is of independent interest.
In this paper, we present -competitive deterministic algorithms
for online service with deadlines or delay, improving upon the results from
FOCS 2019. Furthermore, our algorithms are the first deterministic algorithms
for online service with deadlines or delay which apply to general metric spaces
and have sub-polynomial competitiveness.Comment: Appears in STOC 202