196 research outputs found

### 2-Vertex Connectivity in Directed Graphs

We complement our study of 2-connectivity in directed graphs, by considering
the computation of the following 2-vertex-connectivity relations: We say that
two vertices v and w are 2-vertex-connected if there are two internally
vertex-disjoint paths from v to w and two internally vertex-disjoint paths from
w to v. We also say that v and w are vertex-resilient if the removal of any
vertex different from v and w leaves v and w in the same strongly connected
component. We show how to compute the above relations in linear time so that we
can report in constant time if two vertices are 2-vertex-connected or if they
are vertex-resilient. We also show how to compute in linear time a sparse
certificate for these relations, i.e., a subgraph of the input graph that has
O(n) edges and maintains the same 2-vertex-connectivity and vertex-resilience
relations as the input graph, where n is the number of vertices.Comment: arXiv admin note: substantial text overlap with arXiv:1407.304

### Efficient Enumeration of Induced Subtrees in a K-Degenerate Graph

In this paper, we address the problem of enumerating all induced subtrees in
an input k-degenerate graph, where an induced subtree is an acyclic and
connected induced subgraph. A graph G = (V, E) is a k-degenerate graph if for
any its induced subgraph has a vertex whose degree is less than or equal to k,
and many real-world graphs have small degeneracies, or very close to small
degeneracies. Although, the studies are on subgraphs enumeration, such as
trees, paths, and matchings, but the problem addresses the subgraph
enumeration, such as enumeration of subgraphs that are trees. Their induced
subgraph versions have not been studied well. One of few example is for
chordless paths and cycles. Our motivation is to reduce the time complexity
close to O(1) for each solution. This type of optimal algorithms are proposed
many subgraph classes such as trees, and spanning trees. Induced subtrees are
fundamental object thus it should be studied deeply and there possibly exist
some efficient algorithms. Our algorithm utilizes nice properties of
k-degeneracy to state an effective amortized analysis. As a result, the time
complexity is reduced to O(k) time per induced subtree. The problem is solved
in constant time for each in planar graphs, as a corollary

### Semi-dynamic connectivity in the plane

Motivated by a path planning problem we consider the following procedure.
Assume that we have two points $s$ and $t$ in the plane and take
$\mathcal{K}=\emptyset$. At each step we add to $\mathcal{K}$ a compact convex
set that does not contain $s$ nor $t$. The procedure terminates when the sets
in $\mathcal{K}$ separate $s$ and $t$. We show how to add one set to
$\mathcal{K}$ in $O(1+k\alpha(n))$ amortized time plus the time needed to find
all sets of $\mathcal{K}$ intersecting the newly added set, where $n$ is the
cardinality of $\mathcal{K}$, $k$ is the number of sets in $\mathcal{K}$
intersecting the newly added set, and $\alpha(\cdot)$ is the inverse of the
Ackermann function

### On the Computational Complexity of Non-dictatorial Aggregation

We investigate when non-dictatorial aggregation is possible from an
algorithmic perspective, where non-dictatorial aggregation means that the votes
cast by the members of a society can be aggregated in such a way that the
collective outcome is not simply the choices made by a single member of the
society. We consider the setting in which the members of a society take a
position on a fixed collection of issues, where for each issue several
different alternatives are possible, but the combination of choices must belong
to a given set $X$ of allowable voting patterns. Such a set $X$ is called a
possibility domain if there is an aggregator that is non-dictatorial, operates
separately on each issue, and returns values among those cast by the society on
each issue. We design a polynomial-time algorithm that decides, given a set $X$
of voting patterns, whether or not $X$ is a possibility domain. Furthermore, if
$X$ is a possibility domain, then the algorithm constructs in polynomial time
such a non-dictatorial aggregator for $X$. We then show that the question of
whether a Boolean domain $X$ is a possibility domain is in NLOGSPACE. We also
design a polynomial-time algorithm that decides whether $X$ is a uniform
possibility domain, that is, whether $X$ admits an aggregator that is
non-dictatorial even when restricted to any two positions for each issue. As in
the case of possibility domains, the algorithm also constructs in polynomial
time a uniform non-dictatorial aggregator, if one exists. Then, we turn our
attention to the case where $X$ is given implicitly, either as the set of
assignments satisfying a propositional formula, or as a set of consistent
evaluations of an sequence of propositional formulas. In both cases, we provide
bounds to the complexity of deciding if $X$ is a (uniform) possibility domain.Comment: 21 page

### Finding 2-Edge and 2-Vertex Strongly Connected Components in Quadratic Time

We present faster algorithms for computing the 2-edge and 2-vertex strongly
connected components of a directed graph, which are straightforward
generalizations of strongly connected components. While in undirected graphs
the 2-edge and 2-vertex connected components can be found in linear time, in
directed graphs only rather simple $O(m n)$-time algorithms were known. We use
a hierarchical sparsification technique to obtain algorithms that run in time
$O(n^2)$. For 2-edge strongly connected components our algorithm gives the
first running time improvement in 20 years. Additionally we present an $O(m^2 /
\log{n})$-time algorithm for 2-edge strongly connected components, and thus
improve over the $O(m n)$ running time also when $m = O(n)$. Our approach
extends to k-edge and k-vertex strongly connected components for any constant k
with a running time of $O(n^2 \log^2 n)$ for edges and $O(n^3)$ for vertices

### New Variants of Pattern Matching with Constants and Variables

Given a text and a pattern over two types of symbols called constants and
variables, the parameterized pattern matching problem is to find all
occurrences of substrings of the text that the pattern matches by substituting
a variable in the text for each variable in the pattern, where the substitution
should be injective. The function matching problem is a variant of it that
lifts the injection constraint. In this paper, we discuss variants of those
problems, where one can substitute a constant or a variable for each variable
of the pattern. We give two kinds of algorithms for both problems, a
convolution-based method and an extended KMP-based method, and analyze their
complexity.Comment: 15 pages, 2 figure

### Data-Oblivious Graph Algorithms in Outsourced External Memory

Motivated by privacy preservation for outsourced data, data-oblivious
external memory is a computational framework where a client performs
computations on data stored at a semi-trusted server in a way that does not
reveal her data to the server. This approach facilitates collaboration and
reliability over traditional frameworks, and it provides privacy protection,
even though the server has full access to the data and he can monitor how it is
accessed by the client. The challenge is that even if data is encrypted, the
server can learn information based on the client data access pattern; hence,
access patterns must also be obfuscated. We investigate privacy-preserving
algorithms for outsourced external memory that are based on the use of
data-oblivious algorithms, that is, algorithms where each possible sequence of
data accesses is independent of the data values. We give new efficient
data-oblivious algorithms in the outsourced external memory model for a number
of fundamental graph problems. Our results include new data-oblivious
external-memory methods for constructing minimum spanning trees, performing
various traversals on rooted trees, answering least common ancestor queries on
trees, computing biconnected components, and forming open ear decompositions.
None of our algorithms make use of constant-time random oracles.Comment: 20 page

### Enumerating Cyclic Orientations of a Graph

Acyclic and cyclic orientations of an undirected graph have been widely
studied for their importance: an orientation is acyclic if it assigns a
direction to each edge so as to obtain a directed acyclic graph (DAG) with the
same vertex set; it is cyclic otherwise. As far as we know, only the
enumeration of acyclic orientations has been addressed in the literature. In
this paper, we pose the problem of efficiently enumerating all the
\emph{cyclic} orientations of an undirected connected graph with $n$ vertices
and $m$ edges, observing that it cannot be solved using algorithmic techniques
previously employed for enumerating acyclic orientations.We show that the
problem is of independent interest from both combinatorial and algorithmic
points of view, and that each cyclic orientation can be listed with
$\tilde{O}(m)$ delay time. Space usage is $O(m)$ with an additional setup cost
of $O(n^2)$ time before the enumeration begins, or $O(mn)$ with a setup cost of
$\tilde{O}(m)$ time

### Space Efficient Algorithms for Breadth-Depth Search

Continuing the recent trend, in this article we design several
space-efficient algorithms for two well-known graph search methods. Both these
search methods share the same name {\it breadth-depth search} (henceforth {\sf
BDS}), although they work entirely in different fashion. The classical
implementation for these graph search methods takes $O(m+n)$ time and $O(n \lg
n)$ bits of space in the standard word RAM model (with word size being
$\Theta(\lg n)$ bits), where $m$ and $n$ denotes the number of edges and
vertices of the input graph respectively. Our goal here is to beat the space
bound of the classical implementations, and design $o(n \lg n)$ space
algorithms for these search methods by paying little to no penalty in the
running time. Note that our space bounds (i.e., with $o(n \lg n)$ bits of
space) do not even allow us to explicitly store the required information to
implement the classical algorithms, yet our algorithms visits and reports all
the vertices of the input graph in correct order.Comment: 12 pages, This work will appear in FCT 201

- …