Arrow Research search

Author name cluster

Rajeev Raman

Possible papers associated with this exact author name in Arrow. This page groups case-insensitive exact name matches and is not a full identity disambiguation profile.

16 papers
2 author rows

Possible papers

16

TCS Journal 2020 Journal Article

Generating a Gray code for prefix normal words in amortized polylogarithmic time per word

  • Péter Burcsi
  • Gabriele Fici
  • Zsuzsanna Lipták
  • Rajeev Raman
  • Joe Sawada

A prefix normal word is a binary word with the property that no substring has more 1s than the prefix of the same length. By proving that the set of prefix normal words is a bubble language, we can exhaustively list all prefix normal words of length n as a combinatorial Gray code, where successive strings differ by at most two swaps or bit flips. This Gray code can be generated in O ( log 2 ⁡ n ) amortized time per word, while the best generation algorithm hitherto has O ( n ) running time per word. We also present a membership tester for prefix normal words, as well as a novel characterization of bubble languages.

TCS Journal 2018 Journal Article

Encoding nearest larger values

  • Michael Hoffmann
  • John Iacono
  • Patrick K. Nicholson
  • Rajeev Raman

In nearest larger value (NLV) problems, we are given an array A [ 1. . n ] of distinct numbers, and need to preprocess A to answer queries of the following form: given any index i ∈ [ 1, n ], return a “nearest” index j such that A [ j ] > A [ i ]. We consider the variant where the values in A are distinct, and we wish to return an index j such that A [ j ] > A [ i ] and | j − i | is minimized, the nondirectional NLV (NNLV) problem. We consider NNLV in the encoding model, where the array A is deleted after preprocessing. The NNLV encoding problem turns out to have an unexpectedly rich structure: the effective entropy (optimal space usage) of the problem depends crucially on details in the definition of the problem. Of particular interest is the tiebreaking rule: if there exist two nearest indices j 1, j 2 such that A [ j 1 ] > A [ i ] and A [ j 2 ] > A [ i ] and | j 1 − i | = | j 2 − i |, then which index should be returned? For the tiebreaking rule where the rightmost (i. e. , largest) index is returned, we encode a path-compressed representation of the Cartesian tree that can answer all NNLV queries in 1. 89997 n + o ( n ) bits, and can answer queries in O ( 1 ) time. An alternative approach, based on forbidden patterns, achieves a very similar space bound for two tiebreaking rules (including the one where ties are broken to the right), and (for a more flexible tiebreaking rule) achieves 1. 81211 n + o ( n ) bits. Finally, we develop a fast method of counting distinguishable configurations for NNLV queries. Using this method, we prove a lower bound of 1. 62309 n − Θ ( 1 ) bits of space for NNLV encodings for the tiebreaking rule where the rightmost index is returned.

TCS Journal 2016 Journal Article

Encoding 2D range maximum queries

  • Mordecai Golin
  • John Iacono
  • Danny Krizanc
  • Rajeev Raman
  • Srinivasa Rao Satti
  • Sunil Shende

We consider the two-dimensional range maximum query (2D-RMQ) problem: given an array containing elements from an ordered set, encode the array so that the position of the maximum element in any specified range of rows and range of columns can be found efficiently. We focus on determining the effective entropy of 2D-RMQ, i. e. , how many bits are needed to encode an array so that 2D-RMQ queries can be answered without accessing the array. We give tight upper and lower bounds on the expected effective entropy for the case when A contains independent identically-distributed random values, and give new upper and lower bounds for the case when the array contains few rows. The latter results improve upon the upper and lower bounds by Brodal et al. [4]. We also give some efficient data structures for 2D-RMQ whose space usage is close to the effective entropy.

TCS Journal 2016 Journal Article

Two dimensional range minimum queries and Fibonacci lattices

  • Gerth Stølting Brodal
  • Pooya Davoodi
  • Moshe Lewenstein
  • Rajeev Raman
  • Srinivasa Rao Satti

Given a matrix of size N, two dimensional range minimum queries (2D-RMQs) ask for the position of the minimum element in a rectangular range within the matrix. We study trade-offs between the query time and the additional space used by indexing data structures that support 2D-RMQs. Using a novel technique—the discrepancy properties of Fibonacci lattices—we give an indexing data structure for 2D-RMQs that uses O ( N / c ) bits additional space with O ( c log ⁡ c ( log ⁡ log ⁡ c ) 2 ) query time, for any parameter c, 4 ≤ c ≤ N. Also, when the entries of the input matrix are from { 0, 1 }, we show that the query time can be improved to O ( c log ⁡ c ) with the same space usage.

TCS Journal 2012 Journal Article

Succinct representations of permutations and functions

  • J. Ian Munro
  • Rajeev Raman
  • Venkatesh Raman
  • Srinivasa Rao S.

We investigate the problem of succinctly representing an arbitrary permutation, π, on { 0, …, n − 1 } so that π k ( i ) can be computed quickly for any i and any (positive or negative) integer power k. A representation taking ( 1 + ϵ ) n lg n + O ( 1 ) bits suffices to compute arbitrary powers in constant time, for any positive constant ϵ ≤ 1. A representation taking the optimal ⌈ lg n! ⌉ + o ( n ) bits can be used to compute arbitrary powers in O ( lg n / lg lg n ) time. We then consider the more general problem of succinctly representing an arbitrary function, f: [ n ] → [ n ] so that f k ( i ) can be computed quickly for any i and any integer power k. We give a representation that takes ( 1 + ϵ ) n lg n + O ( 1 ) bits, for any positive constant ϵ ≤ 1, and computes arbitrary positive powers in constant time. It can also be used to compute f k ( i ), for any negative integer k, in optimal O ( 1 + ∣ f k ( i ) ∣ ) time. We place emphasis on the redundancy, or the space beyond the information-theoretic lower bound that the data structure uses in order to support operations efficiently. A number of lower bounds have recently been shown on the redundancy of data structures. These lower bounds confirm the space–time optimality of some of our solutions. Furthermore, the redundancy of one of our structures “surpasses” a recent lower bound by Golynski [Golynski, SODA 2009], thus demonstrating the limitations of this lower bound.

TCS Journal 2006 Journal Article

A simple optimal representation for balanced parentheses

  • Richard F. Geary
  • Naila Rahman
  • Rajeev Raman
  • Venkatesh Raman

We consider succinct, or highly space-efficient, representations of a (static) string consisting of n pairs of balanced parentheses, which support natural operations such as finding the matching parenthesis for a given parenthesis, or finding the pair of parentheses that most tightly enclose a given pair. This problem was considered by Jacobson [Space-efficient static trees and graphs, in: Proc. of the 30th FOCS, 1989, pp. 549–554] and Munro and Raman [Succinct representation of balanced parentheses and static trees, SIAM J. Comput. 31 (2001) 762–776] who gave O ( n ) -bit and 2 n + o ( n ) -bit representations, respectively, that supported the above operations in O ( 1 ) time on the RAM model of computation. This data structure is a fundamental tool in succinct representations, and has applications in representing suffix trees, ordinal trees, planar graphs and permutations. We consider the practical performance of parenthesis representations. First, we give a new 2 n + o ( n ) -bit representation that supports all the above operations in O ( 1 ) time. This representation is conceptually simpler, its space bound has a smaller o ( n ) term and it also has a simple and uniform o ( n ) time and space construction algorithm. We implement our data structure and a variant of Jacobson's, and evaluate their practical performance (speed and memory usage), when used in a succinct representation of trees derived from XML documents. As a baseline, we compare our representations against a widely used implementation of the standard DOM (document object model) representation of XML documents. Both succinct representations use orders of magnitude less space than DOM and tree traversal operations are usually only slightly slower than in DOM.

MFCS Conference 1993 Conference Paper

Approximate and Exact Deterministic Parallel Selection

  • Shiva Chaudhuri
  • Torben Hagerup
  • Rajeev Raman

Abstract The selection problem of size n is, given a set of n elements drawn from an ordered universe and an integer r with 1< r ≤ n, to identify the r th smallest element in the set. We study approximate and exact selection on deterministic concurrent-read concurrent-write parallel RAMs, where approximate selection with relative accuracy λ>0 asks for any element whose true rank differs from r by at most An. Our main results are: (1) For all t ≥(log log n ) 4, approximate selection problems of size n can be solved in O(t) time with optimal speedup with relative accuracy \(2^{{{ - t} \mathord{\left/{\vphantom {{ - t} {\left( {\log \log n} \right)}}} \right. \kern-\nulldelimiterspace} {\left( {\log \log n} \right)}}^4 }\); no deterministic PRAM algorithm for approximate selection with a running time below Ο (log n /log log n ) was previously known. (2) Exact selection problems of size n can be solved in O (log n /log log n ) time with O(n log log n /log n ) processors. This running time is the best possible (using only a polynomial number of processors), and the number of processors is optimal for the given running time (optimal speedup); the best previous algorithm achieves optimal speedup with a running time of O (log n log * n /log log n ).

FOCS Conference 1992 Conference Paper

Waste Makes Haste: Tight Bounds for Loose Parallel Sorting

  • Torben Hagerup
  • Rajeev Raman

Conventional parallel sorting requires the n input keys to be output in an array of size n, and is known to take Omega (log n/log log n) time using any polynomial number of processors. The lower bound does not apply to the more 'wasteful' convention of padded sorting, which requires the keys to be output in sorted order in an array of size (1+o(1))n. The authors give very fast randomised CRCW PRAM algorithms for several padded-sorting problems. Applying only pairwise comparisons to the input and using kn processors, where 2 >

v2026.09.13