arXiv subjects

Sasanka Roy

Publications and source records attributed to Sasanka Roy.

At least 19 recordsLinked to original sources

arXiv2026

Witness Set: A Visibility Problem in $NP\cap XP$

We study the Witness Set problem, a natural dual to the classical Art Gallery problem. In the Witness Set problem, we are given a polygon $P$ and an integer $k$ as input, and the objective is to determine whether $P$ has a witness set of size at least $k$. A point set $X$ in $P$ is called a witness set if every point in $P$ is visible from at most one point in $X$. For simple polygons, we show that Witness Set lies in both $NP$ and $XP$. This stands in sharp contrast to its dual, the Art Gallery problem, which was recently shown to be $\exists \mathbb{R}$-complete by Abrahamsen et al. and is therefore neither in $NP$ nor admits a polynomial-size discretization unless $NP=\exists \mathbb{R}$. In contrast, we prove that Witness Set for simple polygons admits a finite discretization of size $n^{f(k)}$ for some function $f$. For comparison, even for simple polygons, Efrat and Har-Peled gave an algorithm for Art Gallery running in time $n^{O(k)}$ using tools from real algebraic geometry, and it appears difficult to obtain such algorithms without this machinery. On the other hand, our approach for Witness Set is purely combinatorial and relies on discretization, leading to an $n^{f(k)}$-time algorithm. Although Amit et al. claimed more than fifteen years ago that Witness Set is $NP$-hard, no proof or reference was provided. We show that the discrete version of the Witness Set problem - where the witness set must be chosen from a given finite point set $Q$ (instead of allowing witnesses to be chosen anywhere in the polygon), referred to as Discrete Witness Set - is $NP$-complete, even when the input is restricted to rectilinear polygons with holes. However, for simple polygons, Discrete Witness Set admits a polynomial-time algorithm by Das et al. Thus, it remains an open question whether the Witness Set problem is $NP$-hard.

cs.CG↗

arXiv2025

Witness Set in Monotone Polygons: Exact and Approximate

Given a simple polygon $\mathscr{P}$, two points $x$ and $y$ within $\mathscr{P}$ are {\em visible} to each other if the line segment between $x$ and $y$ is contained in $\mathscr{P}$. The {\em visibility region} of a point $x$ includes all points in $\mathscr{P}$ that are visible from $x$. A point set $Q$ within a polygon $\mathscr{P}$ is said to be a \emph{witness set} for $\mathscr{P}$ if each point in $\mathscr{P}$ is visible from at most one point from $Q$. The problem of finding the largest size witness set in a given polygon was introduced by Amit et al. [Int. J. Comput. Geom. Appl. 2010]. Recently, Daescu et al. [Comput. Geom. 2019] gave a linear-time algorithm for this problem on monotone mountains. In this study, we contribute to this field by obtaining the largest witness set within both continuous and discrete models. In the {\sc Witness Set (WS)} problem, the input is a polygon $\mathscr{P}$, and the goal is to find a maximum-sized witness set in $\mathscr{P}$. In the {\sc Discrete Witness Set (DisWS)} problem, one is given a finite set of points $S$ alongside $\mathscr{P}$, and the task is to find a witness set $Q \subseteq S$ that maximizes $|Q|$. We investigate {\sc DisWS} in simple polygons, but consider {\sc WS} specifically for monotone polygons. Our main contribution is as follows: (1) a polynomial time algorithm for {\sc DisWS} for general polygons and (2) the discretization of the {\sc WS} problem for monotone polygons. Specifically, given a monotone polygon with $r$ reflex vertices, and a positive integer $k$ we generate a point set $Q$ with size $r^{O(k)} \cdot n$ such that $Q$ contains an witness set of size $k$ (if exists). This leads to an exact algorithm for {\sc WS} problem in monotone polygons running in time $r^{O(k)} \cdot n^{O(1)}$. We also provide a PTAS for this with running time $r^{O(1/\epsilon)} n^2$.

cs.CG↗

arXiv2024

New Complexity and Algorithmic Bounds for Minimum Consistent Subsets

In the Minimum Consistent Subset (MCS) problem, we are presented with a connected simple undirected graph $G=(V,E)$, consisting of a vertex set $V$ of size $n$ and an edge set $E$. Each vertex in $V$ is assigned a color from the set $\{1,2,\ldots, c\}$. The objective is to determine a subset $V' \subseteq V$ with minimum possible cardinality, such that for every vertex $v \in V$, at least one of its nearest neighbors in $V'$ (measured in terms of the hop distance) shares the same color as $v$. A variant of MCS is the minimum strict consistent subset (MSCS) in which instead of requiring at least one nearest neighbor of $v$, all the nearest neighbors of $v$ in $V'$ must have the same color as $v$. The decision version for MCS problem as well as for MSCS problem asks whether there exists a subset $V'$ of cardinality at most $l$ for some positive integer $l$. The MCS problem is known to be NP-complete for planar graphs. In this paper, we establish that the MCS problem for trees, when the number of colors $c$ is considered an input parameter, is NP-complete. We propose a fixed-parameter tractable (FPT) algorithm for MCS on trees running in $O(2^{6c}n^6)$ time, significantly improving the currently best-known algorithm whose running time is $O(2^{4c}n^{2c+3})$. In an effort to comprehensively understand the computational complexity of the MCS problem across different graph classes, we extend our investigation to interval graphs. We show that it remains NP-complete for interval graphs, thus enriching graph classes where MCS remains intractable. We also show that the MSCS problem is log-APX-hard on general graphs and NP-complete on planar graphs.

cs.CG↗

arXiv2021

Constant Delay Lattice Train Schedules

The following geometric vehicle scheduling problem has been considered: given continuous curves $f_1, \ldots, f_n : \mathbb{R} \rightarrow \mathbb{R}^2$, find non-negative delays $t_1, \ldots, t_n$ minimizing $\max \{ t_1, \ldots, t_n \}$ such that, for every distinct $i$ {and $j$} and every time $t$, $| f_j (t - t_j) - f_i (t - t_i) | > \ell$, where~$\ell$ is a given safety distance. We study a variant of this problem where we consider trains (rods) of fixed length $\ell$ that move at constant speed and sets of train lines (tracks), each of which consisting of an axis-parallel line-segment with endpoints in the integer lattice $\mathbb{Z}^d$ and of a direction of movement (towards $\infty$ {or $- \infty$}). We are interested in upper bounds on the maximum delay we need to introduce on any line to avoid collisions, but more specifically on universal upper bounds that apply no matter the set of train lines. We show small universal constant upper bounds for $d = 2$ and any given $\ell$ and also for $d = 3$ and $\ell = 1$. Through clique searching, we are also able to show that several of these upper bounds are tight.

cs.CG↗

arXiv2020

Maximum Bipartite Subgraph of Geometric Intersection Graphs

We study the Maximum Bipartite Subgraph (MBS) problem, which is defined as follows. Given a set $S$ of $n$ geometric objects in the plane, we want to compute a maximum-size subset $S'\subseteq S$ such that the intersection graph of the objects in $S'$ is bipartite. We first give a simple $O(n)$-time algorithm that solves the MBS problem on a set of $n$ intervals. We also give an $O(n^2)$-time algorithm that computes a near-optimal solution for the problem on circular-arc graphs. We show that the MBS problem is NP-hard on geometric graphs for which the maximum independent set is NP-hard (hence, it is NP-hard even on unit squares and unit disks). On the other hand, we give a PTAS for the problem on unit squares and unit disks. Moreover, we show fast approximation algorithms with small-constant factors for the problem on unit squares, unit disks and unit-height rectangles. Finally, we study a closely related geometric problem, called Maximum Triangle-free Subgraph (TFS), where the objective is the same as that of MBS except the intersection graph induced by the set $S'$ needs to be triangle-free only (instead of being bipartite).

cs.DM↗

arXiv2019

Corrigendum to: "Linear time algorithm to cover and hit a set of line segments optimally by two axis-parallel squares", Theoretical Computer Science 769 (2019) 63--74

In the paper "Linear time algorithm to cover and hit a set of line segments optimally by two axis-parallel squares", TCS Volume 769 (2019), pages 63--74, the LHIT problem is proposed as follows: For a given set of non-intersecting line segments ${\cal L} = \{\ell_1, \ell_2, \ldots, \ell_n\}$ in $I\!\!R^2$, compute two axis-parallel congruent squares ${\cal S}_1$ and ${\cal S}_2$ of minimum size whose union hits all the line segments in $\cal L$, and a linear time algorithm was proposed. Later it was observed that the algorithm has a bug. In this corrigendum, we corrected the algorithm. The time complexity of the corrected algorithm is $O(n^2)$.

cs.CG↗

arXiv2019

Linear Size Planar Manhattan Network for Convex Point Sets

Let $G = (V, E)$ be an edge-weighted geometric graph such that every edge is horizontal or vertical. The weight of an edge $uv \in E$ is its length. Let $ W_G (u,v)$ denote the length of a shortest path between a pair of vertices $u$ and $v$ in $G$. The graph $G$ is said to be a Manhattan network for a given point set $ P $ in the plane if $P \subseteq V$ and $\forall p,q \in P$, $ W_G (p,q)=|pq|_1$. In addition to $ P$, graph $G$ may also include a set $T$ of Steiner points in its vertex set $V$. In the Manhattan network problem, the objective is to construct a Manhattan network of small size for a set of $ n $ points. This problem was first considered by Gudmundsson et al.\cite{gudmundsson2007small}. They give a construction of a Manhattan network of size $Θ(n \log n)$ for general point set in the plane. We say a Manhattan network is planar if it can be embedded in the plane without any edge crossings. In this paper, we construct a linear size planar Manhattan network for convex point set in linear time using $\mathcal{ O}(n)$ Steiner points. We also show that, even for convex point set, the construction in Gudmundsson et al. \cite{gudmundsson2007small} needs $Ω(n \log n)$ Steiner points and the network may not be planar.

cs.CG↗

arXiv2019

Balanced Connected Subgraph Problem in Geometric Intersection Graphs

We study the Balanced Connected Subgraph(shortly, BCS) problem on geometric intersection graphs such as interval, circular-arc, permutation, unit-disk, outer-string graphs, etc. Given a vertex-colored graph $G=(V,E)$, where each vertex in $V$ is colored with either ``red'' or ``blue'', the BCS problem seeks a maximum cardinality induced connected subgraph $H$ of $G$ such that $H$ is color-balanced, i.e., $H$ contains an equal number of red and blue vertices. We study the computational complexity landscape of the BCS problem while considering geometric intersection graphs. On one hand, we prove that the BCS problem is NP-hard on the unit disk, outer-string, complete grid, and unit square graphs. On the other hand, we design polynomial-time algorithms for the BCS problem on interval, circular-arc and permutation graphs. In particular, we give algorithm for the Steiner Tree problem on both the interval graphs and circular arc graphs, that is used as a subroutine for solving BCS problem on same graph classes. Finally, we present a FPT algorithm for the BCS problem on general graphs.

cs.DM↗

arXiv2018

The Balanced Connected Subgraph Problem

The problem of computing induced subgraphs that satisfy some specified restrictions arises in various applications of graph algorithms and has been well studied. In this paper, we consider the following Balanced Connected Subgraph (shortly, BCS) problem. The input is a graph $G=(V,E)$, with each vertex in the set $V$ having an assigned color, "red" or "blue". We seek a maximum-cardinality subset $V'\subseteq V$ of vertices that is color-balanced (having exactly $|V'|/2$ red nodes and $|V'|/2$ blue nodes), such that the subgraph induced by the vertex set $V'$ in $G$ is connected. We show that the BCS problem is NP-hard, even for bipartite graphs $G$ (with red/blue color assignment not necessarily being a proper 2-coloring). Further, we consider this problem for various classes of the input graph $G$, including, e.g., planar graphs, chordal graphs, trees, split graphs, bipartite graphs with a proper red/blue $2$-coloring, and graphs with diameter $2$. For each of these classes either we prove NP-hardness or design a polynomial time algorithm.

cs.DM↗

arXiv2018

Maximal and maximum transitive relation contained in a given binary relation

We study the problem of finding a \textit{maximal} transitive relation contained in a given binary relation. Given a binary relation of size $m$ defined on a set of size $n$, we present a polynomial time algorithm that finds a maximal transitive sub-relation in time $O(n^2 + nm)$. We also study the problem of finding a \textit{maximum} transitive relation contained in a binary relation. This is the problem of computing a maximum transitive subgraph in a given digraph. For the class of directed graphs with the underlying graph being triangle-free, we present a $0.874$-approximation algorithm. This is achieved via a simple connection to the problem of maximum directed cut. Further, we give an upper bound for the size of any maximum transitive relation to be $m/4 + cm^{4/5}$, where $c > 0$ and $m$ is the number of edges in the digraph.

cs.DS↗

arXiv2017

A linear time algorithm to cover and hit a set of line segments optimally by two axis-parallel squares

This paper discusses the problem of covering and hitting a set of line segments $\cal L$ in ${\mathbb R}^2$ by a pair of axis-parallel squares such that the side length of the larger of the two squares is minimized. We also discuss the restricted version of covering, where each line segment in $\cal L$ is to be covered completely by at least one square. The proposed algorithm for the covering problem reports the optimum result by executing only two passes of reading the input data sequentially. The algorithm proposed for the hitting and restricted covering problems produces optimum result in $O(n)$ time. All the proposed algorithms are in-place, and they use only $O(1)$ extra space. The solution of these problems also give a $\sqrt{2}$ approximation for covering and hitting those line segments $\cal L$ by two congruent disks of minimum radius with same computational complexity.

cs.CG↗

arXiv2017

Fast Gaussian Process Regression for Big Data

Gaussian Processes are widely used for regression tasks. A known limitation in the application of Gaussian Processes to regression tasks is that the computation of the solution requires performing a matrix inversion. The solution also requires the storage of a large matrix in memory. These factors restrict the application of Gaussian Process regression to small and moderate size data sets. We present an algorithm that combines estimates from models developed using subsets of the data obtained in a manner similar to the bootstrap. The sample size is a critical parameter for this algorithm. Guidelines for reasonable choices of algorithm parameters, based on detailed experimental study, are provided. Various techniques have been proposed to scale Gaussian Processes to large scale regression tasks. The most appropriate choice depends on the problem context. The proposed method is most appropriate for problems where an additive model works well and the response depends on a small number of features. The minimax rate of convergence for such problems is attractive and we can build effective models with a small subset of the data. The Stochastic Variational Gaussian Process and the Sparse Gaussian Process are also appropriate choices for such problems. These methods pick a subset of data based on theoretical considerations. The proposed algorithm uses bagging and random sampling. Results from experiments conducted as part of this study indicate that the algorithm presented in this work can be as effective as these methods. Model stacking can be used to combine the model developed with the proposed method with models from other methods for large scale regression such as Gradient Boosted Trees. This can yield performance gains.

cs.LG↗

arXiv2016

Faster Approximation for Maximum Independent Set on Unit Disk Graph

Maximum independent set from a given set $D$ of unit disks intersecting a horizontal line can be solved in $O(n^2)$ time and $O(n^2)$ space. As a corollary, we design a factor 2 approximation algorithm for the maximum independent set problem on unit disk graph which takes both time and space of $O(n^2)$. The best known factor 2 approximation algorithm for this problem runs in $O(n^2 \log n)$ time and takes $O(n^2)$ space [Jallu and Das 2016, Das et al. 2016].

cs.CG↗

arXiv2016

Covering segments with unit squares

We study several variations of line segment covering problem with axis-parallel unit squares in $I\!\!R^2$. A set $S$ of $n$ line segments is given. The objective is to find the minimum number of axis-parallel unit squares which cover at least one end-point of each segment. The variations depend on the orientation and length of the input segments. We prove some of these problems to be NP-complete, and give constant factor approximation algorithms for those problems. For some variations, we have polynomial time exact algorithms. For the general version of the problem, where the segments are of arbitrary length and orientation, and the squares are given as input, we propose a factor 16 approximation result based on multilevel linear programming relaxation technique, which may be useful for solving some other problems. Further, we show that our problems have connections with the problems studied by Arkin et al. 2015 on conflict-free covering problem. Our NP-completeness results hold for more simplified types of objects than those of Arkin et al. 2015.

cs.CG↗

arXiv2016

Color Spanning Annulus: Square, Rectangle and Equilateral Triangle

In this paper, we study different variations of minimum width color-spanning annulus problem among a set of points $P=\{p_1,p_2,\ldots,p_n\}$ in $I\!\!R^2$, where each point is assigned with a color in $\{1, 2, \ldots, k\}$. We present algorithms for finding a minimum width color-spanning axis parallel square annulus $(CSSA)$, minimum width color spanning axis parallel rectangular annulus $(CSRA)$, and minimum width color-spanning equilateral triangular annulus of fixed orientation $(CSETA)$. The time complexities of computing (i) a $CSSA$ is $O(n^3+n^2k\log k)$ which is an improvement by a factor $n$ over the existing result on this problem, (ii) that for a $CSRA$ is $O(n^4\log n)$, and for (iii) a $CSETA$ is $O(n^3k)$. The space complexity of all the algorithms is $O(k)$.

cs.CG↗

arXiv2015

Approximation algorithms for the two-center problem of convex polygon

Given a convex polygon $P$ with $n$ vertices, the two-center problem is to find two congruent closed disks of minimum radius such that they completely cover $P$. We propose an algorithm for this problem in the streaming setup, where the input stream is the vertices of the polygon in clockwise order. It produces a radius $r$ satisfying $r\leq2r_{opt}$ using $O(1)$ space, where $r_{opt}$ is the optimum solution. Next, we show that in non-streaming setup, we can improve the approximation factor by $r\leq 1.84 r_{opt}$, maintaining the time complexity of the algorithm to $O(n)$, and using $O(1)$ extra space in addition to the space required for storing the input.

cs.CG↗

arXiv2014

Facility location problems in the constant work-space read-only memory model

Facility location problems are captivating both from theoretical and practical point of view. In this paper, we study some fundamental facility location problems from the space-efficient perspective. Here the input is considered to be given in a read-only memory and only constant amount of work-space is available during the computation. This {\em constant-work-space model} is well-motivated for handling big-data as well as for computing in smart portable devices with small amount of extra-space. First, we propose a strategy to implement prune-and-search in this model. As a warm up, we illustrate this technique for finding the Euclidean 1-center constrained on a line for a set of points in $\IR^2$. This method works even if the input is given in a sequential access read-only memory. Using this we show how to compute (i) the Euclidean 1-center of a set of points in $\IR^2$, and (ii) the weighted 1-center and weighted 2-center of a tree network. The running time of all these algorithms are $O(n~poly(\log n))$. While the result of (i) gives a positive answer to an open question asked by Asano, Mulzer, Rote and Wang in 2011, the technique used can be applied to other problems which admit solutions by prune-and-search paradigm. For example, we can apply the technique to solve two and three dimensional linear programming in $O(n~poly(\log n))$ time in this model. To the best of our knowledge, these are the first sub-quadratic time algorithms for all the above mentioned problems in the constant-work-space model. We also present optimal linear time algorithms for finding the centroid and weighted median of a tree in this model.

cs.DS↗

arXiv2013

Helly-Type Theorems in Property Testing

Helly's theorem is a fundamental result in discrete geometry, describing the ways in which convex sets intersect with each other. If $S$ is a set of $n$ points in $R^d$, we say that $S$ is $(k,G)$-clusterable if it can be partitioned into $k$ clusters (subsets) such that each cluster can be contained in a translated copy of a geometric object $G$. In this paper, as an application of Helly's theorem, by taking a constant size sample from $S$, we present a testing algorithm for $(k,G)$-clustering, i.e., to distinguish between two cases: when $S$ is $(k,G)$-clusterable, and when it is $ε$-far from being $(k,G)$-clusterable. A set $S$ is $ε$-far $(0<ε\leq1)$ from being $(k,G)$-clusterable if at least $εn$ points need to be removed from $S$ to make it $(k,G)$-clusterable. We solve this problem for $k=1$ and when $G$ is a symmetric convex object. For $k>1$, we solve a weaker version of this problem. Finally, as an application of our testing result, in clustering with outliers, we show that one can find the approximate clusters by querying a constant size sample, with high probability.

cs.CG↗