196 research outputs found

    2-Vertex Connectivity in Directed Graphs

    Full text link
    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

    Full text link
    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

    Full text link
    Motivated by a path planning problem we consider the following procedure. Assume that we have two points ss and tt in the plane and take K=∅\mathcal{K}=\emptyset. At each step we add to K\mathcal{K} a compact convex set that does not contain ss nor tt. The procedure terminates when the sets in K\mathcal{K} separate ss and tt. We show how to add one set to K\mathcal{K} in O(1+kα(n))O(1+k\alpha(n)) amortized time plus the time needed to find all sets of K\mathcal{K} intersecting the newly added set, where nn is the cardinality of K\mathcal{K}, kk is the number of sets in K\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

    Full text link
    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 XX of allowable voting patterns. Such a set XX 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 XX of voting patterns, whether or not XX is a possibility domain. Furthermore, if XX is a possibility domain, then the algorithm constructs in polynomial time such a non-dictatorial aggregator for XX. We then show that the question of whether a Boolean domain XX is a possibility domain is in NLOGSPACE. We also design a polynomial-time algorithm that decides whether XX is a uniform possibility domain, that is, whether XX 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 XX 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 XX is a (uniform) possibility domain.Comment: 21 page

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

    Full text link
    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(mn)O(m n)-time algorithms were known. We use a hierarchical sparsification technique to obtain algorithms that run in time O(n2)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(m2/log⁡n)O(m^2 / \log{n})-time algorithm for 2-edge strongly connected components, and thus improve over the O(mn)O(m n) running time also when m=O(n)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(n2log⁡2n)O(n^2 \log^2 n) for edges and O(n3)O(n^3) for vertices

    New Variants of Pattern Matching with Constants and Variables

    Full text link
    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

    Full text link
    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

    Get PDF
    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 nn vertices and mm 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 O~(m)\tilde{O}(m) delay time. Space usage is O(m)O(m) with an additional setup cost of O(n2)O(n^2) time before the enumeration begins, or O(mn)O(mn) with a setup cost of O~(m)\tilde{O}(m) time

    Space Efficient Algorithms for Breadth-Depth Search

    Full text link
    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)O(m+n) time and O(nlg⁡n)O(n \lg n) bits of space in the standard word RAM model (with word size being Θ(lg⁡n)\Theta(\lg n) bits), where mm and nn 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(nlg⁡n)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(nlg⁡n)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
    • …
    corecore