Tanaeem M. Moosa

Sub-quadratic time and linear space data structures for permutation matching in binary strings

Given a pattern P of length n and a text T of length m, the permutation matching problem asks whether any permutation of P occurs in T. Indexing a string for permutation matching seems to be quite hard in spite of the existence of a simple non-indexed solution. In this paper, we devise several o(n^2) time data structures for a binary string capable of answering permutation queries in O(m) time. In particular, we first present two O(n^2/logn) time data structures and then improve the data structure construction time to O(n^2/log^2n). The space complexity of the data structures remains linear.

Indexing permutations for binary strings

Given a pattern P of length m and a text T of length n, the permutation matching problem asks whether any permutation of P occurs in T. Indexing a string for permutation matching seems to be quite hard in spite of the existence of a simple non-indexed solution. It is an open question whether there exists an index data structure for this problem with o(n^2) time and space complexity even for a binary alphabet. In this paper, we settle this question by reducing the problem to the (min,+) convolution problem and thereby achieving an O(n^2/logn) time data structure for a binary string capable of answering permutation queries in O(m) time. The space requirement of the data structure is also improved to be linear.

Finite automata based algorithms for the generalized constrained longest common subsequence problems

The Longest Common Subsequence (LCS) problem is a classic and well-studied problem in computer science. Given strings S1, S2 and P, the generalized constrained longest common subsequence problem (GC-LCS) for S1 and S2 with respect to P is to find a longest common subsequence of S1 and S2, which contains (excludes) P as a subsequence (substring). We present finite automata based algorithms with time complexity O(r(n+m)+(n+m) log(n+m)) for a fixed sized alphabet, where r, n and m are the lengths of P, S1 and S2 respectively.

Improved algorithms for the point-set embeddability problem for plane 3-trees

In the point set embeddability problem, we are given a plane graph G with n vertices and a point set S with n points. Now the goal is to answer the question whether there exists a straight-line drawing of G such that each vertex is represented as a distinct point of S as well as to provide an embedding if one does exist. Recently, in [15], a complete characterization for this problem on a special class of graphs known as the plane 3-trees was presented along with an efficient algorithm to solve the problem. In this paper, we use the same characterization to devise an improved algorithm for the same problem. Much of the efficiency we achieve comes from clever uses of the triangular range search technique.

Cache Oblivious Algorithms for the RMQ and the RMSQ Problems

In the Range Minimum/Maximum Query (RMQ) and Range Maximum-Sum Segment Query (RMSQ) problems, we are given an array which we can preprocess in order to answer subsequent queries. In the RMQ query, we are given a range on the array and we need to find the maximum/minimum element within that range. On the other hand, in RMSQ query, we need to return the segment within the given query range that gives the maximum sum. In this paper, we present cache oblivious optimal algorithms for both of the above problems. In particular, for both the problems, we have presented linear time data structures having optimal cache miss. The data structures can answer the corresponding queries in constant time with constant cache miss.

Linear time inference of strings from cover arrays using a binary alphabet

Covers being one of the most popular form of regularities in strings, have drawn much attention over time. In this paper, we focus on the problem of linear time inference of strings from cover arrays using the least sized alphabet possible. We present an algorithm that can reconstruct a string x over a two-letter alphabet whenever a valid cover array C is given as an input. This algorithm uses several interesting combinatorial properties of cover arrays and an interesting relation between border array and cover array to achieve this. Our algorithm runs in linear time.

INFERRING STRINGS FROM COVER ARRAYS

Covers, being one of the most popular form of regularities in strings, have drawn much attention in the relevant literature. In this paper, we focus on the problem of linear-time inference of strings from cover arrays using the least sized alphabet. We present an algorithm that can reconstruct a string x over a binary alphabet whenever a valid cover array C is given as an input. We have devised our algorithm using several interesting combinatorial properties of cover arrays as well as an interesting relation between border array and cover array. Our algorithm runs in linear-time. The fact that, from any valid cover array, we can infer a binary string x, is, in itself, a fascinating result in stringology, and this work may be considered as the final step for this particular problem area.

Pattern Matching in Indeterminate and Arc-Annotated Sequences

In this paper, we present efficient algorithms for finding indeterminate Arc-Annotated patterns in indeterminate Arc-Annotated references. Our algorithms run in O(m+ (nm) w) time where n and m are respectively the length of our reference and pattern strings and w is the target machine word size. Here we have assumed the alphabet size to be constant, because, indeterminate Arc-Annotated sequences are used to model biological sequences. Clearly, for short patterns, our algorithms run in linear time and efficient algorithms for matching short patterns to reference genomes have huge applications in practical settings. We have also applied our algorithms to scan the ncRNAs without pseudoknots. We scanned three whole human chromosomes and it took only 2.5 - 4 minutes to scan one whole chromosome for an ncRNA family. Some relevant patents are discussed in.

Two dimensional Range Minimum/Maximum Query revisited

In this paper, we present a cache oblivious efficient data structure to solve the two dimensional variant of the Range Minimum/Maximum Query (RMQ) problem.