Number Of Trees Research Articles

Enumeration of Binary Trees and Universal Types

Binary unlabeled ordered trees (further called binary trees) were studied at least since Euler, who enumerated them. The number of such trees with n nodes is now known as the Catalan number. Over the years various interesting questions about the statistics of such trees were investigated (e.g., height and path length distributions for a randomly selected tree). Binary trees find an abundance of applications in computer science. However, recently Seroussi posed a new and interesting problem motivated by information theory considerations: how many binary trees of a \emphgiven path length (sum of depths) are there? This question arose in the study of \emphuniversal types of sequences. Two sequences of length p have the same universal type if they generate the same set of phrases in the incremental parsing of the Lempel-Ziv'78 scheme since one proves that such sequences converge to the same empirical distribution. It turns out that the number of distinct types of sequences of length p corresponds to the number of binary (unlabeled and ordered) trees, T_p, of given path length p (and also the number of distinct Lempel-Ziv'78 parsings of length p sequences). We first show that the number of binary trees with given path length p is asymptotically equal to T_p ~ 2^2p/(log_2 p)(1+O(log ^-2/3 p)). Then we establish various limiting distributions for the number of nodes (number of phrases in the Lempel-Ziv'78 scheme) when a tree is selected randomly among all trees of given path length p. Throughout, we use methods of analytic algorithmics such as generating functions and complex asymptotics, as well as methods of applied mathematics such as the WKB method and matched asymptotics.

Finding hot query patterns over an XQuery stream

Caching query results is one efficient approach to improving the performance of XML management systems. This entails the discovery of frequent XML queries issued by users. In this paper, we model user queries as a stream of XML query pattern trees and mine the frequent query patterns over the query stream. To facilitate the one-pass mining process, we devise a novel data structure called DTS to summarize the pattern trees seen so far. By grouping the incoming pattern trees into batches, we can dynamically mark the active portion of the current batch in DTS and limit the enumeration of candidate trees to only the currently active pattern trees. We also design another summary data structure called ECTree that provides for the incremental computation of the frequent tree patterns over the query stream. Based on the above two constructs, we present two mining algorithms called XQSMinerI and XQSMinerII. XQSMinerI is fast, but it tends to overestimate, while XQSMinerII adopts a filter-and-refine approach to minimize the amount of overestimation. Experimental results show that the proposed methods are both efficient and scalable and require only small memory footprints.

A Scalable Vertical Model for Mining Association Rules

Association rule mining (ARM) is the data-mining process for finding all association rules in datasets matching user-defined measures of interest such as support and confidence. Usually, ARM proceeds by mining all frequent itemsets — a step known to be very computationally intensive — from which rules are then derived in a straight forward manner. In general, mining all frequent itemsets prunes the space by using the downward closure (or anti-monotonicity) property of support which states that no itemset can be frequent unless all of its subsets are frequent. A large number of papers have addressed the problem of ARM but not many of them have focused on scalability over very large datasets (i.e. when datasets contain a very large number of transactions). In this paper, we propose a new model for representing data and mining frequent itemsets that is based on the P-tree technology for compression and faster logical operations over vertically structured data and on set enumeration trees for fast itemset enumeration. Experimental results presented hereinafter show big improvements for our approach over large datasets when compared to other contemporary approaches in the literature.

Discrete facility location and routing of obnoxious activities

The problem of simultaneously locating obnoxious facilities and routing obnoxious materials between a set of built-up areas and the facilities is addressed. Obnoxious facilities are those facilities which cause exposure to people as well as to the environment i.e. dump sites, chemical industrial plants, electric power supplier networks, nuclear reactors and so on. A discrete combined location-routing model, which we refer to as Obnoxious Facility Location and Routing model ( OFLR), is defined. OFLR is a NP-hard problem for which a Lagrangean heuristic approach is presented. The Lagrangean relaxation proposed allows to decompose OFLR into a Location subproblem and a Routing subproblem; such subproblems are then strengthened by adding suitable inequalities. Based on this Lagrangean relaxation two simple Lagrangean heuristics are provided. An effective Branch and Bound algorithm is then presented, which aims at reducing the gap between the above mentioned lower and upper bounds. Our Branch and Bound exploits the information gathered while going down in the enumeration tree in order to solve efficiently the subproblems related to other nodes. This is accomplished by using a bundle method to solve at each node the Lagrangean dual. Some variants of the proposed Branch and Bound method are defined in order to identify the best strategy for different classes of instances. A comparison of computational results relative to these variants is presented.

Optimal Allocation Of Heterogeneous Robots In World Wide Web Search Engines

It is a conflicting requirement to reduce network traffic and loads on Web servers caused by the robots in a World Wide Web search engine and to increase the currency of the database in the search engine. This paper addresses the problem of finding optimal allocations of a given number of robots in a search engine to heterogeneous Internet domains such that a cost function which characterizes the combined consideration of network/server loads and database currency can be minimized. The cost function and the optimization problem are formulated based on a queueing model of search engines. Our algorithm to solve the problem uses the depth-first search strategy to traverse an enumeration tree which generates all possible allocations.

Optimal Integer Solutions to Industrial Cutting-Stock Problems: Part 2, Benchmark Results

In this paper we present a state-of-the-art version of the branch-and-price procedure of Degraeve and Schrage (1999) for the exact solution of the cutting-stock problem. The average solution time is reduced by a factor of more than 300. This allows us to solve problems twice as large as the largest problems solved in the literature today. The two most important improvements are (1) a hybrid simplex method/subgradient-optimization procedure to find the LP relaxation, and (2) a branching scheme that first focuses on the residual problem throughout the enumeration tree. In addition, the strength of our algorithm is the integration of different components into one comprehensive procedure. The other components are using heuristics intensively, a pruning rule, and the use of a dominance rule. We validate our methodology with both industrial and generated data sets. The performance of our algorithm is compared extensively with other implementations and various heuristics for the problem. The proposed algorithm is very efficient for solving the bin-packing problem as well. The major implication of our methodology is that we solve industrial sizes of an NP-hard problem practically in a time to solve its LP relaxation.

Deciding validity in a spatial logic for trees

(MATH) We consider a propositional spatial logic for finite trees. The logic includes A ???? Par B (tree composition), A ???? B (the implication induced by composition), and O (the unit of composition). We show that the satisfaction and validity problems are equivalent, and decidable. The crux of the argument is devising a finite enumeration of trees to consider when deciding whether a spatial implication is satisfied. We introduce a sequent calculus for the logic, and show it to be sound and complete with respect to an interpretation in terms of satisfaction. Finally, we describe a complete proof procedure for the sequent calculus. We envisage applications in the area of logic-based type systems for semistructured data. We describe a small programming language based on this idea.

On Trees and Characters

A new family of trees, defined in term of Young diagrams, is introduced. Values of central characters of the symmetric group are represented as a weighted enumeration of such trees. The proof involves a new decomposition theorem for representations corresponding to general shapes.

Small covering designs by branch-and-cut

A Branch-and-Cut algorithm for finding covering designs is presented. Its originality resides in the use of isomorphism pruning of the enumeration tree. A proof that no 4-(10, 5, 1)-covering design with less than 51 sets exists is obtained together with all non isomorphic 4-(10, 5, 1)-covering designs with 51 sets.

Enumeration of Pareto optimal multi-criteria spanning trees – a proof of the incorrectness of Zhou and Gen's proposed algorithm

The minimum spanning tree (MST) problem is a well-known optimization problem of major significance in operational research. In the multi-criteria MST (mc-MST) problem, the scalar edge weights of the MST problem are replaced by vectors, and the aim is to find the complete set of Pareto optimal minimum-weight spanning trees. This problem is NP-hard and so approximate methods must be used if one is to tackle it efficiently. In an article previously published in this journal, a genetic algorithm (GA) was put forward for the mc-MST. To evaluate the GA, the solution sets generated by it were compared with solution sets from a proposed (exponential time) algorithm for enumerating all Pareto optimal spanning trees. However, the proposed enumeration algorithm that was used is not correct for two reasons: (1) It does not guarantee that all Pareto optimal minimum-weight spanning trees are returned. (2) It does not guarantee that those trees that are returned are Pareto optimal. In this short paper we prove these two theorems.

Pruning by isomorphism in branch-and-cut

The paper presents a branch-and-cut for solving (0, 1) integer linear programs having a large symmetry group. The group is used for pruning the enumeration tree and for generating cuts. The cuts are non-standard, cutting integer feasible solutions but leaving the optimal value of the problem unchanged. Pruning and cut generation are performed by backtracking procedures using a Schreier-Sims table for representing the group. Applications to hard set covering problems and to the generation of covering designs and error correcting codes are presented.

DIMERS AND SPANNING TREES: SOME RECENT RESULTS

This paper reviews some recent progress on dimer and spanning tree enumerations. We use the Kasteleyn formulation to enumerate close-packed dimers on a simple-quartic net embedded on non-orientable surfaces, and obtain solutions in the form of double products. For spanning trees the enumeration is carried out by evaluating the eigenvalues of the Laplacian matrix associated with the lattice, a procedure which holds in any spatial dimension. In two dimensions a bijection due to Temperley relates spanning tree and dimer configurations on two related lattices. We use this bijection to enumerate dimers on a net with a vacancy on the boundary. It is found that the occurrence of a vacancy induces a [Formula: see text] correction to the enumeration, where N is the linear size of the lattice, and changes the central charge from c = 1 to -2.

An improved branch-and-bound algorithm for the two machine total completion time flow shop problem

We consider the two machine total completion time flow shop scheduling problem. This problem is known to be NP-Hard in the strong sense. An improved Lagrangean relaxation approach is proposed. Two new dominance criteria are introduced to curtail the enumeration tree. A branch-and-bound algorithm capable of solving to optimality medium size problem instances is presented.

An algorithm to generate all spanning trees with flow

Spanning tree enumeration in undirected graphs is an important issue and task in many problems encountered in computer network and circuit analysis. This paper discusses the spanning tree with flow for the case that there are flow requirements between each node pair. An algorithm based on minimal paths (MPs) is proposed to generate all spanning trees without flow. The proposed algorithm is a structured approach, which splits the system into structural MPs first, and also all steps in it are easy to follow.

An efficient algorithm for the single machine total tardiness problem

This paper presents an exact algorithm for the single machine total tardiness problem (1// Σ Ti ). We present a new synthesis of various results from the literature which leads to a compact and concise representation of job precedences, a simple optimality check, new decomposition theory, a new lower bound, and a check for presolved subproblems. These are integrated through the use of an equivalence concept that permits a continuous reformation of the data to permit early detection of optimality at the nodes of an enumeration tree. The overall effect is a significant reduction in the size of the search tree, CPU times, and storage requirements. The algorithm is capable of handling much larger problems (e.g., 500 jobs) than its predecessors in the literature (≤ 150). In addition, a simple modification of the algorithm gives a new heuristic which significantly outperforms the best known heuristics in the literature.

Global optimization of nonconvex factorable programming problems

In this paper, we consider a special class of nonconvex programming problems for which the objective function and constraints are defined in terms of general nonconvex factorable functions. We propose a branch-and-bound approach based on linear programming relaxations generated through various approximation schemes that utilize, for example, the Mean-Value Theorem and Chebyshev interpolation polynomials coordinated with a Reformulation-Linearization Technique (RLT). A suitable partitioning process is proposed that induces convergence to a global optimum. The algorithm has been implemented in C++ and some preliminary computational results are reported on a set of fifteen engineering process control and design test problems from various sources in the literature. The results indicate that the proposed procedure generates tight relaxations, even via the initial node linear program itself. Furthermore, for nine of these fifteen problems, the application of a local search method that is initialized at the LP relaxation solution produced the actual global optimum at the initial node of the enumeration tree. Moreover, for two test cases, the global optimum found improves upon the solutions previously reported in the source literature.

An outer approximation based branch and cut algorithm for convex 0-1 MINLP problems

A branch and cut algorithm is developed for solving convex 0-1 Mixed Integer Nonlinear Programming (MINLP) problems. The algorithm integrates Branch and Bound, Outer Approximation and Gomory Cutting Planes. Only the initial Mixed Integer Linear Programming (MILP) master problem is considered. At integer solutions Nonlinear Programming (NLP) problems are solved, using a primal-dual interior point algorithm. The objective and constraints are linearized at the optimum solution of these NLP problems and the linearizations are added to all the unsolved nodes of the enumeration tree. Also, Gomory cutting planes, which are valid throughout the tree, are generated at selected nodes. These cuts help the algorithm to locate integer solutions quickly and consequently improve the linear approximation of the objective and constraints held at the unsolved nodes of the tree. Numerical results show that the addition of Gomory cuts can reduce the number of nodes in the enumeration tree.

Enumeration of Equicolorable Trees

A tree, being a connected acyclic graph, can be bicolored in two ways, which differ from each other by exchange of the colors. We shall say that a tree is equicolorable if these bicolorings assign the two colors to equal numbers of vertices. Labelled equicolored trees have been enumerated several times in the literature, and from this result it is easy to enumerate labelled equicolorable trees. The result is that the probability that a randomly chosen n-vertex labelled tree is equicolorable is asymptotically just twice the probability that its vertices would be equicolored if they were assigned colors by independent unbiased coin flips. Our goal in this paper is the enumeration of unlabelled equicolorable trees (that is, trees up to isomorphism), both exactly (in terms of generating functions) and asymptotically. We treat both the rooted and unrooted versions of this problem and conclude that in either case the probability that a randomly chosen n-vertex unlabelled tree is equicolorable is asymptotically 1.40499... times as large as the probability that it would be equicolored if its vertices were assigned colors by independent unbiased coin flips.

An Efficient Algorithm for the Single Machine Total Tardiness Problem

This paper presents an exact algorithm for the single machine total tardiness problem (1//∑T i). We present a new synthesis of various results from the literature which leads to a compact and concise representation of job precedences, a simple optimality check, new decomposition theory, a new lower bound, and a check for presolved subproblems. These are integrated through the use of an equivalence concept that permits a continuous reformation of the data to permit early detection of optimality at the nodes of an enumeration tree. The overall effect is a significant reduction in the size of the search tree, CPU times, and storage requirements. The algorithm is capable of handling much larger problems (e.g., 500 jobs) than its predecessors in the literature (≤ 150). In addition, a simple modification of the algorithm gives a new heuristic which significantly outperforms the best known heuristics in the literature.

Experimental Results on Using General Disjunctions in Branch-and-Bound for General-Integer Linear Programs

Typical implementations of branch-and-bound for integer linear programs choose to branch on single variables. In this paper we explore the use of general disjunctions for branching when solving linear programs with general-integer variables. We give computational results that show that the size of the enumeration tree can be greatly reduced by branching on such disjunctions rather than on single variables.