Combined Data Structure for Previous- and Next-Smaller-Values

Let $A$ be a static array storing $n$ elements from a totally ordered set. We present a data structure of optimal size at most $n\log_2(3+2\sqrt{2})+o(n)$ bits that allows us to answer the following queries on $A$ in constant time, without accessing $A$: (1) previous smaller value queries, where given an index $i$, we wish to find the first index to the left of $i$ where $A$ is strictly smaller than at $i$, and (2) next smaller value queries, which search to the right of $i$. As an additional bonus, our data structure also allows to answer a third kind of query: given indices $i<j$, find the position of the minimum in $A[i..j]$. Our data structure has direct consequences for the space-efficient storage of suffix trees.Comment: to appear in Theoretical Computer Scienc

Optimal Doubly Logarithmic Parallel Algorithms Based On Finding All Nearest Smaller Values

The all nearest smaller values problem is defined as follows. Let A = (a 1 ; a 2 ; : : : ; an ) be n elements drawn from a totally ordered domain. For each a i , 1 i n, find the two nearest elements in A that are smaller than a i (if such exist): the left nearest smaller element a j (with j ! i) and the right nearest smaller element a k (with k ? i). We give an O(log log n) time optimal parallel algorithm for the problem on a CRCW PRAM. We apply this algorithm to achieve optimal O(log log n) time parallel algorithms for four problems: (i) Triangulating a monotone polygon, (ii) Preprocessing for answering range minimum queries in constant time, (iii) Reconstructing a binary tree from its inorder and either preorder or postorder numberings, (vi) Matching a legal sequence of parentheses. We also show that any optimal CRCW PRAM algorithm for the triangulation problem requires \Omega\Gammauir log n) time. Dept. of Computing, King&apos;s College London, The Strand, London WC2R 2LS, England. ..

Optimal parallel string algorithms: sorting, merching and computing the minimum

We study fundamental comparison problems on strings of characters, equipped with the usual lexicographical ordering. For each problem studied, we give a parallel algorithm that is optimal with respect to at least one criterion for which no optimal algorithm was previously known. Specifically, our main results are: % \begin{itemize} \item Two sorted sequences of strings, containing altogether $n$~characters, can be merged in $O(\log n)$ time using $O(n)$ operations on an EREW PRAM. This is optimal as regards both the running time and the number of operations. \item A sequence of strings, containing altogether $n$~characters represented by integers of size polynomial in~$n$, can be sorted in $O({{\log n}/{\log\log n}})$ time using $O(n\log\log n)$ operations on a CRCW PRAM. The running time is optimal for any polynomial number of processors. \item The minimum string in a sequence of strings containing altogether $n$ characters can be found using (expected) $O(n)$ operations in constant expected time on a randomized CRCW PRAM, in $O(\log\log n)$ time on a deterministic CRCW PRAM with a program depending on~$n$, in $O((\log\log n)^3)$ time on a deterministic CRCW PRAM with a program not depending on~$n$, in $O(\log n)$ expected time on a randomized EREW PRAM, and in $O(\log n\log\log n)$ time on a deterministic EREW PRAM. The number of operations is optimal, and the running time is optimal for the randomized algorithms and, if the number of processors is limited to~$n$, for the nonuniform deterministic CRCW PRAM algorithm as we

Parameterized Algorithms for Graph Partitioning Problems

In parameterized complexity, a problem instance (I, k) consists of an input I and an extra parameter k. The parameter k usually a positive integer indicating the size of the solution or the structure of the input. A computational problem is called fixed-parameter tractable (FPT) if there is an algorithm for the problem with time complexity O(f(k).nc ), where f(k) is a function dependent only on the input parameter k, n is the size of the input and c is a constant. The existence of such an algorithm means that the problem is tractable for fixed values of the parameter. In this thesis, we provide parameterized algorithms for the following NP-hard graph partitioning problems: (i) Matching Cut Problem: In an undirected graph, a matching cut is a partition of vertices into two non-empty sets such that the edges across the sets induce a matching. The matching cut problem is the problem of deciding whether a given graph has a matching cut. The Matching Cut problem is expressible in monadic second-order logic (MSOL). The MSOL formulation, together with Courcelle’s theorem implies linear time solvability on graphs with bounded tree-width. However, this approach leads to a running time of f(||ϕ||, t) · n, where ||ϕ|| is the length of the MSOL formula, t is the tree-width of the graph and n is the number of vertices of the graph. The dependency of f(||ϕ||, t) on ||ϕ|| can be as bad as a tower of exponentials. In this thesis we give a single exponential algorithm for the Matching Cut problem with tree-width alone as the parameter. The running time of the algorithm is 2O(t) · n. This answers an open question posed by Kratsch and Le [Theoretical Computer Science, 2016]. We also show the fixed parameter tractability of the Matching Cut problem when parameterized by neighborhood diversity or other structural parameters. (ii) H-Free Coloring Problems: In an undirected graph G for a fixed graph H, the H-Free q-Coloring problem asks to color the vertices of the graph G using at most q colors such that none of the color classes contain H as an induced subgraph. That is every color class is H-free. This is a generalization of the classical q-Coloring problem, which is to color the vertices of the graph using at most q colors such that no pair of adjacent vertices are of the same color. The H-Free Chromatic Number is the minimum number of colors required to H-free color the graph. For a fixed q, the H-Free q-Coloring problem is expressible in monadic secondorder logic (MSOL). The MSOL formulation leads to an algorithm with time complexity f(||ϕ||, t) · n, where ||ϕ|| is the length of the MSOL formula, t is the tree-width of the graph and n is the number of vertices of the graph. In this thesis we present the following explicit combinatorial algorithms for H-Free Coloring problems: • An O(q O(t r ) · n) time algorithm for the general H-Free q-Coloring problem, where r = |V (H)|. • An O(2t+r log t · n) time algorithm for Kr-Free 2-Coloring problem, where Kr is a complete graph on r vertices. The above implies an O(t O(t r ) · n log t) time algorithm to compute the H-Free Chromatic Number for graphs with tree-width at most t. Therefore H-Free Chromatic Number is FPT with respect to tree-width. We also address a variant of H-Free q-Coloring problem which we call H-(Subgraph)Free q-Coloring problem, which is to color the vertices of the graph such that none of the color classes contain H as a subgraph (need not be induced). We present the following algorithms for H-(Subgraph)Free q-Coloring problems. • An O(q O(t r ) · n) time algorithm for the general H-(Subgraph)Free q-Coloring problem, which leads to an O(t O(t r ) · n log t) time algorithm to compute the H- (Subgraph)Free Chromatic Number for graphs with tree-width at most t. • An O(2O(t 2 ) · n) time algorithm for C4-(Subgraph)Free 2-Coloring, where C4 is a cycle on 4 vertices. • An O(2O(t r−2 ) · n) time algorithm for {Kr\e}-(Subgraph)Free 2-Coloring, where Kr\e is a graph obtained by removing an edge from Kr. • An O(2O((tr2 ) r−2 ) · n) time algorithm for Cr-(Subgraph)Free 2-Coloring problem, where Cr is a cycle of length r. (iii) Happy Coloring Problems: In a vertex-colored graph, an edge is happy if its endpoints have the same color. Similarly, a vertex is happy if all its incident edges are happy. we consider the algorithmic aspects of the following Maximum Happy Edges (k-MHE) problem: given a partially k-colored graph G, find an extended full k-coloring of G such that the number of happy edges are maximized. When we want to maximize the number of happy vertices, the problem is known as Maximum Happy Vertices (k-MHV). We show that both k-MHE and k-MHV admit polynomial-time algorithms for trees. We show that k-MHE admits a kernel of size k + `, where ` is the natural parameter, the number of happy edges. We show the hardness of k-MHE and k-MHV for some special graphs such as split graphs and bipartite graphs. We show that both k-MHE and k-MHV are tractable for graphs with bounded tree-width and graphs with bounded neighborhood diversity. vii In the last part of the thesis we present an algorithm for the Replacement Paths Problem which is defined as follows: Let G (|V (G)| = n and |E(G)| = m) be an undirected graph with positive edge weights. Let PG(s, t) be a shortest s − t path in G. Let l be the number of edges in PG(s, t). The Edge Replacement Path problem is to compute a shortest s − t path in G\{e}, for every edge e in PG(s, t). The Node Replacement Path problem is to compute a shortest s−t path in G\{v}, for every vertex v in PG(s, t). We present an O(TSP T (G) + m + l 2 ) time and O(m + l 2 ) space algorithm for both the problems, where TSP T (G) is the asymptotic time to compute a single source shortest path tree in G. The proposed algorithm is simple and easy to implement