CS 312: Algorithm Analysis Lecture #35: Branch and Bound Design Options - State Spaces Slides by: Eric Ringger, with contributions from Mike Jones, Eric.

Slides:



Advertisements
Similar presentations
Techniques for Dealing with Hard Problems Backtrack: –Systematically enumerates all potential solutions by continually trying to extend a partial solution.
Advertisements

Game Playing (Tic-Tac-Toe), ANDOR graph By Chinmaya, Hanoosh,Rajkumar.
Branch & Bound Algorithms
Search in AI.
CPSC 322, Lecture 9Slide 1 Search: Advanced Topics Computer Science cpsc322, Lecture 9 (Textbook Chpt 3.6) January, 23, 2009.
Branch and Bound Searching Strategies
Branch and Bound Similar to backtracking in generating a search tree and looking for one or more solutions Different in that the “objective” is constrained.
CS 410 Applied Algorithms Applied Algorithms Lecture #3 Data Structures.
Great Theoretical Ideas in Computer Science.
Graphs. Graph definitions There are two kinds of graphs: directed graphs (sometimes called digraphs) and undirected graphs Birmingham Rugby London Cambridge.
MAE 552 – Heuristic Optimization Lecture 26 April 1, 2002 Topic:Branch and Bound.
1 Branch and Bound Searching Strategies 2 Branch-and-bound strategy 2 mechanisms: A mechanism to generate branches A mechanism to generate a bound so.
Ch 13 – Backtracking + Branch-and-Bound
Jin Zheng, Central South University1 Branch-and-bound.
Approximation Algorithms Motivation and Definitions TSP Vertex Cover Scheduling.
Backtracking.
CS 312: Algorithm Analysis Lecture #16: Strongly Connected Components This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported.
Minimax Trees: Utility Evaluation, Tree Evaluation, Pruning CPSC 315 – Programming Studio Spring 2008 Project 2, Lecture 2 Adapted from slides of Yoonsuck.
CS 312: Algorithm Analysis Lecture #3: Algorithms for Modular Arithmetic, Modular Exponentiation This work is licensed under a Creative Commons Attribution-Share.
Dr. Jouhaina Chaouachi Siala
CS 312: Algorithm Analysis
Branch & Bound UPPER =  LOWER = 0.
CS 312: Algorithm Design & Analysis Lecture #34: Branch and Bound Design Options for Solving the TSP: Tight Bounds This work is licensed under a Creative.
CS 312: Algorithm Analysis Lecture #4: Primality Testing, GCD This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License.Creative.
CS 312: Algorithm Design & Analysis Lecture #17: Connectedness in Graphs This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported.
CSCE350 Algorithms and Data Structure Lecture 17 Jianjun Hu Department of Computer Science and Engineering University of South Carolina
CS 312: Algorithm Analysis Lecture #8: Non-Homogeneous Recurrence Relations This work is licensed under a Creative Commons Attribution-Share Alike 3.0.
Design and Analysis of Algorithms - Chapter 111 How to tackle those difficult problems... There are two principal approaches to tackling NP-hard problems.
BackTracking CS335. N-Queens The object is to place queens on a chess board in such as way as no queen can capture another one in a single move –Recall.
CS 312: Algorithm Analysis Lecture #32: Intro. to State-Space Search This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported.
CS 312: Algorithm Design & Analysis Lecture #23: Making Optimal Change with Dynamic Programming Slides by: Eric Ringger, with contributions from Mike Jones,
CS 312: Algorithm Design & Analysis Lecture #12: Average Case Analysis of Quicksort This work is licensed under a Creative Commons Attribution-Share Alike.
CS 312: Algorithm Analysis Lecture #1: Algorithms and Efficiency This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License.Creative.
Computer Science CPSC 322 Lecture 9 (Ch , 3.7.6) Slide 1.
CS 312: Algorithm Design & Analysis Lecture #24: Optimality, Gene Sequence Alignment This work is licensed under a Creative Commons Attribution-Share Alike.
CS 312: Algorithm Design & Analysis Lecture #2: Asymptotic Notation This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported.
CS 312: Algorithm Analysis Lecture #4: Primality Testing, GCD This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License.Creative.
CS 312: Algorithm Design & Analysis Lecture #35: Branch and Bound Design Options: State Spaces Slides by: Eric Ringger, with contributions from Mike Jones,
Lecture 3: Uninformed Search
1 Branch and Bound Searching Strategies Updated: 12/27/2010.
COPING WITH THE LIMITATIONS OF ALGORITHM POWER
CS 312: Algorithm Design & Analysis Lecture #37: A* (cont.); Admissible Heuristics Credit: adapted from slides by Stuart Russell of UC Berkeley. This work.
An Algorithm for the Traveling Salesman Problem John D. C. Little, Katta G. Murty, Dura W. Sweeney, and Caroline Karel 1963 Speaker: Huang Cheng-Kang.
Lecture #9: Introduction to Markov Chain Monte Carlo, part 3
Slides by: Eric Ringger, adapted from slides by Stuart Russell of UC Berkeley. CS 312: Algorithm Design & Analysis Lecture #36: Best-first State- space.
CS 312: Algorithm Analysis Lecture #7: Recurrence Relations a.k.a. Difference Equations Slides by: Eric Ringger, with contributions from Mike Jones, Eric.
CS 312: Algorithm Analysis Lecture #8: Non-Homogeneous Recurrence Relations This work is licensed under a Creative Commons Attribution-Share Alike 3.0.
CS 312: Algorithm Analysis Lecture #33: Branch and Bound, Job Assignment This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported.
CS 312: Algorithm Analysis
CS 312: Algorithm Analysis Lecture #31: Linear Programming: the Simplex Algorithm, part 2 This work is licensed under a Creative Commons Attribution-Share.
CSCE350 Algorithms and Data Structure Lecture 21 Jianjun Hu Department of Computer Science and Engineering University of South Carolina
CS 312: Algorithm Analysis Lecture #31: Linear Programming: the Simplex Algorithm, part 2 This work is licensed under a Creative Commons Attribution-Share.
CS 312: Algorithm Analysis Lecture #4: Primality Testing, GCD This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License.Creative.
Other partial solution strategies. Partial solution algorithms greedy  branch and bound  A*  divide and conquer  dynamic programming.
Branch and Bound Searching Strategies
Adversarial Search 2 (Game Playing)
CS 312: Algorithm Analysis Lecture #9: Recurrence Relations - Change of Variable Slides by: Eric Ringger, with contributions from Mike Jones, Eric Mercer,
CS 312: Algorithm Design & Analysis Lecture #26: 0/1 Knapsack This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License.Creative.
CS 312: Algorithm Design & Analysis Lecture #29: Network Flow and Cuts This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported.
CS 312: Algorithm Analysis Lecture #30: Linear Programming: Intro. to the Simplex Algorithm This work is licensed under a Creative Commons Attribution-Share.
CS 721 Project Implementation of Hypergraph Edge Covering Algorithms By David Leung ( )
The NP class. NP-completeness Lecture2. The NP-class The NP class is a class that contains all the problems that can be decided by a Non-Deterministic.
Brian Williams, Fall 041 Analysis of Uninformed Search Methods Brian C. Williams Sep 21 st, 2004 Slides adapted from: Tomas Lozano Perez,
CS 312: Algorithm Analysis Lecture #27: Network Flow This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License.Creative.
BackTracking CS255.
Branch and Bound.
Graphs Part 2 Adjacency Matrix
Branch and Bound Searching Strategies
Backtracking and Branch-and-Bound
Lecture 4: Tree Search Strategies
Presentation transcript:

CS 312: Algorithm Analysis Lecture #35: Branch and Bound Design Options - State Spaces Slides by: Eric Ringger, with contributions from Mike Jones, Eric Mercer, and Sean Warnick This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License.Creative Commons Attribution-Share Alike 3.0 Unported License

Announcements  Homework #25 due now  Homework #26 optional  Project #7: TSP  We continue discussing ideas today  Early: Wednesday  Due: next Friday

Objectives  Consider an alternate way to structure the state space.  i.e., an alternate way to generate successor states  Provide more options to complete the project.

Review the Ingredients of B&B

Review: Branch and Bound function BandB(v) BSSF  quick-solution(v) // BSSF.cost holds cost Agenda.clear() v.b  bound(v) Agenda.add(v, v.b) while !Agenda.empty() and time remains and BSSF.cost != v.b do u  Agenda.first() Agenda.remove_first() children = generate_children_ascending(u) for each w in children do if ! time remains then break w.b  bound(w) if (w.b < BSSF.cost) then if criterion(w) then BSSF  w Agenda.prune(BSSF.cost) else if partial_criterion(w) then Agenda.add(w, w.b) return BSSF Compute bound when constructing state rather than as separate step.

Review: Branch and Bound function BandB(v) BSSF  quick-solution(v) // BSSF.cost holds cost Agenda.clear() Agenda.add(v, v.b) while !Agenda.empty() and time remains and BSSF.cost != v.b do u  Agenda.first() Agenda.remove_first() children = generate_children_ascending(u) for each w in children do if ! time remains then break if (w.b < BSSF.cost) then if criterion(w) then BSSF  w Agenda.prune(BSSF.cost) else if partial_criterion(w) then Agenda.add(w, w.b) return BSSF Compute bound when constructing state rather than as separate step.

Review: Branch and Bound function BandB(v) BSSF  quick-solution(v) // BSSF.cost holds cost Agenda.clear() Agenda.add(v, v.b) while !Agenda.empty() and time remains and BSSF.cost != v.b do u  Agenda.first() Agenda.remove_first() children = generate_children_ascending(u) for each w in children do if ! time remains then break if (w.b < BSSF.cost) then if criterion(w) then BSSF  w Agenda.prune(BSSF.cost) else if partial_criterion(w) then Agenda.add(w, w.b) return BSSF Apply partial_criterion() when generating children.

Simplify: Branch and Bound function BandB(v) BSSF  quick-solution(v) // BSSF.cost holds cost Agenda.clear() Agenda.add(v, v.b) while !Agenda.empty() and time remains and BSSF.cost != v.b do u  Agenda.first() Agenda.remove_first() children = generate_children_ascending(u) for each w in children do if ! time remains then break if (w.bound < BSSF.cost) then if criterion(w) then BSSF  w Agenda.prune(BSSF.cost) else Agenda.add(w, w.b) return BSSF Apply partial_criterion() when generating children.

Simplify: Branch and Bound function BandB(v) BSSF  quick-solution(v) // BSSF.cost holds cost Agenda.clear() Agenda.add(v, v.b) while !Agenda.empty() and time remains and BSSF.cost != v.b do u  Agenda.first() Agenda.remove_first() children = generate_children_ascending(u) for each w in children do if ! time remains then break if (w.bound < BSSF.cost) then if criterion(w) then BSSF  w Agenda.prune(BSSF.cost) else Agenda.add(w, w.b) return BSSF Use init_state() function. Compute bound as part of initial state.

Simplify: Branch and Bound function BandB() s  init_state() BSSF  quick-solution(s) // BSSF.cost holds cost Agenda.clear() Agenda.add(s, s.bound) while !Agenda.empty() and time remains and BSSF.cost != s.bound do u  Agenda.first() Agenda.remove_first() children = generate_children_ascending(u) for each w in children do if ! time remains then break if (w.bound < BSSF.cost) then if criterion(w) then BSSF  w Agenda.prune(BSSF.cost) else Agenda.add(w, w.b) return BSSF Use init_state() function. Compute bound as part of initial state. Requirement for Proj. #7: Use B&B pseudo-code.

Review: A Bound on TSP Tour

1.Reduce Rows

2. Reduce Columns

Review: Pruning  Under what conditions can a search state be pruned?  Lower bound for state  BSSF (least upper bound)  Could be true when the state is created  Could happen when the BSSF is updated and the agenda is pruned  The state is not feasible  Where feasibility may include any test you might think of:  Already occupied  Cycle among sub-set of cities  No options remaining ……

Focus on State Space function BandB() s  init_state() BSSF  quick-solution(s) // BSSF.cost holds cost Agenda.clear() Agenda.add(s, s.bound) while !Agenda.empty() and time remains and BSSF.cost != s.bound do u  Agenda.first() Agenda.remove_first() children = generate_children_ascending(u) for each w in children do if ! time remains then break if (w.bound < BSSF.cost) then if criterion(w) then BSSF  w Agenda.prune(BSSF.cost) else Agenda.add(w, w.b) return BSSF

Structure of State Space  Recall the structure of the state space from last time?

Review: State Space #1  Generate all children one step away  each child state is generated by including one of the edges leaving city j, where j is the destination of the last edge in the parent state  Pro: Does not include premature cycles. Why not?  Pro: Simple algorithm: pick all neighbors that remain from vertex j, (leave the starting vertex for the end)  Con: On many instances, while searching with B&B, will result in excessively deep agendas. Why?  Can B&B in this state space be optimal? Include edge (j,1) (j,2)(j,3) … (j,N) (i,j)

Structure of State Space  Could we structure the space another way?  How else could we generate children states?

State Space #2 Include edge (i,j)Exclude edge (i,j) Use the same method for representing states computing bounds. New method for generating children: Why can branch and bound in this state space be optimal?

Excluding an Edge What happens to a state’s cost matrix when an edge is excluded? Exclude 4  2

State Space: Strategy #2

Which edge to select?  What strategies for edge selection can you think of?  Idea: try to reduce the size of the part of the state-space you actually need to explore!

0 Try #1: Consider edge (3,2) include (3,2)exclude (3,2) bound = 22bound = 21 Parent: bound = 21 Both children similarly competetive.

Try #2: Consider edge (2,3) include (2,3)exclude (2,3) bound = 21bound = 28 bound = Parent: Left child more likely to be pruned.

Try #3: Consider edge (5,1) include (5,1)exclude (5,1) bound = 30bound = Parent: Right child more likely to be pruned.

State Space so far include (5,1)exclude (5,1) bound = 30bound = 21

Consider edge (2,5) include (2,5)exclude (2,5) bound = 28bound = Parent: Again, right child more likely to be pruned.

Search Space so far include (5,1)exclude (5,1) 3021 include (2,5)exclude (2,5) 2821

Consider edge (3,2) include (3,2)exclude (3,2) bound = 22bound = Parent:

Search Space so far include (5,1)exclude (5,1) 3021 include (2,5)exclude (2,5) 2821 include (3,2) 21 exclude (3,2) 22

Search Space so far include (5,1)exclude (5,1) 3021 include (2,5)exclude (2,5) 2821 include (3,2) 21 exclude (3,2) include (4,3),(1,4)

Summarize: State Space #2  Pick an edge e = (i,j) and generate two children: 1.Include edge e 2.Exclude edge e  One might pick an edge by:  maximizing the difference between the included edge child and the excluded edge child  maximizing the bound on the excluded edge child  minimizing the bound on the included edge child  One must be careful not to create a cycle prematurely  How to prevent? Include edge (i,j) Exclude edge (i,j)

Sizes of State Spaces  Start with Complete Graph

Sizes of State Spaces  Strategy #1  Strategy #2  See ch. 6: DP strategy  n 2 2 n

Conclusions  You have options!  Having some control without sacrificing optimality is important.  You may be able to prune more aggressively without sacrificing optimality.

Assignment  HW #26: Optional  Include-exclude state-space generation  Kill two birds with one stone:  Read the project instructions and lecture notes  Do HW #26 on whiteboard with a partner  Have your “whiteboard experience” for Project #7  Consider your options  Design a B&B algorithm  Work and talk through an example  Read the assigned selection from Russell & Norvig  Use your homework key credentials  Happy General Conference weekend!