arXiv subjects

Niranka Banerjee

Publications and source records attributed to Niranka Banerjee.

4 recordsLinked to original sources

arXiv2024

Directed Token Sliding

Reconfiguration problems involve determining whether two given configurations can be transformed into each other under specific rules. The Token Sliding problem asks whether, given two different set of tokens on vertices of a graph $G$, we can transform one into the other by sliding tokens step-by-step along edges of $G$ such that each resulting set of tokens forms an independent set in $G$. Recently, Ito et al. [MFCS 2022] introduced a directed variant of this problem. They showed that for general oriented graphs (i.e., graphs where no pair of vertices can have directed edges in both directions), the problem remains $\mathsf{PSPACE}$-complete, and is solvable in polynomial time on oriented trees. In this paper, we further investigate the Token Sliding problem on various oriented graph classes. We show that the problem remains $\mathsf{PSPACE}$-complete for oriented split graphs, bipartite graphs and bounded treewidth graphs. Additionally, we present polynomial-time algorithms for solving the problem on oriented cycles and cographs.

cs.DS↗

arXiv2024

Distance Recoloring

Reconfiguration problems ask whether one feasible solution can be transformed into another by a sequence of local moves while maintaining feasibility throughout. For integers $d \geq 1$ and $k \geq d+1$, the Distance Coloring problem asks if a given graph $G$ has a $(d, k)$-coloring, i.e., a coloring of the vertices of $G$ by $k$ colors such that any two vertices within distance $d$ from each other have different colors. For ordinary proper colorings ($d=1$), the $k$-Coloring Reconfiguration problem is polynomial-time solvable for $k\le 3$ [Cereceda, van den Heuvel, and Johnson, J. Graph Theory 67(1):69--82, 2011] but is $\mathsf{PSPACE}$-complete for every fixed $k\ge 4$, even on bipartite graphs [Bonsma and Cereceda, Theor. Comput. Sci. 410(50):5215--5226, 2009]. In this work, we initiate a study of the distance-$d$ analogue, for $d \geq 2$. We show that even for planar, bipartite, and $2$-degenerate graphs, $(d, k)$-Coloring Reconfiguration remains $\mathsf{PSPACE}$-complete for every $d \geq 3$ via a reduction from the well-known Sliding Tokens problem. Our construction uses $k = k_0 + 2 + n(\lceil d/2\rceil-1)$ colors on instances of size $n$, where $k_0\in\{3d+3,3d+6\}$ (depending on the parity of $d$). For $d = 2$, the same reduction scheme can be adapted to show that the problem is $\mathsf{PSPACE}$-complete on planar and $2$-degenerate graphs with same values of $k$. Additionally, on split graphs, there is an interesting dichotomy: the problem is $\mathsf{PSPACE}$-complete when $d = 2$ and $k$ is large but can be solved efficiently when $d \geq 3$ and $k \geq d+1$. For chordal graphs, we show that the problem is $\mathsf{PSPACE}$-complete for even values of $d \geq 2$. Finally, we design a quadratic-time algorithm to solve the problem on paths for any $d \geq 2$ and $k \geq d+1$.

cs.DS↗

arXiv2023

The Complexity of Distance-$r$ Dominating Set Reconfiguration

For a fixed integer $r \geq 1$, a distance-$r$ dominating set (D$r$DS) of a graph $G = (V, E)$ is a vertex subset $D \subseteq V$ such that every vertex in $V$ is within distance $r$ from some member of $D$. Given two D$r$DSs $D_s, D_t$ of $G$, the Distance-$r$ Dominating Set Reconfiguration (D$r$DSR) problem asks if there is a sequence of D$r$DSs that transforms $D_s$ into $D_t$ (or vice versa) such that each intermediate member is obtained from its predecessor by applying a given reconfiguration rule exactly once. The problem for $r = 1$ has been well-studied in the literature. We consider D$r$DSR for $r \geq 2$ under two well-known reconfiguration rules: Token Jumping ($\mathsf{TJ}$, which involves replacing a member of the current D$r$DS by a non-member) and Token Sliding ($\mathsf{TS}$, which involves replacing a member of the current D$r$DS by an adjacent non-member). It is known that under any of $\mathsf{TS}$ and $\mathsf{TJ}$, the problem on split graphs is $\mathtt{PSPACE}$-complete for $r = 1$. We show that for $r \geq 2$, the problem is in $\mathtt{P}$, resulting in an interesting complexity dichotomy. Along the way, we prove some non-trivial bounds on the length of a shortest reconfiguration sequence on split graphs when $r = 2$ which may be of independent interest. Additionally, we design a linear-time algorithm under $\mathsf{TJ}$ on trees. On the negative side, we show that D$r$DSR for $r \geq 1$ on planar graphs of maximum degree three and bounded bandwidth is $\mathtt{PSPACE}$-complete, improving the degree bound of previously known results. We also show that the known $\mathtt{PSPACE}$-completeness results under $\mathsf{TS}$ and $\mathsf{TJ}$ for $r = 1$ on bipartite graphs and chordal graphs can be extended for $r \geq 2$.

cs.DS↗

arXiv2017

Improved Space efficient linear time algorithms for BFS, DFS and applications

Recent work by Elmasry et al. (STACS 2015) and Asano et al. (ISAAC 2014), reconsidered classical fundamental graph algorithms focusing on improving the space complexity. We continue this line of work focusing on space. Our first result is a simple data structure that can maintain any subset $S$ of a universe of $n$ elements using $n+o(n)$ bits and support in constant time, apart from the standard insert, delete and membership queries, the operation {\it findany} that finds and returns any element of the set (or outputs that the set is empty). Using this we give a BFS implementation that takes $O(m+n)$ time using at most $2n+o(n)$ bits. Later, we further improve the space requirement of BFS to at most $1.585n + o(n)$ bits. We demonstrate the use of our data structure by developing another data structure using it that can represent a sequence of $n$ non-negative integers $x_1, x_2, \ldots x_n$ using at most $\sum_{i=1}^n x_i + 2n + o(\sum_{i=1}^n x_i+n)$ bits and, in constant time, determine whether the $i$-th element is $0$ or decrement it otherwise. We also discuss an algorithm for finding a minimum weight spanning tree of a weighted undirected graph using at most $n+o(n)$ bits. We also provide an implementation for DFS that takes $O(m+n)$ time and $O(n \lg(m/n))$ bits. Using this DFS algorithm and other careful implementations, we can test biconnectivity, 2-edge connectivity, and determine cut vertices, bridges etc among others, essentially within the same time and space bounds required for DFS. These improve the space required for earlier implementations from $Ω(n\lg n)$ bits.

cs.DS↗