Elisabetta Grazzini

Exhaustive generation of combinatorial objects by ECO

Abstract.The problem of exhaustively generating combinatorial objects can currently be applied to many disciplines, such as biology, chemistry, medicine and computer science. A well known approach to the exhaustive generation problem is given by the Gray code scheme for listing n-bit binary numbers in such a way that successive numbers differ in exactly one bit position. In this work, we introduce an exhaustive generation algorithm, which is general for the classes of succession rules considered in [1]. We also show that our algorithm is efficient in an amortized sense; it actually uses only a constant amount of computation per object.

A general exhaustive generation algorithm for Gray structures

Starting from a succession rule for Catalan numbers, we define a procedure for encoding and listing the objects enumerated by these numbers such that two consecutive codes of the list differ only by one digit. The Gray code we obtain can be generalized to all the succession rules with the stability property: each label (k) has in its productions two labels c1 and c2, always in the same position, regardless of k. Because of this link, we define Gray structures as the sets of those combinatorial objects whose construction can be encoded by a succession rule with the stability property. This property is a characteristic that can be found among various succession rules, such as the finite, factorial or transcendental ones. We also indicate an algorithm which is a very slight modification of Walsh’s one, working in O(1) worst-case time per word for generating Gray codes.

Avoiding cross-bifix-free binary words

In this paper we study the construction and the enumeration of binary words in

A strategy for executing complex queries

\{0,1\}^*

Some bijective results about the ares of Schröder paths

having more 1’s than 0’s and avoiding a set of cross-bifix-free patterns. We give a particular succession rule, called jumping and marked succession rule, which describes the growth of such words according to their number of ones. Moreover, the problem of associating a word to a path in the generating tree obtained by the succession rule is solved by introducing an algorithm which constructs all binary words having more 1’s than 0’s and then kills those containing the forbidden patterns. Finally, we give the generating function of such words according to the number of ones.

Shared VS separate inverted files

In this paper, two different structures for inverted files are analyzed and compared, when the relational join operation is taken into account. The structures are called shared and separate inverted files. The results are given of some experiments which show that the shared inverted organization is always advantageous when the inverted files are not sorted and is almost always advantageous when the files are sorted.

An exhaustive generation algorithm for Catalan objects and others

In this paper we define a strategy for processing a given class of relational queries. The strategy is based on: (i) the presence of inverted files; (ii) the representation of temporary relations, obtained during the execution of a query, as sets of pointers to tuples; (iii) the execution of the relational operators involved in the query by means of operations, namely intersections, unions and Cartesian products, on these sets of pointers. In this way actual tuples are kept in the main memory only when the resulting relation is produced. A storage structure for the access keys in indices, too, is used; it allows us to maintain a join index, i.e. an index which permits to compute a join without operating on tuples coming from the two operand relations in it. The join index we propose can be used also when computing selections; we will show how it permits to perform operations on sets of pointers efficiently.

Counting Binary Words Avoiding Alternating Patterns

The query processing subsystem of a relational Data Base Management System (DBMS) is often called the query optimizer. The degree of sophistication of a query optimizer design critically affects the performance of the DBMS. This is true even if the query optimizer is probably the most difficult subsystem to implement because each of the high-level database operations that the relational model of data allows may be implemented in more than one way; the choice of optimal algorithms depends on the characteristics of both the stored data and of the query itself.