Searcharxiv⌕ Search

arXiv subjects

Sanjeev Saxena

Publications and source records attributed to Sanjeev Saxena.

At least 19 recordsLinked to original sources
arXiv2026

Some variations of the secretary problem

We consider two variations of the classical secretary problem. * A variation of the returning secretary problem where each interviewee may appear a second time with a fixed probability p. The decision-maker observes interviewees sequentially and must choose whether to accept or reject each appearance. We characterize the optimal threshold rule and examine its dependence on the reappearance probability p, highlighting how additional information from repeated appearances improves selection performance. * A variation of the secretary problem in which success is defined as selecting any one of the top three interviewees rather than the single best. Interviewees are observed sequentially in random order, and decisions are irreversible. We estimated the success probability under this relaxed success criterion using the threshold strategy of the classical secretary problem. The results show that allowing selection among the top three significantly increases the success probability and shifts the optimal stopping threshold earlier than in the classical problem. This model provides insight into realistic decision-making scenarios where top interviewees are more or less similar.

cs.DS↗
arXiv2025

Duality between Lines and Points

There are several notions of duality between lines and points. In this note, it is shown that all these can be studied in a unified way. Most interesting properties are independent of specific choices. It is also shown that either dual mapping can be its own inverse or it can preserve relative order (but not both). Generalisation to higher dimensions is also discussed. An elementary and very intuitive treatment of relationship between arrangements in $d+1$ dimensions and searching for $k$-nearest neighbour in $d$-dimensions is also given.

cs.CG↗
arXiv2024

Top-k Stabbing Interval Queries

We investigate a weighted variant of the interval stabbing problem, where the goal is to design an efficient data structure for a given set $\mathcal{I}$ of weighted intervals such that, for a query point $q$ and an integer $k>0$, we can report the $k$ intervals with largest weights among those stabbed by $q$. In this paper, we present a linear space solution with $O(\log n + k)$ query time. Moreover, we also present another trade-off for the problem.

cs.DS↗
arXiv2024

Simpler O(1) Query Algorithm for Level Ancestors

This note describes a very simple O(1) query time algorithm for finding level ancestors. This is basically a serial (re)-implementation of the parallel algorithm of Berkman and Vishkin (O.Berkman and U.Vishkin, Finding level-ancestors in trees, JCSS, 48, 214--230, 1994). Although the basic algorithm has preprocessing time of O(n log n), by having additional levels or using table lookup, the preprocessing time can be reduced to almost linear or linear. The table lookup algorithm can be built in O(1) parallel time with $n$ processors and can also be used to simplify the parallel algorithm of Berkman and Vishkin and make it optimal.

cs.DS↗
arXiv2024

Maximizing Weighted Dominance in the Plane

Let P be a set of n weighted points, Q be a set of m unweighted points in the plane, and k a non-negative integer. We consider the problem of computing a subset $Q'\subseteq Q$ with size at most k such that the sum of the weights of the points of P dominated by at least one point in the set Q' is maximized. A point q in the plane dominates another point p if and only if $x(q)\ge x(p)$ and $y(q)\ge y(p)$, and at least one inequality is strict. We present a solution to the problem that takes O(n + m)-space and $O(k \min\{n+m, \frac{n}{k}+m^2\}\log m)$-time. We (conditionally) improve upon the existing result (the bounds of our solution are interesting when $m= o(\sqrt{n}))$. Moreover, we also present a simple algorithm solving the problem in $O(km^2+n\log m)$-time and $O(n+m)$-space. The bounds of the algorithm are interesting when $m= o(\sqrt{n})$.

cs.DS↗
arXiv2023

Storage in Computational Geometry

We show that $n$ real numbers can be stored in a constant number of real numbers such that each original real number can be fetched in $O(\log n)$ time. Although our result has implications for many computational geometry problems, we show here, combined with Han's $O(n\sqrt{\log n})$ time real number sorting algorithm [3, arXiv:1801.00776], we can improve the complexity of Kirkpatrick's point location algorithm [8] to $O(n\sqrt{\log n})$ preprocessing time, a constant number of real numbers for storage and $O(\log n)$ point location time. Kirkpatrick's algorithm uses $O(n\log n)$ preprocessing time, $O(n)$ storage and $O(\log n)$ point location time. The complexity results in Kirkpatrick's algorithm was the previous best result. Although Lipton and Tarjan's algorithm [10] predates Kirkpatrick's algorithm and has the same complexity, Kirkpatrick's algorithm is simpler and has a better structure. This paper can be viewed as a companion paper of paper [3, arXiv:1801.00776].

cs.CG↗
arXiv2022

Dominance for Containment Problems

In a containment problem, the goal is to preprocess a set of geometric objects so that, given a geometric query object, we can report all the objects containing the query object. We consider the containment problem where input objects are homothetic triangles and the query objects considered are line segments, circles, and trapezoids with bases parallel to either axis. We show that this problem can be solved using the 3-d query dominance problem. The solutions presented can also be extended for higher dimensions.

cs.DS↗
arXiv2022

On Brooks' Theorem

In this note we give two proofs of Brooks' Theorem. The first is obtained by modifying an earlier proof and the second by combining two earlier proofs. We believe these proofs are easier to teach in Computer Science courses.

cs.DM↗
arXiv2021

Point Enclosure Problem for Homothetic Polygons

In this paper, we investigate the homothetic point enclosure problem: given a set $S$ of $n$ triangles with sides parallel to three fixed directions, find a data structure for $S$ that can report all the triangles of $S$ that contain a query point efficiently. The problem is "inverse" of the homothetic range search problem. We present an $O(n\log n)$ space solution that supports the queries in $O(\log n + k)$ time, where $k$ is the output size. The preprocessing time is $O(n\log n)$. The same results also hold for homothetic polygons.

cs.CG↗
arXiv2021

Sorted Range Reporting and Range Minima Queries

Given an array A[1: n] of n elements drawn from an ordered set, the sorted range selection problem is to build a data structure that can be used to answer the following type of queries efficiently: Given a pair of indices i, j $ (1\le i\le j \le n)$, and a positive integer k, report the k smallest elements from the sub-array A[i: j] in order. Brodal et al. (Brodal, G.S., Fagerberg, R., Greve, M., and L{\'o}pez-Ortiz, A., Online sorted range reporting. Algorithms and Computation (2009) pp. 173--182) introduced the problem and gave an optimal solution. After O(n log n) time for preprocessing, the query time is O(k). The space used is O(n). In this paper, we propose the only other possible optimal trade-off for the problem. We present a linear space solution to the problem that takes O(k log k) time to answer a range selection query. The preprocessing time is O(n). Moreover, the proposed algorithm reports the output elements one by one in non-decreasing order. Our solution is simple and practical. We also describe an extremely simple method for range minima queries (most of whose parts are known) which takes al most (but not exactly) linear time. We believe that this method may be, in practice, faster and easier to implement in most cases.

cs.DS↗
arXiv2020

On seat allocation problem with multiple merit lists

In this note, we present a simpler algorithm for joint seat allocation problem in case there are two or more merit lists. In case of two lists (the current situation for Engineering seats in India), the running time of the algorithm is proportional to sum of running time for two separate (delinked) allocations. The algorithm is straight forward and natural and is not (at least directly) based on deferred acceptance algorithm of Gale and Shapley. Each person can only move higher in his or her preference list. Thus, all steps of the algorithm can be made public. This will improve transparency and trust in the system.

cs.DS↗
arXiv2020

Zone Theorem for Arrangements in three dimensions

In this note, a simple description of zone theorem in three dimensions is given.Arrangements in three dimensions are useful for constructing higher-order Voronoi diagrams in plane. An elementary and very intuitive treatment of this result is also given.

cs.CG↗
arXiv2020

Edge colouring Game on Trees with maximum degree $Δ=4$

Consider the following game. We are given a tree $T$ and two players (say) Alice and Bob who alternately colour an edge of a tree (using one of $k$ colours). If all edges of the tree get coloured, then Alice wins else Bob wins. Game chromatic index of trees of is the smallest index $k$ for which there is a winning strategy for Alice. If the maximum degree of a node in tree is $Δ$, Erdos et.al.[6], show that the game chromatic index is at least $Δ+1$. The bound is known to be tight for all values of $Δ\neq 4$. In this paper we show that for $Δ=4$, even if Bob is allowed to skip a move, Alice can always choose an edge to colour and win the game for $k=Δ+1$. Thus the game chromatic index of trees of maximum degree $4$ is also $5$. Hence, game chromatic index of trees of maximum degree $Δ$ is $Δ+1$ for all $Δ\geq 2$. Moreover,the tree can be preprocessed to allow Alice to pick the next edge to colour in $O(1)$ time. A result of independent interest is a linear time algorithm for on-line edge-deletion problem on trees.

cs.DS↗
arXiv2017

Ellipsoid Method for Linear Programming made simple

In this paper, ellipsoid method for linear programming is derived using only minimal knowledge of algebra and matrices. Unfortunately, most authors first describe the algorithm, then later prove its correctness, which requires a good knowledge of linear algebra.

cs.DS↗
arXiv2016

A Still Simpler Way of Introducing the Interior-Point Method for Linear Programming

Linear programming is now included in algorithm undergraduate and postgraduate courses for computer science majors. We give a self-contained treatment of an interior-point method which is particularly tailored to the typical mathematical background of CS students. In particular, only limited knowledge of linear algebra and calculus is assumed.

cs.DS↗
arXiv2015

Maximal Independent Sets in Generalised Caterpillar Graphs

A caterpillar graph is a tree which on removal of all its pendant vertices leaves a chordless path. The chordless path is called the backbone of the graph. The edges from the backbone to the pendant vertices are called the hairs of the caterpillar graph. Ortiz and Villanueva (C.Ortiz and M.Villanueva, Discrete Applied Mathematics, 160(3): 259-266, 2012) describe an algorithm, linear in the size of the output, for finding a family of maximal independent sets in a caterpillar graph. In this paper, we propose an algorithm, again linear in the output size, for a generalised caterpillar graph, where at each vertex of the backbone, there can be any number of hairs of length one and at most one hair of length two.

cs.DS↗