## Are you sure?

This action might not be possible to undo. Are you sure you want to continue?

Terminology Deﬁnition 1 Live node is a node that has been generated but whose children have not yet been generated. Deﬁnition 2 E-node is a live node whose children are currently being explored. In other words, an E-node is a node currently being expanded. Deﬁnition 3 Dead node is a generated node that is not to be expanded or explored any further. All children of a dead node have already been expanded. Deﬁnition 4 Branch-and-bound refers to all state space search methods in which all children of an E-node are generated before any other live node can become the E-node. • Used for state space search – In BFS, exploration of a new node cannot begin until the node currently being explored is fully explored General method • Both BFS and DFS generalize to branch-and-bound strategies – BFS is an FIFO search in terms of live nodes ∗ List of live nodes is a queue – DFS is an LIFO search in terms of live nodes ∗ List of live nodes is a stack • Just like backtracking, we will use bounding functions to avoid generating subtrees that do not contain an answer node • Example: 4-queens – FIFO branch-and-bound algorithm ∗ Initially, there is only one live node; no queen has been placed on the chessboard ∗ The only live node becomes E-node ∗ Expand and generate all its children; children being a queen in column 1, 2, 3, and 4 of row 1 (only live nodes left) ∗ Next E-node is the node with queen in row 1 and column 1 ∗ Expand this node, and add the possible nodes to the queue of live nodes ∗ Bound the nodes that become dead nodes – Compare with backtracking algorithm ∗ Backtracking is superior method for this search problem • Least Cost (LC) search – Selection rule does not give preference to nodes that will lead to answer quickly but just queues those behind the current live nodes ∗ In 4-queen problem, if three queens have been placed on the board, it is obvious that the answer may be reached in one more move ∗ The rigid selection rule requires that other live nodes be expanded and then, the current node be tested – Rank the live nodes by using a heuristic c(·) ˆ

c(x) is the cost of a minimum cost answer node in subtree x c(·) with f (h(x)) = h(x) is an approximation to c(·) ˆ • The 15-puzzle . c(x) is the cost of reaching x from the root of state space tree If x is not an answer node. we use f (h(x)) ≡ 0 and g (x) ≥ g (y) whenever y is a child of x ˆ ˆ – An LC-search coupled with bounding functions is called an LC branch-and-bound search – Cost function ∗ ∗ ∗ ∗ If x is an answer node. then a child of y becomes E node. we can force the search algorithm to favor a node z close to the root over node w.Branch and Bound 2 – The next E-node is selected on the basis of this ranking function – Heuristic is based on the expected additional computational effort (cost) to reach a solution from the current live node – For any node x. that subtree has been searched and there is no need to explore x again ∗ Above can be avoided by using an estimate function g (·) instead of actually expanding the nodes ˆ – Let g (x) be an estimate of the additional effort needed to reach an answer from node x ˆ ∗ x is assigned a rank using a function c(·) such that ˆ c(x) = f (h(x)) + g (x) ˆ ˆ where h(x) is the cost of reaching x from root and f (·) is any nondecreasing function ∗ The effort spent in reaching the live node cannot be reduced and all we are concerned with at this point is to minimize the effort reaching the solution from the live node · This is faulty logic · Using f (·) ≡ 0 biases search algorithm to make deep probes into the search tree · Note that we would expect g (y) ≤ g (x) for y which is a child of x ˆ ˆ · Following x. and so on. we use g (x) ≡ 0 and f (h(x)) as the level of node x ˆ · LC search generates nodes by level ∗ In DFS. reducing the possiblity of deep and fruitless search – A search strategy that uses a cost function c(x) = f (h(x)) + g (x) to select the next E-node would always choose ˆ ˆ for its next E-node a live node with least c(·) ˆ ∗ Such a search strategy is called an LC-search (Least Cost search) ∗ Both BFS and DFS are special cases of LC-search ∗ In BFS. g (w) < g (z) and z is much closer to answer than w ˆ ˆ · By using f (·) ≡ 0. the cost could be given by 1. c(x) = ∞. provided the subtree x contains no answer node If subtree x contains an answer node. Number of nodes in subtree x that need to be generated before an answer can be reached ∗ Search will always generate the minimum number of nodes 2. Number of levels to the nearest answer node in the subtree x ∗ c(root) for 4-queen problem is 4 ˆ ∗ The only nodes to become E-nodes are the nodes on the path from the root to the nearest answer node – Problem with the above techniques to compute the cost at node x is that they involve the search of the subtree at x implying the exploration of the subtree ∗ By the time the cost of a node is determined. y becomes E node. until a subtree is fully searched · Subtrees of nodes in other children of x are not considered until y is fully explored · But g (x) is only an estimate of the true cost ˆ · It is possible that for two nodes w and z.

the algorithm attempts the same sequence of moves – Intelligent solution ∗ Seeks out an answer node and adapts the path it takes through state space tree ∗ Associate a cost c(x) with each node x of state space tree · c(x) is the length of path from the root to nearest goal node (if any) in the subtree with root x ∗ Begin with root as E-node and generate a child node with c(·)-value the same as root · May not be always possible to compute c(·) ∗ Compute an estimate c(x) of c(x) ˆ . the empty spot is in one of the following positions: 2. right No node should have a child state that is the same as its parent Let us order the move of empty space as up.9 × 1012 ∗ Only about half of them are reachable from any given initial state – Check whether the goal state is reachable from initial state ∗ ∗ ∗ ∗ ∗ ∗ Number the frame positions from 1 to 16 pi is the frame position containing tile numbered i p16 is the position of empty spot For any state. 5. and l12 = 6 Let x = 1 if in the initial state. l1 = 0. left (clockwise moves) Perform depth-ﬁrst search and you will notice that successive moves take us away from the goal rather than closer · The search of state space tree is blind. – Organize state space search as a tree ∗ ∗ ∗ ∗ ∗ ∗ Children of each node x represent the states reachable from x in one legal move Consider the move as move of empty space rather than tile Empty space can have four legal moves: up. 6 – Each move creates a new arrangement of tiles. taking leftmost path from the root regardless of initial state · An answer node may never be found ∗ Breadth-ﬁrst search will always ﬁnd a goal state nearest to the root · It is still blind because no matter what the initial state. down. 3. 13. 5. called state of the puzzle – Initial and goal states – A state is reachable from the initial state iff there is a sequence of legal moves from initial state to this state – The state space of an initial state is all the states that can be reached from initial state – Search the state space for the goal state and use the path from initial state to goal state as the answer – Number of possible arrangments for tiles: 16! ≈ 20. right. transform it to the goal arrangement through a series of legal moves 1 3 4 15 2 5 12 7 6 11 14 8 9 10 13 Initial Arrangement 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Goal Arrangement – Legal move involves moving a tile adjacent to the empty spot E to E – Four possible moves in the initial state above: tiles 2. left. 4. 7. 10. l4 = 1. otherwise x = 0 16 Theorem 1 The goal state is reachable from the initial state iff i=1 li + x is even. down. 12.Branch and Bound 3 – 15 numbered tiles on a square frame with a capacity for 16 tiles – Given an initial arrangement. let li be the number of tiles j such that j < i and pj > pi For the initial arrangement above. 15.

// E-node Initialize the list of live nodes to be empty. list_node_t list_node. float cost. algorithm LCSearch ( t ) { // Search t for an answer node if ( *t is an answer node ) { print ( *t ). return. return. while ( true ) { for each child x of E { if x is an answer node { print the path from x to t. } E = t. } . we’ll substitute it by a heuristic estimate as c() ˆ – Algorithm LCSearch uses c() to ﬁnd an answer node ˆ typedef struct { list_node_t * next.Branch and Bound 4 ∗ c(x) = f (x) + g (x) where f (x) is the length of the path from root to x and g (x) is an estimate of the length ˆ ˆ ˆ of a shortest path from x to a goal node in the subtree with root x ∗ One possible choice for g (x) is the number of nonblank tiles not in their goal position ˆ ∗ There are at least g (x) moves to transform state x to a goal state ˆ · c(x) is a lower bound on c(x) ˆ · c(x) in the conﬁguration below is 1 but you need more moves ˆ 1 2 3 4 5 6 8 9 10 11 12 13 14 15 7 • Control abstractions for LC-search – Search space tree t – Cost function for the nodes in t: c(·) – Let x be any node in t ∗ c(x) is the minimum cost of any answer node in the subtree with root x ∗ c(t) is the cost of the minimum cost answer node in t – Since it is not easy to compute c(). } list_node_t. list_node_t * parent.

a penalty pi is incurred // Find a live node with least estimated cost // The found node is deleted from the list of live nodes . FIFO. and LIFO is in the implementation of list of live nodes • Bounding – A branch-and-bound method searches a state space tree using any search mechanism in which all children of the E-node are generated before another node becomes the E-node – Each answer node x has a cost c(x) and we have to ﬁnd a minimum-cost answer node ∗ Common strategies include LC. x->parent = E. E becomes a dead node · Happens only if none of E’s children is an answer node ∗ If there are no live nodes left. } // Add x to list of live nodes. the algorithm terminates. } } ∗ The algorithm always keeps the list of live nodes in a list ∗ When all the children of E have been generated. and LIFO – Use a cost function c(·) such that c(x) ≤ c(x) provides lower bound on the solution obtainable from any node x ˆ ˆ – If U is the upper bound on the cost of a minimum-cost solution. then all live nodes x with c(x) > U may be killed ˆ ∗ All answer nodes reachable from x have cost c(x) ≥ c(x) > U ˆ ∗ Starting value for U can be obtained by some heuristic or set to ∞ ∗ Each time a new answer node is found. Least() correctly chooses the next Enode and the search continues – FIFO search ∗ Implement list of live nodes as a queue ∗ Least() removes the head of the queue ∗ Add() adds the node to the end of the queue – LIFO search – The only difference in LC. the value of U can be updated – Optimization/minimization problem ∗ Maximization converted to minimization by changing sign of objective function ∗ Formulate the search for an optimal solution as a search for a least-cost answer node in a state space search tree ∗ Deﬁne the cost function c(·) such that c(x) is minimum for all nodes representing an optimal solution · Easiest done if c(·) is the objective function itself – Example: Job sequencing with deadlines ∗ Given n jobs and 1 processor ∗ Each job ji has a 3-tuple associated with it represented by (pi .Branch and Bound 5 Add ( x ). return. // Pointer for path to root if there are no more live nodes { print ( "No answer node" ). otherwise. } E = Least(). FIFO. ti ) · Job ji requires ti units of processing time · If processing is not completed by deadline di . di .

2). j4 ) Organize solution space by either of the two formulations of sum-of-subsets problem (variable or ﬁxed tuple size) Optimal solution comes as J = {j2 . c(2) = 9. c(2) = 9. nodes 4 and 5 get killed (or bounded) ˆ ˆ – Only nodes 2 and 3 remain alive – Node 2 becomes the next E-node. c(5) = 13. its children are generated as nodes 6. 3} and m = 3. S7 = {1. 4. c(x) = ∞ ˆ · In the tree with variable tuple formulation. j3 = (6. and u(5) = 21 – Variable U is updated to 14 when node 3 is generated – Since c(4) and c(5) are greater than U .Branch and Bound 6 ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ Objective is to select a subset J of n jobs such that all jobs in J can be completed by their deadline A penalty will incur only on jobs not in J For optimal solution. j4 = (3. 1. J should be such that the penalty is minimized among all possible subsets J Problem instance: n = 4. 1). U is updated to 9 – c(7) = 10 > U and so. Also. for node 6. j3 }. j2 } and hence. generating node 9 and 10 – u(9) = 8 updating U to 8 . j1 = (5. i < 2 pi = i ∈ S2 i < 2 = pi = p2 = 10 i ∈ S2 · In the tree with ﬁxed tuple formulation. j2 . 0 · For node 7. j3 . therefore. and c(1) = 8 Fixed tuple size formulation · c(1) = 8. 7. 2. and c(6) = 8 c(1) is the penalty corresponding to an optimal solution J Getting the estimate bound c(x) ˆ · c(x) ≤ c(x) for all x ˆ · Let Sx be the subset of jobs selected for J at node x ˆ · If m = max{i|i ∈ Sx } then c(x) = ˆ i < m pi is an estimate for c(x) with the property c(x) ≤ c(x) i ∈ Sx · For a non-feasible node. and 5 are generated in that order ∗ u(2) = 19. node 7 gets killed ˆ – Next node 3 becomes E-node. u(4) = 18. with a penalty cost of 8 Cost function c(x) can be deﬁned as the minimum penalty corresponding to any node in the subtree with root x c(x) = ∞ for any non-feasible node Variable tuple size formulation · c(3) = 8. and 8 – u(6) = 9 and so. 1) Solution space is all possible subsets of (j1 . m = 2. 1. u(3) = 14. 1). j2 = (10. 3. node 12 corresponds to the omission of job j1 and hence a penalty of 5 · Node 13 corresponds to the omission of jobs j1 and j3 and hence a penalty of 13 ∗ A simpler upper bound u(x) on the cost of a minimum-cost answer node in the subtree x is u(x) = i∈Sx pi · u(x) is the cost of the solution Sx corresponding to node x • FIFO branch-and-bound – FIFO branch-and-bound for job sequencing problem can begin with U = ∞ (or U = 1≤i≤n pi ) as an upper bound on the cost of a minimum-cost answer node – Start with node 1 as the E-node in the variable tuple formulation of the state space tree ∗ Nodes 2. 3. S6 = {j1 .

- [BlackHat]Eagle Ida Pro 06
- Inside Youtube
- Mc Quine Multiple Output
- Ai Book Unit i Final
- Branch And Bound Design And Analysis Of Alogorithm
- Branch and Bound Algorithms
- Cs1302 Computer Networks Full Notes
- Branch and Bound
- branch and bound tsp
- Scheduling -Branch and Bound Method
- MIP Bounding Strategies
- AWS Overview
- Visual Basic 6
- MM-Visualization Tools for Real-Time Search Algorithms
- What is Difference Between Backtracking and Branch and Bound Method
- A Incremental Algorithm Based on Rough Set for Concept Hierarchy Tree
- CS-TR-4438
- 4-solutions-clrs-22
- MIT18_310F13_Ch6
- vulunerability classification
- DMT
- 106
- 11
- 10.1.1.45
- AVL Tree SK
- The Mathematics and Statistics of Voting Power
- Constraint Programming MOZ 2004
- 04220788
- Type Indexed Data
- B

Read Free for 30 Days

Cancel anytime.

Close Dialog## Are you sure?

This action might not be possible to undo. Are you sure you want to continue?

Loading