Toward a Model for Backtracking and Dynamic Programming (original) (raw)
Related papers
Pebbling and Branching Programs Solving the Tree Evaluation Problem
Corr, 2010
We study restricted computation models related to the tree evaluation problem. The TEP was introduced in earlier work as a simple candidate for the (very) long term goal of separating L and LogDCFL. The input to the problem is a rooted, balanced binary tree of height h, whose internal nodes are labeled with binary functions on [k] = {1,. .. , k} (each given simply as a list of k 2 elements of [k]), and whose leaves are labeled with elements of [k]. Each node obtains a value in [k] equal to its binary function applied to the values of its children. The output is the value of the root. The first restricted computation model, called fractional pebbling, is a generalization of the black/white pebbling game on graphs, and arises in a natural way from the search for good upper bounds on the size of nondeterministic branching programs solving the TEP-for any fixed h, if the binary tree of height h has fractional pebbling cost at most p, then there are nondeterministic branching programs of size O(k p) solving the height h TEP. We prove a lower bound on the fractional pebbling cost of d-ary trees that is tight to within an additive constant for each fixed d. The second restricted computation model we study is a semantic restriction on (non)deterministic branching programs solving the TEP-thrifty branching programs. Deterministic (resp. nondeterministic) thrifty BPs suffice to implement the best known algorithms, based on black pebbling (resp. fractional pebbling), for the TEP. In earlier work, for each fixed h a lower bound on the size of thrifty deterministic branching programs was proved that is tight for sufficiently large k. We give an alternative proof that achieves the same bound for all k and h. We show the same bound still holds in a lessrestricted model, and also that gradually weaker lower bounds can be obtained for gradually weaker restrictions on the model.
Pebbling and branching programs solving the tree evaluation problem. MSc research paper
2010
We study restricted computation models related to the tree evaluation problem. The TEP was introduced in earlier work as a simple candidate for the (very) long term goal of separating L and LogDCFL. The input to the problem is a rooted, balanced binary tree of height h, whose internal nodes are labeled with binary functions on [k] = {1,. .. , k} (each given simply as a list of k 2 elements of [k]), and whose leaves are labeled with elements of [k]. Each node obtains a value in [k] equal to its binary function applied to the values of its children. The output is the value of the root. The first restricted computation model, called fractional pebbling, is a generalization of the black/white pebbling game on graphs, and arises in a natural way from the search for good upper bounds on the size of nondeterministic branching programs solving the TEP-for any fixed h, if the binary tree of height h has fractional pebbling cost at most p, then there are nondeterministic branching programs of size O(k p) solving the height h TEP. We prove a lower bound on the fractional pebbling cost of d-ary trees that is tight to within an additive constant for each fixed d. The second restricted computation model we study is a semantic restriction on (non)deterministic branching programs solving the TEP-thrifty branching programs. Deterministic (resp. nondeterministic) thrifty BPs suffice to implement the best known algorithms, based on black pebbling (resp. fractional pebbling), for the TEP. In earlier work, for each fixed h a lower bound on the size of thrifty deterministic branching programs was proved that is tight for sufficiently large k. We give an alternative proof that achieves the same bound for all k and h. We show the same bound still holds in a lessrestricted model, and also that gradually weaker lower bounds can be obtained for gradually weaker restrictions on the model.
On the complexity of dynamic programming for sequencing problems with precedence constraints
Annals of Operations Research, 1990
Dynamic programming has been successfully used in the past to solve a large class of precedence constrained sequencing problems including for example, the assembly line balancing problem and the total tardiness problem on a single machine. The main limitation of this method has been the amount of storage required, which is directly related to the number of ideals in the precedence structure. In this paper, we present classes for which this number can be efficiently computed, enabling us to decide, in advance, whether the storage requirements of dynamic programming would be excessive for the problem. We develop regression equations based on large-scale computational experiments, which lead to surprisingly good approximations for the number of ideals. We also report on a computational study, comparing the relative effectiveness of various implementations of dynamic progranuning. A common theme throughout the paper is that the width of the precedence constraints plays the most important role in determining the storage requirements of dynamic programming for a sequencing problem.
Minimizing the overhead for some tree-scheduling problems
European Journal of Operational Research, 1996
This paper is devoted to the study of tree-scheduling problems within the execution model described by Anderson, Beame and Ruzzo. We first prove the NP-completeness of the problem of minimizing the overhead for scheduling trees on m processors, and then we propose an algorithm that provides optimal schedules when complete trees are considered.
The Fine Details of Fast Dynamic Programming over Tree Decompositions
Parameterized and Exact Computation, 2013
We study implementation details for dynamic programming over tree decompositions. Firstly, a fact that is overlooked in many papers and books on this subject is that it is not clear how to test adjacency between two vertices in time bounded by a function of k, where k is the width of the given tree decomposition. This is necessary to obtain linear time dynamic programming algorithms. We address this by giving a simple O(kn) time and space preprocessing procedure that enables adjacency testing in time O(k), where n is the number of vertices of the graph. Secondly, we show that a large class of NP-hard problems can be solved in time O(q k+1 n), where q k+1 is the natural size of the dynamic programming tables. The key improvement is that we avoid a polynomial factor in k. This holds for all problems that can be formulated as a Min Weight Homomorphism problem: given a (large) graph G on n vertices and a (small) graph H on q vertices, with integer vertex and edge weights, is there a homomorphism from G to H with total (vertex and edge image) weight at most M ? This result implies e.g. O(2 k n) algorithms for Max Independent Set and Max Cut, and a O(q k+1 n) algorithm for q-Colorability. The table building techniques we develop are also useful for many other problems.
A branch and bound approach for the sequential ordering problem
2012
Abstract. Many different real problems can be modeled in mathematical terms as a Sequential Ordering Problem. This combinatorial optimization problem can be seen as a scheduling problem with precedence constraints among the jobs. In the present paper a branch and bound method that exploits the structure of the precedence constraints is introduced and tested on some benchmark instances commonly adopted in the literature.
European Journal of Operational Research, 1990
In this paper computational results are presented with a very general, yet powerful backtracking procedure for solving the duration minimization and net present value maximization problems in a precedence and resource-constrained network. These networks are generally of the PERT/CPM variety, although it is not required that they be so. Among the advantages cited for our approach are low computer memory (storage) requirements and the ability to obtain improved solutions rapidly (heuristic properties). Since the resource-constrained project scheduling problem subsumes the job shop, flow shop, assembly line balancing, and related scheduling problems, our procedure can be used with little or no modification to solve a wide variety of problem types. Computational experience is reported for both mainframe and personal computer implementations. /$03.50 © 1990 -Elsevier Science Publishers B.V. (North-Holland) J.H. Patterson et al. / A backtracking algorithm for solving scheduling problems 69
On the approximability of an interval scheduling problem
Journal of Scheduling, 1999
In this paper we consider a general interval scheduling problem. The problem is a natural generalization of "nding a maximum independent set in an interval graph. We show that, unless P"NP, this maximization problem cannot be approximated in polynomial time within arbitrarily good precision. On the other hand, we present a simple greedy algorithm that delivers a solution with a value of at least times the value of an optimal solution. Finally, we investigate the quality of an LP-relaxation of a formulation for the problem, by establishing an upper bound on the ratio between the value of the LP-relaxation and the value of an optimal solution.
Pebbles and Branching Programs for the Tree Evaluation Problem
ACM Transactions on Computation Theory, 2012
We introduce the tree evaluation problem, show that it is in LogDCFL (and hence in P), and study its branching program complexity in the hope of eventually proving a superlogarithmic space lower bound. The input to the problem is a rooted, balanced d-ary tree of height h, whose internal nodes are labeled with d-ary functions on [k] = {1, . . . , k}, and whose leaves are labeled with elements of [k]. Each node obtains a value in [k] equal to its d-ary function applied to the values of its d children. The output is the value of the root. We show that the standard black pebbling algorithm applied to the binary tree of height h yields a deterministic k-way branching program with O(k h ) states solving this problem, and we prove that this upper bound is tight for h = 2 and h = 3. We introduce a simple semantic restriction called thrifty on k-way branching programs solving tree evaluation problems and show that the same state bound of Θ(k h ) is tight for all h ≥ 2 for deterministic thrifty programs. We introduce fractional pebbling for trees and show that this yields nondeterministic thrifty programs with Θ(k h/2+1 ) states solving the Boolean problem "determine whether the root has value 1", and prove that this bound is tight for h = 2, 3, 4. We also prove that this same bound is tight for unrestricted nondeterministic k-way branching programs solving the Boolean problem for h = 2, 3.
Branching Allen: Reasoning with intervals in branching time
2004
Allen's interval calculus is one of the most prominent formalisms in the domain of qualitative spatial and temporal reasoning. Applications of this calculus, however, are restricted to domains that deal with linear flows of time. But how the fundamental ideas of Allen's calculus can be extended to other, weaker structures than linear orders has gained only little attention in the literature. In this paper we will investigate intervals in branching flows of time, which are of special interest for temporal reasoning, since they allow for representing indeterministic aspects of systems, scenarios, planning tasks, etc. As well, branching time models, i. e., treelike non-linear structures, do have interesting applications in the field of spatial reasoning, for example, for modeling traffic networks. In a first step we discuss interval relations for branching time, thereby comprising various sources from the literature. Then, in a second step, we present some new complexity results concerning constraint satisfaction problems of interval relations in branching time.