Papers by Sankardeep Chakraborty
2022 Data Compression Conference (DCC)
2022 Data Compression Conference (DCC)
Theoretical Computer Science
We consider the problem of designing succinct navigational oracles, i.e., succinct data structure... more We consider the problem of designing succinct navigational oracles, i.e., succinct data structures supporting basic navigational queries such as degree, adjacency and neighborhood efficiently for intersection graphs on a circle, which include graph classes such as circle graphs, k-polygoncircle graphs, circle-trapezoid graphs, trapezoid graphs. The degree query reports the number of incident edges to a given vertex, the adjacency query asks if there is an edge between two given vertices, and the neighborhood query enumerates all the neighbors of a given vertex. We first prove a general lower bound for these intersection graph classes, and then present a uniform approach that lets us obtain matching lower and upper bounds for representing each of these graph classes. More specifically, our lower bound proofs use a unified technique to produce tight bounds for all these classes, and this is followed by our data structures which are also obtained from a unified representation method to achieve succinctness for each class. In addition, we prove a lower bound of space for representing trapezoid graphs, and give a succinct navigational oracle for this class of graphs.
2021 Data Compression Conference (DCC)
Clique-width is a well-studied graph parameter owing to its use in understanding algorithmic trac... more Clique-width is a well-studied graph parameter owing to its use in understanding algorithmic tractability. In this paper we design a succinct data structure for graphs on $n$ vertices whose clique-width is at most $k \leq \epsilon \sqrt{\log n / \log \log n}$ for some constant $0<\epsilon<1$, along with supporting degree, adjacency, neighborhood queries efficiently. This resolves an open problem of Kamali (Algorithmica-2018).
Norsk IKT-konferanse for forskning og utdanning, Nov 14, 2021
Nowadays graph data have become absolutely ubiquitous in various applications starting from socia... more Nowadays graph data have become absolutely ubiquitous in various applications starting from social/road networks to bio-medical data etc. Given such graph data, a reachability query asks if there exists a path from a source vertex to a target vertex in the graph. Due to its immense implications in both theory and applied domains, this query and many of its variants have been extensively studied in the literature. One such variant investigates the reachability between two vertices in an edge-labeled graph while constraining the label set simultaneously. This problem has recently been addressed by Valstar et al. [SIGMOD'17] who proposed an approach called the landmark indexing (LI) to support faster label-constrained reachability (LCR) queries. In this work, we introduce a simple, practical and space-efficient solution for answering LCR queries even faster. The experimental evaluation shows significant time and space efficiency benefits of our proposed solution over the LI approach for this problem in both real-world and synthetic graphs.
SSRN Electronic Journal, 2022
Deterministic finite automata are one of the simplest and most practical models of computation st... more Deterministic finite automata are one of the simplest and most practical models of computation studied in automata theory. Their conceptual extension is the non-deterministic finite automata which also have plenty of applications. In this article, we study these models through the lens of succinct data structures where our ultimate goal is to encode these mathematical objects using information theoretically optimal number of bits along with supporting queries on them efficiently. Towards this goal, we first design a succinct data structure for representing any deterministic finite automaton D having n states over a σ-letter alphabet Σ using (σ−1)n log n+O(n log σ) bits of space, which can determine, given an input string x over Σ, whether D accepts x in O(|x| log σ) time, using constant words of working space. When the input deterministic finite automaton is acyclic, not only we can improve the above space bound significantly to (σ − 1)(n − 1) log n + 3n + O(log 2 σ) + o(n) bits, we also obtain optimal query time for string acceptance checking. More specifically, using our succinct representation, we can check if a given input string x can be accepted by the acyclic deterministic finite automaton using time proportional to the length of x, hence, the optimal query time. We also exhibit a succinct data structure for representing a non-deterministic finite automaton N having n states over a σ-letter alphabet Σ using σn 2 + n bits of space, such that given an input string x, we can decide whether N accepts x efficiently in O(n 2 |x|) time. Finally, we also provide time and space efficient algorithms for performing several standard operations such as union, intersection and complement on the languages accepted by deterministic finite automata.
Lecture Notes in Computer Science, 2019
We consider the problem of designing succinct data structures for interval graphs with n vertices... more We consider the problem of designing succinct data structures for interval graphs with n vertices while supporting degree, adjacency, neighborhood and shortest path queries in optimal time. Towards showing succinctness, we first show that at least n log 2 n−2n log 2 log 2 n−O(n) bits are necessary to represent any unlabeled interval graph G with n vertices, answering an open problem of Yang and Pippenger [Proc. Amer. Math. Soc. 2017]. This is augmented by a data structure of size n log 2 n + O(n) bits while supporting not only the above queries optimally but also capable of executing various combinatorial algorithms (like proper coloring, maximum independent set etc.) on interval graphs efficiently. Finally, we extend our ideas to other variants of interval graphs, for example, proper/unit interval graphs, kimproper interval graphs, and circular-arc graphs, and design succinct data structures for these graph classes as well along with supporting queries on them efficiently.
2021 Data Compression Conference (DCC), 2021
We consider the problem of designing succinct encodings for some intersection graphs on a circle,... more We consider the problem of designing succinct encodings for some intersection graphs on a circle, which include graph classes such as circle graphs, k-polygon-circle graphs, circle-trapezoid graphs among others. More specifically, we first prove a general counting lower bound, which is of independent interest, for these intersection graph classes, and then present a uniform encoding approach that lets us obtain matching lower and upper bounds for their succinct representation.
Combinatorial Algorithms, 2020
We present linear time in-place algorithms for several fundamental graph problems including the w... more We present linear time in-place algorithms for several fundamental graph problems including the well-known graph search methods (like depth-first search, breadth-first search, maximum cardinality search), connectivity problems (like biconnectivity, 2-edge connectivity), decomposition problem (like chain decomposition) among various others, improving the running time (by polynomial multiplicative factor) of the recent results of Chakraborty et al. [ESA, 2018] who designed \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(n^3 \lg n)$$\end{document} time in-place algorithms for some of the above mentioned problems. The running times of all our algorithms are essentially optimal as they run in linear time. One of the main ideas behind obtaining these algorithms is the detection and careful exploitation of so...
Combinatorial Optimization and Applications, 2021
We design succinct encodings of series-parallel, block-cactus and 3-leaf power graphs while suppo... more We design succinct encodings of series-parallel, block-cactus and 3-leaf power graphs while supporting the basic navigational queries such as degree, adjacency and neighborhood optimally in the RAM model with logarithmic word size. One salient feature of our representation is that it can achieve optimal space even though the exact space lower bound for these graph classes is not known. For these graph classes, we provide succinct data structures with optimal query support for the first time in the literature. For series-parallel multigraphs, our work also extends the works of Uno et al. (Disc. Math. Alg. and Appl., 2013) and Blelloch and Farzan (CPM, 2010) to produce optimal bounds.
ArXiv, 2020
We consider the range mode problem where given a sequence and a query range in it, we want to fin... more We consider the range mode problem where given a sequence and a query range in it, we want to find items with maximum frequency in the range. We give time- and space- efficient algorithms for this problem. Our algorithms are efficient for small maximum frequency cases. We also consider a natural generalization of the problem: the range mode enumeration problem, for which there has been no known efficient algorithms. Our algorithms have query time complexities which is linear to the output size plus small terms.
Read-only memory (ROM) model is a classical model of computation to study time-space tradeoffs of... more Read-only memory (ROM) model is a classical model of computation to study time-space tradeoffs of algorithms. A classical result on the ROM model is that any algorithm to sort n numbers using O(s) words of extra space requires Omega (n^2/s) comparisons for lg n <= s <= n/lg n and the bound has also been recently matched by an algorithm. However, if we relax the model, we do have sorting algorithms (say Heapsort) that can sort using O(n lg n) comparisons using O(lg n) bits of extra space, even keeping a permutation of the given input sequence at anytime during the algorithm. We address similar relaxations for graph algorithms. We show that a simple natural relaxation of ROM model allows us to implement fundamental graph search methods like BFS and DFS more space efficiently than in ROM. By simply allowing elements in the adjacency list of a vertex to be permuted, we show that, on an undirected or directed connected graph G having n vertices and m edges, the vertices of G can be...
ArXiv, 2019
We consider the problem of compactly representing the Depth First Search (DFS) tree of a given un... more We consider the problem of compactly representing the Depth First Search (DFS) tree of a given undirected or directed graph having $n$ vertices and $m$ edges while supporting various DFS related queries efficiently in the RAM with logarithmic word size. We study this problem in two well-known models: {\it indexing} and {\it encoding} models. While most of these queries can be supported easily in constant time using $O(n \lg n)$ bits\footnote{We use $\lg$ to denote logarithm to the base $2$.} of extra space, our goal here is, more specifically, to beat this trivial $O(n \lg n)$ bit space bound, yet not compromise too much on the running time of these queries. In the {\it indexing} model, the space bound of our solution involves the quantity $m$, hence, we obtain different bounds for sparse and dense graphs respectively. In the {\it encoding} model, we first give a space lower bound, followed by an almost optimal data structure with extremely fast query time. Central to our algorithm ...
Deterministic finite automata are one of the simplest and most practical models of computation st... more Deterministic finite automata are one of the simplest and most practical models of computation studied in automata theory. Their conceptual extension is the non-deterministic finite automata which also have plenty of applications. In this article, we study these models through the lens of succinct data structures where our ultimate goal is to encode these mathematical objects using information theoretically optimal number of bits along with supporting queries on them efficiently. Towards this goal, we first design a succinct data structure for representing any deterministic finite automaton D having n states over a σ-letter alphabet Σ using (σ−1)n log n+O(n log σ) bits of space, which can determine, given an input string x over Σ, whether D accepts x in O(|x| log σ) time, using constant words of working space. When the input deterministic finite automaton is acyclic, not only we can improve the above space bound significantly to (σ − 1)(n − 1) log n + 3n + O(log 2 σ) + o(n) bits, we also obtain optimal query time for string acceptance checking. More specifically, using our succinct representation, we can check if a given input string x can be accepted by the acyclic deterministic finite automaton using time proportional to the length of x, hence, the optimal query time. We also exhibit a succinct data structure for representing a non-deterministic finite automaton N having n states over a σ-letter alphabet Σ using σn 2 + n bits of space, such that given an input string x, we can decide whether N accepts x efficiently in O(n 2 |x|) time. Finally, we also provide time and space efficient algorithms for performing several standard operations such as union, intersection and complement on the languages accepted by deterministic finite automata.
ArXiv, 2017
This short note provides space-efficient linear time algorithms for computing bridges, topologica... more This short note provides space-efficient linear time algorithms for computing bridges, topological sorting, and strongly connected components improving on several recent results of Elmasry et al. [STACS'15], Banerjee et al. [COCOON'16] and Chakraborty et al. [ISAAC'16]. En route, we also provide another DFS implementation with weaker input graph representation assumption without compromising on the time and space bounds of the earlier results of Banerjee et al. [COCOON'16] and Kammer et al. [MFCS'16].
Journal of Computer and System Sciences, 2022
Read-only memory (ROM) model is a classical model of computation to study time-space tradeoffs of... more Read-only memory (ROM) model is a classical model of computation to study time-space tradeoffs of algorithms. One of the classical results on the ROM model is that any sorting algorithm that uses O(s) words of extra space requires Ω(n 2 /s) comparisons for lg n ≤ s ≤ n/ lg n 1 and the bound has also been recently matched by an algorithm. However, if we relax the model (from ROM), we do have sorting algorithms (say Heapsort) that can sort using O(n lg n) comparisons using O(lg n) bits of extra space, even keeping a permutation of the given input sequence at any point of time during the algorithm. We address similar questions for graph algorithms. We show that a simple natural relaxation of ROM model allows us to implement fundamental graph search methods like BFS and DFS more space efficiently than in ROM. By simply allowing elements in the adjacency list of a vertex to be permuted, we show that, on an undirected or directed connected graph G having n vertices and m edges, the vertices of G can be output in a DFS or BFS order using O(lg n) bits of extra space and O(n 3 lg n) time. Thus we obtain similar bounds for reachability and shortest path distance (both for undirected and directed graphs). With a little more (but still polynomial) time, we can also output vertices in the lex-DFS order. As reachability in directed graphs (even in DAGs) and shortest path distance (even in undirected graphs) are NL-complete, and lex-DFS is P-complete, our results show that our model is more powerful than ROM if L = P. En route, we also introduce and develop algorithms for another relaxation of ROM where the adjacency lists of the vertices are circular lists and we can modify only the heads of the lists. Here we first show a linear time DFS implementation using n + O(lg n) bits of extra space. Improving the extra space further to only O(lg n) bits, we also obtain BFS and DFS albeit with a slightly slower running time. Some of these algorithms also translate to improved algorithms for DFS and its applications in ROM. Both the models we propose maintain the graph structure throughout the algorithm, only the order of vertices in the adjacency list changes. In sharp contrast, for BFS and DFS, to the best of our knowledge, there are no algorithms in ROM that use even O(n 1−) bits of extra space; in fact, implementing DFS using cn bits for c < 1 has been mentioned as an open problem. Furthermore, DFS (BFS) algorithms using n + o(n) (o(n)) bits of extra use Reingold's [JACM, 2008] or Barnes et al's reachability algorithm [SICOMP, 1998] and hence have high runtime. Our results can be contrasted with the recent result of Buhrman et al. [STOC, 2014] which gives an algorithm for directed st-reachability on catalytic Turing machines using O(lg n) bits with catalytic space O(n 2 lg n) and time O(n 9). All our algorithms are simple but quite subtle, and we believe that these models are practical enough to spur interest for other graph problems in these models.
Fundamentals of Computation Theory, 2019
Continuing the recent trend, in this article we design several space-efficient algorithms for two... more 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 breadth-depth search (henceforth 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 Θ(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.
Algorithmica, 2020
We consider the problem of designing succinct data structures for interval graphs with n vertices... more We consider the problem of designing succinct data structures for interval graphs with n vertices while supporting degree, adjacency, neighborhood and shortest path queries in optimal time. Towards showing succinctness, we first show that at least n log 2 n − 2n log 2 log 2 n − O(n) bits are necessary to represent any unlabeled interval graph G with n vertices, answering an open problem of Yang and Pippenger (Proc Am Math Soc Ser B 4(1):1-3, 2017). This is augmented by a data structure of size n log 2 n + O(n) bits while supporting not only the above queries optimally but also capable of executing various combinatorial algorithms (like proper coloring, maximum independent set etc.) on interval graphs efficiently. Finally, we extend our ideas to other variants of interval graphs, for example, proper/unit interval graphs, k-improper interval graphs, and circular-arc graphs, and design succinct data structures for these graph classes as well along with supporting queries on them efficiently.
Journal of Combinatorial Optimization, 2018
Following the recent trends of designing space efficient algorithms for fundamental algorithmic g... more Following the recent trends of designing space efficient algorithms for fundamental algorithmic graph problems, we present several time-space tradeoffs for performing maximum cardinality search (MCS), stack breadth first search, and queue breadth first search on a given input graph. As applications of these results, we also provide space-efficient implementations for testing if a given undirected graph is chordal, reporting an independent set, and a proper coloring of a given chordal graph among others. Finally, we also show how two other seemingly different graph problems and their algorithms have surprising connection with MCS with respect to designing space efficient algorithms. Keywords Maximum cardinality search • Graph algorithms • Breadth-first search • Depth-first search • Chordal graphs Some of these results were announced in preliminary form in the proceedings of 23rd International Computing and Combinatorics Conference (COCOON 2017), Springer LNCS volume 10392, pages 87-98 (Chakraborty and Satti 2017).
Journal of Computer and System Sciences, 2017
We consider space efficient implementations of some classical applications of DFS including the p... more We consider space efficient implementations of some classical applications of DFS including the problem of testing biconnectivity and 2-edge connectivity, finding cut vertices and cut edges, computing chain decomposition and st-numbering of a given undirected graph G on n vertices and m edges. Classical algorithms for them typically use DFS and some Ω(lg n) bits 1 of information at each vertex. Building on a recent O(n)-bits implementation of DFS due to Elmasry et al. (STACS 2015) we provide O(n)-bit implementations for all these applications of DFS. Our algorithms take O(m lg c n lg lg n) time for some small constant c (where c ≤ 2). Central to our implementation is a succinct representation of the DFS tree and a space efficient partitioning of the DFS tree into connected subtrees, which maybe of independent interest for designing other space efficient graph algorithms. 1 We use lg to denote logarithm to the base 2. $ Some of these results were announced in preliminary form in the proceedings of 27th International Symposium on Algorithms and
Uploads
Papers by Sankardeep Chakraborty