A similar algorithm can also enumerate all bases of a linear program, without requiring that it defines a polytope that is simple. Applying reverse search to this data generates all vertices of the polytope. Any such pivot rule can be interpreted as defining the parent function of a spanning tree of the polytope, whose root is the optimal vertex. The simplex algorithm from the theory of linear programming finds a vertex maximizing a given linear function of the coordinates, by walking from vertex to vertex, choosing at each step a vertex with a greater value of the function there are several standard choices of "pivot rule" that specify more precisely which vertex to choose. This algorithm involves listing the neighbors of an object once for each step in the search. In the remaining case, when there is no next child and the current object is the root, the reverse search terminates. If there is no next child and the current object is not the root, the next object is the parent of the current object. If another child is found in this way, it is the next object. The algorithm lists the children (that is, state-space neighbors of the current object that have the current object as their parent) one at a time until reaching this previous child, and then takes one more step in this list of children. In all other cases, the previous object must be a child of the current object.The next object is its first child or, if it has no children, its parent. If there is no previous object, or the previous object is the parent of the current object, then this is the first time the traversal has reached the current object, so it is output from the search.From this information, it is possible to determine the next step of the traversal by the following case analysis: Initially, the current object is set to the root of the tree, and there is no previous object. Instead, reverse search traverses the spanning tree in the same order while only storing two objects: the current object of the traversal, and the previously traversed object. However, this recursive algorithm may still require a large amount of memory for its call stack, in cases when the tree is very deep. Unlike a depth-first search of a graph with cycles, it is not necessary to maintain the set of already-visited nodes to avoid repeated visits such repetition is not possible in a tree. Ī classical depth-first search of this spanning tree would traverse the tree recursively, starting from the root, at each node listing all of the children and making a recursive call for each one. It is these reversed links to child nodes that the algorithm searches. A subroutine for listing all of the neighbors in the state space (not all of which may be neighbors in the tree)įrom this information it is possible to find the children of any given node in the tree, reversing the links given by the parent subroutine: they are simply the neighbors whose parent is the given node.A subroutine for generating the parent of each object in the tree, with the property that if repeated enough times it will eventually reach the root.The root of the spanning tree, one of the objects.It finds each objects using a depth-first search in a rooted spanning tree of this state space, described by the following information: Principles Ī reverse-search algorithm generates the combinatorial objects in a state space, an implicit graph whose vertices are the objects to be listed and whose edges represent certain "local moves" connecting pairs of objects, typically by making small changes to their structure. They were formalized more broadly by Avis and Fukuda in 1996. Reverse-search algorithms were introduced by David Avis and Komei Fukuda in 1991, for problems of generating the vertices of convex polytopes and the cells of arrangements of hyperplanes. (Generally, however, they are not classed as polynomial-time algorithms, because the number of objects they generate is exponential.) They work by organizing the objects to be generated into a spanning tree of their state space, and then performing a depth-first search of this tree. In many cases, these methods allow the objects to be generated in polynomial time per object, using only enough memory to store a constant number of objects ( polynomial space). Reverse-search algorithms are a class of algorithms for generating all objects of a given size, from certain classes of combinatorial objects.
0 Comments
Leave a Reply. |
AuthorWrite something about yourself. No need to be fancy, just an overview. ArchivesCategories |