Concettina Guerra

The longest common subsequence problem revisited

This paper re-examines, in a unified framework, two classic approaches to the problem of finding a longest common subsequence (LCS) of two strings, and proposes faster implementations for both. Letl be the length of an LCS between two strings of lengthm andn ≥m, respectively, and let s be the alphabet size. The first revised strategy follows the paradigm of a previousO(ln) time algorithm by Hirschberg. The new version can be implemented in timeO(lm · min logs, logm, log(2n/m)), which is profitable when the input strings differ considerably in size (a looser bound for both versions isO(mn)). The second strategy improves on the Hunt-Szymanski algorithm. This latter takes timeO((r +n) logn), wherer≤mn is the total number of matches between the two input strings. Such a performance is quite good (O(n logn)) whenr∼n, but it degrades to Θ(mn logn) in the worst case. On the other hand the variation presented here is never worse than linear-time in the productmn. The exact time bound derived for this second algorithm isO(m logn +d log(2mn/d)), whered ≤r is the number ofdominant matches (elsewhere referred to asminimal candidates) between the two strings. Both algorithms require anO(n logs) preprocessing that is nearly standard for the LCS problem, and they make use of simple and handy auxiliary data structures.

Parallel algorithms for line detection on a mesh

ShuffleNet and de Bruijn networks have been proposed as multihop lightwave networks based on wavelength division multiplexing (WDM). With multihop lightwave networks, few fixed wavelength transmitters/receivers are assigned to each user, eliminating the need for wavelength agility and pretransmission coordination. These networks have been shown to be very effective for uniform traffic. For communications with high locality, we propose two-level hierarchical networks. At the first level, each cluster of users can be connected either via a ShuffleNet (SH) or a de Bruijn network (dB). At the second level, all the clusters in the system can be connected by two rings in opposite directions (SH/Ring and dB/Ring), a de Bruijn network (dB/dB), or a ShuffleNet (SH/SH). The performance of ShuffleNet, de Bruijn networks, and the hierarchical networks SH/Ring, dB/Ring, dB/dB, and SH/SH is analyzed. For communications with a high locality, the hierarchical networks are shown to be very effective.

Fast linear-space computations of longest common subsequences

Space saving techniques in computations of a longest common subsequence (LCS) of two strings are crucial in many applications, notably, in molecular sequence comparisons. For about ten years, however, the only linear-space LCS algorithm known required time quadratic in the length of the input, for all inputs. This paper reviews linear-space LCS computations in connection with two classical paradigms originally designed to take less than quadratic time in favorable circumstances. The objective is to achieve the space reduction without alteration of the asymptotic time complexity of the original algorithm. The first one of the resulting constructions takes time O(n(m−l)), and is thus suitable for cases where the LCS is expected to be close to the shortest input string. The second takes time O(ml log(min[s, m, 2nl])) and suits cases where one of the inputs is much shorter than the other. Here m and n (m⩽n) are the lengths of the two input strings, l is the length of the longest common subsequences and s is the size of the alphabet. Along the way, a very simple O(m(m−l)) time algorithm is also derived for the case of strings of equal length.

2-D object recognition by multiscale tree matching

Abstract In this paper we present an efficient 2D object recognition method that uses multiscale tree representations. A planar object is represented by means of a tree, in which each node corresponds to a boundary segment at some level of resolution and an arc connects nodes corresponding to segments at successive levels that are spatially related. The problem of matching an object against a model is formulated as the one of determining the best mapping between nodes at all levels of the two associated trees. The proposed matching algorithm is based on dynamic programming and has optimal O(∣T ∣∣T′∣) time complexity, where ∣ T ∣ and ∣ T ′∣ are the number of nodes in the two trees.

Line-based object recognition using Hausdorff distance: from range images to molecular secondary structures

Object recognition algorithms are fundamental tools in automatic matching of geometric shapes within a background scene. Many approaches have been proposed in the past to solve the object recognition problem. Two of the key aspects that distinguish them in terms of their practical usability are: (i) the type of input model description and (ii) the comparison criteria used. In this paper we introduce a novel scheme for 3D object recognition based on line segment representation of the input shapes and comparison using the Hausdorff distance. This choice of model representation provides the flexibility to apply the scheme in different application areas. We define several variants of the Hausdorff distance to compare the models within the framework of well-defined metric spaces. We present a matching algorithm that efficiently finds a pattern in a 3D scene. The algorithm approximates a minimization procedure of the Hausdorff distance. The output error due to the approximation is guaranteed to be within a known constant bound. Practical results are presented for two classes of objects: (i) polyhedral shapes extracted from segmented range images and (ii) secondary structures of large molecules. In both cases the use of our approximate algorithm allows to match correctly the pattern in the background while achieving the efficiency necessary for practical use of the scheme. In particular the performance is improved substantially with minor degradation of the quality of the matching.

Computing the Hough transform on a pyramid architecture

An algorithm to implement the Hough transform for the detection of a straight line on a pyramidal architecture is presented. The algorithm consists of two phases. The first phase, called block-projection, takes constant time. The second phase, called block-combination, is repeated logn times and takes a total ofO(n1/2) time for the detection of all straight lines having a given slope on an n×n image; if there arep different slopes to be detected, then the total time becomesO(pn1/2).

Matching sets of 3D segments

The problem of matching 3D objects has been studied extensively in computer vision. Here we consider the case of polyhedral objects extracted from range images and presented in terms of 3D lines. Given two sets of line segments A and B the problem is to find a rigid body transformation T that minimizes a given dissimilarity measure between T(A) and B. We discuss two practical approximate solutions to the segment matching problem in 3D that can be used to recognize planar- faced objects from range data. The first method is based on indexing and the second is a minimization of the Hausdorff distance. We show the advantage of an integrated use of the two strategies improving the overall performance without degradation in the quality of the results.

2D object recognition on a reconfigurable mesh

Abstract This paper presents an approach to recognizing two-dimensional multiscale objects on a reconfigurable mesh architecture with horizontal and vertical broadcasting. The object models are described in terms of a convex/concave multiscale boundary decomposition that is represented by a tree structure. The problem of matching an observed object against a model is formulated as a tree matching problem. A parallel dynamic programming solution to this problem is presented that requires O (max( n , m )) time on n × m reconfigurable mesh, where n and m are the sizes of the two trees.

A Unifying Framework for Systolic Designs

A systematic methodology to synthesize systolic designs is described and used to derive a new design for dynamic programming. This latter design uses fewer processing elements than previously considered ones. The synthesis method consists of two parts: 1) deriving from the high-level problem specification a form more suitable to VLSI implementation; 2) mapping the new specification into physical hardware. The method also provides a unifying framework for existing systolic algorithms.

A parallel algorithm for the visibility problem from a point

Abstract The problem of the visibility from a point is defined as follows: given a set S of n nonintersecting line segments and a point x, determine the region of the plane that is visible from x. A simpler instance of this problem is the visibility from a point inside a simple polygon. In this paper we present an optimal parallel algorithm for determining the visibility from a point. The algorithm is based on a divide-and-conquer strategy and has time complexity O (log n) on a PRAM with O (n) processors.