M. Sohel Rahman

Solving the Multidimensional Multiple-choice Knapsack Problem by constructing convex hulls

This paper presents a heuristic to solve the Multidimensional Multiple-choice Knapsack Problem (MMKP), a variant of the classical 0-1 Knapsack Problem. We apply a transformation technique to map the multidimensional resource consumption to single dimension. Convex hulls are constructed to reduce the search space to find the near-optimal solution of the MMKP. We present the computational complexity of solving the MMKP using this approach. A comparative analysis of different heuristics for solving the MMKP has been presented based on the experimental results.

Finding patterns in given intervals

In this paper, we study the pattern matching problem in given intervals. Depending on whether the intervals are given a priori for pre-processing, or during the query along with the pattern or, even in both cases, we develop solutions for different variants of this problem. In particular, we present efficient indexing schemes for each of the above variants of the problem.

Improved algorithms for the range next value problem and applications

The Range Next Value problem (problem RNV) is a recent interesting variant of the range search problems, where the query is for the immediate next (or equal) value of a given number within a given interval of an array. Problem RNV was introduced and studied very recently by Crochemore et al. [Maxime Crochemore, Costas S. Iliopoulos, M. Sohel Rahman, Finding patterns in given intervals, in: Antonin Kucera, Ludek Kucera (Eds.), MFCS, 22 in: Lecture Notes in Computer Science, vol. 4708, Springer, 2007, pp. 645-656]. In this paper, we present improved algorithms for problem RNV and algorithms for extended versions of the RNV problem. We also show how this problem can be used to achieve optimal query time for a number of interesting variants of the classic pattern matching problems.

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.

Finding patterns with variable length gaps or don’t cares

In this paper we have presented new algorithms to handle the pattern matching problem where the pattern can contain variable length gaps. Given a pattern P with variable length gaps and a text T our algorithm works in O(n + m + α log(max

Indexing permutations for binary strings

_{\rm 1<={\it i}<={\it l}}

On Hamiltonian cycles and Hamiltonian paths

(bi–ai))) time where n is the length of the text, m is the summation of the lengths of the component subpatterns, α is the total number of occurrences of the component subpatterns in the text and ai and bi are, respectively, the minimum and maximum number of don’t cares allowed between the ith and (i+1)st component of the pattern. We also present another algorithm which, given a suffix array of the text, can report whether P occurs in T in O(m + α loglogn) time. Both the algorithms record information to report all the occurrences of P in T. Furthermore, the techniques used in our algorithms are shown to be useful in many other contexts.

New efficient algorithms for the LCS and constrained LCS problems

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.

A New Efficient Algorithm for Computing the Longest Common Subsequence

A Hamiltonian cycle is a spanning cycle in a graph, i.e., a cycle through every vertex, and a Hamiltonian path is a spanning path. In this paper we present two theorems stating sufficient conditions for a graph to possess Hamiltonian cycles and Hamiltonian paths. The significance of the theorems is discussed, and it is shown that the famous Ores theorem directly follows from our result.

Algorithms for computing variants of the longest common subsequence problem

In this paper, we study the classic and well-studied longest common subsequence (LCS) problem and a recent variant of it, namely the constrained LCS (CLCS) problem. In the CLCS problem, the computed LCS must also be a supersequence of a third given string. In this paper, we first present an efficient algorithm for the traditional LCS problem that runs in O(Rloglogn+n) time, where R is the total number of ordered pairs of positions at which the two strings match and n is the length of the two given strings. Then, using this algorithm, we devise an algorithm for the CLCS problem having time complexity O(pRloglogn+n) in the worst case, where p is the length of the third string.