Node Of Search Tree Research Articles

Improved models for operation modes of complex compressor stations

We study combinatorial structures in large-scale mixed-integer (nonlinear) programming problems arising in gas network optimization. We propose a preprocessing strategy exploiting the observation that a large part of the combinatorial complexity arises in certain subnetworks. Our approach analyzes these subnetworks and the combinatorial structure of the flows within these subnetworks in order to provide alternative models with a stronger combinatorial structure that can be exploited by off-the-shelve solvers. In particular, we consider the modeling of operation modes for complex compressor stations (i.e., ones with several in- or outlets) in gas networks. We propose a refined model that allows to precompute tighter bounds for each operation mode and a number of model variants based on the refined model exploiting these tighter bounds. We provide a procedure to obtain the refined model from the input data for the original model. This procedure is based on a nontrivial reduction of the graph representing the gas flow through the compressor station in an operation mode. We evaluate our model variants on reference benchmark data, showing that they reduce the average running time between 10% for easy instances and 46% for hard instances. Moreover, for three of four considered networks, the average number of search tree nodes is at least halved, showing the effectivity of our model variants to guide the solver’s search.

Block Binary Search Tree

This paper illustrates a novel data structure created by me called Block Binary Search Tree (BBST). BBST is a data structure which extends Binary Search Tree by replacing the key-value pair domain with an array of key-value pairs in each node of Binary Search Tree. It greatly reduces the space usage cost compared to B+ tree, Binary Search Trees and all kinds of different Self-Balancing Binary Search Trees such as AVL, RBT, Splay.

Stochastic passenger train timetabling using a branch and bound approach

Abstract We investigate the integrated scheduling of freight and passenger trains in complex railway networks and the timetabling for passenger trains to improve the efficiency of the schedules. In the proposed model, the objective is to study the robust passenger train timetable considering the uncertainty in freight train departure times. The joint routing and scheduling are considered between the two types of trains. We propose a branch and bound framework with hybrid heuristics to solve the problem. On each search tree node, a Lagrangian method is first developed to solve for a relaxed passenger train schedule and then a feasibility recovery heuristic is applied. Then a labeling algorithm is proposed to jointly optimize the freight and passenger trains sequentially. Numerical experiments show the proposed solution approach outperforms other heuristics on actual railway networks.

Incremental Upper Bound for the Maximum Clique Problem

The maximum clique problem (MaxClique for short) consists of searching for a maximum complete subgraph in a graph. A branch-and-bound (BnB) MaxClique algorithm computes an upper bound of the number of vertices of a maximum clique at every search tree node, to prune the subtree rooted at the node. Existing upper bounds are usually computed from scratch at every search tree node. In this paper, we define an incremental upper bound, called IncUB, which is derived efficiently from previous searches instead of from scratch. Then, we describe a new BnB MaxClique algorithm, called IncMC2, which uses graph coloring and MaxSAT reasoning to filter out the vertices that do not need to be branched on, and uses IncUB to prune the remaining branches. Our experimental results show that IncMC2 is significantly faster than algorithms such as BBMC and IncMaxCLQ. Finally, we carry out experiments to provide evidence that the performance of IncMC2 is due to IncUB. The online supplement is available at https://doi.org/10.1287/ijoc.2017.0770 .

On minimization of the number of branches in branch-and-bound algorithms for the maximum clique problem

When searching for a maximum clique in a graph G, branch-and-bound algorithms in the literature usually focus on the minimization of the number of branches generated at each search tree node. We call dynamic strategy this minimization without any constraint, because it induces a dynamic vertex ordering in G during the search. In this paper, we introduce a static strategy that minimizes the number of branches subject to the constraint that a static vertex ordering in G must be kept during the search. We analyze the two strategies and show that they are complementary. From this complementarity, we propose a new algorithm, called MoMC, that combines the strengths of the two strategies into a single algorithm. The reported experimental results show that MoMC is generally better than the algorithms implementing a single strategy.

Narrowing Support Searching Range in Maintaining Arc Consistency for Solving Constraint Satisfaction Problems

Arc consistency is the most popular filtering technique for solving constraint satisfaction problems. Constraint check plays a central role in establishing arc consistency. In this paper, we propose a method to save constraint checks in maintaining coarse-grained arc consistency during backtracking search for solving the constraint satisfaction problems. We reduce the support searching range by utilizing the information generated by an AC3.1 algorithm at preprocessing step. Compared with the existing maintaining arc consistency (MAC) algorithms, the proposed MAC3 <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">be</sub> algorithm saves constraint checks without maintaining additional data structures at each search tree node. Our experimental results show that MAC3 <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">be</sub> saves both constraint checks and CPU time while solving some benchmark problems.

Improving degree-based variable ordering heuristics for solving constraint satisfaction problems

In this paper, we improved two classical degree-based variable ordering heuristics, $$\frac{\textit{Dom}}{\textit{Ddeg}}$$DomDdeg and $$\frac{\textit{Dom}}{\textit{Wdeg}}$$DomWdeg. We propose a method using the summation of constraint tightness in degree-based heuristics. We also propose two methods to calculate dynamic constraint tightness for binary extensional constraints and non-binary intensional constraints respectively. Our work shows how constraint tightness can be practically used to guide search. We performed a number of experiments on some benchmark instances. The results have shown that, the new heuristics improve the classical ones by both computational time and search tree nodes and they are more efficient than some other successful heuristics on the instances where the classical heuristics work well.

Greedy-Heuristic-Aided Mixed-Integer Linear Programming Approach for Arrival Scheduling

Scheduling arriving aircraft in terminal airspace can be formulated using mixed-integer linear programming and solved by a branch and bound algorithm. Given that the problem is intrinsically nondeterministic polynomial-time hard, success in solving the problem within a reasonable time is not always guaranteed. This paper proposes an efficient optimization approach that calculates the minimum total delay necessary for a conflict-free arrival sequence. A greedy heuristic is developed to find a feasible solution quickly, which serves as a “hot start” so that the branch and bound algorithm can prune as many search tree nodes as it can. Unnecessary searching is thus saved. The greedy heuristic also provides an estimated upper bound for the maximum delay that guarantees a feasible solution for the mixed-integer linear programming. In addition, it identifies a group of aircraft associated with high delays, which are suspended in the first stage of scheduling and sequenced in the second stage based on available time slots. This tactic decreases the computational difficulty. The proposed approach is validated using arriving traffic in 40 major United States airports. Compared to a standalone mixed-integer linear programming, the greedy-heuristic-aided mixed-integer linear programming yields suboptimal solutions in a more efficient manner, and the compromise of optimality is limited.

New bounds and constraint propagation techniques for the clique partitioning problem

This paper considers the problem of clustering the vertices of a complete edge-weighted graph. The objective is to maximize the sum of the edge weights within the clusters (also called cliques). This so-called Clique Partitioning Problem (CPP) is NP-complete, and has several real-life applications such as groupings in flexible manufacturing systems, in biology, in flight gate assignment, etc. Numerous heuristics and exact approaches as well as benchmark tests have been presented in the literature. Most exact methods use branch and bound with branching over edges. We present tighter upper bounds for each search tree node than those known from the literature, improve the constraint propagation techniques for fixing edges in each node, and present a new branching scheme. The theoretical improvements are reflected by computational tests with real-life data. Although a standard solver delivers best results on randomly generated data, the runtime of the proposed algorithm is very low when being applied to instances on object clustering.

제약만족 최적화 문제를 위한 백트래킹 탐색의 구조화

It is very hard to obtain a general algorithm for solution of all the constraint satisfaction optimization problems. However, if the whole problem is separated into subproblems by characteristics of decision variables, we can assume that an algorithm to obtain solutions of these subproblems is easier. Under the assumption, we propose a problem classifying rule which subdivide the whole problem, and develop backtracking algorithms fit for these subproblems. One of the methods of finding a quick solution is efficiently arrange for any order of the search tree nodes. We choose the cluster head positioning problem in wireless sensor networks in which static characteristics is dominant and interference minimization problem of RFID readers that has hybrid mixture of static and dynamic characteristics. For these problems, we develop optimal variable ordering algorithms, and compare with the conventional methods. As a result of classifying the problem into subproblems, we can realize a backtracking framework for systematic search. We also have shown that developed backtracking algorithms have good performance in their quality.

Solution of a fractional combinatorial optimization problem by mixed integer programming

Fractionnal mathematical programs appear in numerous operations research, computer science and economic domains. We consider in this paper the problem of maximizing the sum of 0-1 hyperbolic ratios (SRH). In contrast to the single ratio problem, there has been little work in the literature concerning this problem. We propose two mixed-integer linear programming formulations of SRH and develop two different strategies to solve them. The first one consists in using directly a general-purpose mixed-integer programming solver. The second one is based on a specialized branch and bound algorithm that reformulates more precisely the problem at every node of search tree. We also propose a heuristic method and we exploit the obtained solution in order to improve the first strategy. We present computational experiments that allow to compare the different approaches.

A Library Hierarchy for Implementing Scalable Parallel Search Algorithms

This paper describes the design of the Abstract Library for Parallel Search (ALPS), a framework for implementing scalable, parallel algorithms based on tree search. ALPS is specifically designed to support data-intensive algorithms, in which large amounts of data are required to describe each node in the search tree. Implementing such algorithms in a scalable manner is challenging both because of data storage requirements and communication overhead. ALPS incorporates a number of new ideas to address this challenge. The paper also describes the design of two other libraries forming a hierarchy built on top of ALPS. The first is the Branch, Constrain, and Price Software (BiCePS) library, a framework that supports the implementation of parallel branch and bound algorithms in which the bounds are obtained by solving some sort of relaxation, usually Lagrangian. In this layer, the notion of global data objects associated with the variables and constraints is introduced. These global objects provide a connection between the various subproblems in the search tree, but they pose further difficulties for designing scalable algorithms. The other library is the BiCePS linear integer solver (BLIS), a concretization of BiCePS, in which linear programming is used to obtain bounds in each search tree node.

A theoretical evaluation of selected backtracking algorithms

In recent years, many new backtracking algorithms for solving constraint satisfaction problems have been proposed. The algorithms are usually evaluated by empirical testing. This method, however, has its limitations. Our paper adopts a different, purely theoretical approach, which is based on characterizations of the sets of search tree nodes visited by the backtracking algorithms. A notion of inconsistency between instantiations and variables is introduced, and is shown to be a useful tool for characterizing such well-known concepts as backtrack, backjump, and domain annihilation. The characterizations enable us to: (a) prove the correctness of the algorithms, and (b) partially order the algorithms according to two standard performance measures: the number of nodes visited, and the number of consistency checks performed. Among other results, we prove the correctness of Backjumping and Conflict-Directed Backjumping, and show that Forward Checking never visits more nodes than Backjumping. Our approach leads us also to propose a modification to two hybrid backtracking algorithms, Backmarking with Backjumping (BMJ) and Backmarking with Conflict-Directed Backjumping (BM-CBJ), so that they always perform fewer consistency checks than the original algorithms.

A parallel branch‐and‐bound algorithm for integer linear programming and its implementation on a distributed multiprocessor

AbstractThis paper describes a parallel branch‐and‐bound algorithm for general integer linear programming problems and its implementation on a distributed memory multiprocessor nCUBE2.With a branch‐and‐bound algorithm, the amount of computation on each search tree node varies, and in general, is large. This has led to development of an effective communication strategy for the algorithm presented herein. Its implementation and performance evaluation also are described.The results show that the more difficult the problem instances become in terms of time to solve on a sequential computer, the more efficient the algorithm presented here proves to be.

Expected Performance of m-Solution Backtracking

This paper derives upper bounds on the expected number of search tree nodes visited during an m-solution backtracking search, a search which terminates after some preselected number m problem solutions are found. The search behavior is assumed to have a general probabilistic structure. The results are stated in terms of node expansion and contraction. A visited search tree node is said to be expanding if the mean number of its children visited by the search exceeds 1 and is contracting otherwise. It is shown that if every node expands, or if every node contracts, then the number of search tree nodes visited by a search has an upper bound which is linear in the depth of the tree, in the mean number of children a node has, and in the number of solutions sought. Also derived are bounds linear in the depth of the tree in some situations where an upper portion of the tree contracts (expands), while the lower portion expands (contracts). While previous analyses of 1-solution backtracking have concluded that the expected performance is always linear in the tree depth, the model allows superlinear expected performance.