1 / 14

Exploring Branch-and-Bound and Backtracking Techniques in Optimization Problems

This text delves into the nuances of optimization techniques such as Branch-and-Bound (B&B) and Backtracking, particularly in the context of the 0-1 Knapsack problem and other combinatorial challenges. It discusses the advantages of B&B over Backtracking when a strong bound function is available, enabling faster searches through optimization problems. The text also covers depth-first and breadth-first search strategies, algorithmic complexity, and the importance of efficient traversal methods in decision trees, making it essential reading for those interested in advanced optimization methods.

wilona
Télécharger la présentation

Exploring Branch-and-Bound and Backtracking Techniques in Optimization Problems

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. B&BBed & BreakfastBranch-and-Bound Chapter 6

  2. Task 11 p. 255 • is a bonus task • Microsoft belief network (MSBN) • troubleshooting • office assistant

  3. Methods for 0-1-knapsack problem • Dyn programming W(2n) • Backtracking W(2n) • B&B improvement over Backtracking if have a good bound function

  4. Backtracking way of traversing the tree is selected in advance (depth-first) different of problems threshold bound value selecting any promising child node slower search depth-first search with threshold pruning B&B way of traversing the tree is not selected in advance only optimization problems best bound value selecting best promising child node faster search best-first search with pruning by the best value Backtracking and B&B

  5. Breadth-first search • All nodes at level 1 • All nodes at level 2 • … • All nodes at level n • fig 6.1 (p.223)

  6. v u1 u2 Breadth-first search tree w1 w2 w3 w4 Voidbreadth_first_tree_search(tree T) { queue_of_node Q;// no simple recursion; use a queue node u,v, initialize(Q); // initialize Q=  v=root of T; visit v; enqueue(Q,v); // insert item at the end of the queue while(! Empty(Q)) { dequeue(Q,v); //remove an item from the front of the queue for (each child u of v) {visit u; enqueue;} } } 

  7. v u1 u2 Breadth-first search tree w1 w2 w3 w4 Voidbreadth_first_tree_search(tree T) { queue_of_node Q;// no simple recursion; use a queue node u,v, initialize(Q); // initialize Q=  v=root of T; visit v; enqueue(Q,v); // insert item at the end of the queue while(! Empty(Q)) { dequeue(Q,v); //remove an item from the front of the queue for (each child u of v) {visit u; enqueue;} } } v

  8. v u1 u2 Breadth-first search tree w1 w2 w3 w4 Voidbreadth_first_tree_search(tree T) { queue_of_node Q;// no simple recursion; use a queue node u,v, initialize(Q); // initialize Q=  v=root of T; visit v; enqueue(Q,v); // insert item at the end of the queue while(! Empty(Q)) { dequeue(Q,v); //remove an item from the front of the queue for (each child u of v) {visit u; enqueue;} } } 

  9. v u1 u2 Breadth-first search tree w1 w2 w3 w4 Voidbreadth_first_tree_search(tree T) { queue_of_node Q;// no simple recursion; use a queue node u,v, initialize(Q); // initialize Q=  v=root of T; visit v; enqueue(Q,v); // insert item at the end of the queue while(! Empty(Q)) { dequeue(Q,v); //remove an item from the front of the queue for (each child u of v) {visit u; enqueue;} } } u1

  10. v u1 u2 Breadth-first search tree w1 w2 w3 w4 Voidbreadth_first_tree_search(tree T) { queue_of_node Q;// no simple recursion; use a queue node u,v, initialize(Q); // initialize Q=  v=root of T; visit v; enqueue(Q,v); // insert item at the end of the queue while(! Empty(Q)) { dequeue(Q,v); //remove an item from the front of the queue for (each child u of v) {visit u; enqueue;} } } u2

  11. v u1 u2 Breadth-first search tree w1 w2 w3 w4 Voidbreadth_first_tree_search(tree T) { queue_of_node Q;// no simple recursion; use a queue node u,v, initialize(Q); // initialize Q=  v=root of T; visit v; enqueue(Q,v); // insert item at the end of the queue while(! Empty(Q)) { dequeue(Q,v); //remove an item from the front of the queue for (each child u of v) {visit u; enqueue;} } } w1

  12. v u1 u2 Breadth-first search tree w1 w2 w3 w4 Voidbreadth_first_tree_search(tree T) { queue_of_node Q;// no simple recursion; use a queue node u,v, initialize(Q); // initialize Q=  v=root of T; visit v; enqueue(Q,v); // insert item at the end of the queue while(! Empty(Q)) { dequeue(Q,v); //remove an item from the front of the queue for (each child u of v) {visit u; enqueue;} } } w2

  13. B&B and 0-1 Knapsack problem • Algorithm number of • nodes visited • Backtracking p. 210 fig 5.14 13 • B&B #1 p. 226 fig 6.2 17 • B&B #2 p. 231 fig 6.3 11 • complexity is measured as the number of visited nodes

  14. Traveling salesperson • bound function • greater than current maximum profit • lower bound for the profit • the length of the edge taken when leaving a vertex must be at least as great as the length of the shortest of the edge taken of leaving vertex

More Related