branch & bound - vidyarthiplus

38
Branch & Bound

Upload: others

Post on 24-Oct-2021

9 views

Category:

Documents


0 download

TRANSCRIPT

Page 1: Branch & Bound - Vidyarthiplus

Branch & Bound

Page 2: Branch & Bound - Vidyarthiplus

Branch and Bound

Backtracking is effective for subset or permutationproblems.

Backtracking is not good for optimization problems.

This drawback is rectified by using Branch And Boundtechnique.

Branch And Bound is applicable for only optimizationproblems.

Branch and Bound also uses bounding function similar to backtracking.

Page 3: Branch & Bound - Vidyarthiplus

State Space :-

All paths from the root to other nodes

define the state space of the problem.

Solution Space :-

All paths from the root to solution states

define the solution space of the problem.

Terminology of tree organization

Page 4: Branch & Bound - Vidyarthiplus

1

3418502

8 13 193

5 7 1210 15 17 2321 26 28 3331 37 39 4442 47 9 5553 58 60 6563

4 6 119 14 16 2220 25 27 3230 36 38 4341 46 48 5452 57 59 6462

29 35 4024 51 56 6145

X1=1

X1=2 X1=3X1=4

2 3 4 1 3 41 2 4 1 2 3

3 4 2 4 2 3 3 4 1 4 1 3 2 4 1 4 1 2 2 3 1 3 1 2

4 3 4 2 3 2 4 3 4 1 3 1 4 2 4 1 2 1 3 2 3 1 2 1

x2=

x3=

x4=

Tree organization of the 4-queens solution space. Nodes are numbered as in depth

first search.

Ex :-

Page 5: Branch & Bound - Vidyarthiplus

Problem state :-

Each node in the tree is a problem

state.

Ex:-

and so on1 2 18

Page 6: Branch & Bound - Vidyarthiplus

Solution States :-

These are those problem

states S for which the path from the root

to S define a tuple in the solution space.

Ex:-

and so on5 7 1210 15 17 21

Page 7: Branch & Bound - Vidyarthiplus

– A node which has been generated and all of whose

children have not yet been generated is called a live

node.

– The live node whose children are currently being

generated is called E-node ( Expanding node ).

– A dead node is a generated node which can not to be

expanded further or all of whose children have been

generated.

Page 8: Branch & Bound - Vidyarthiplus

Branch And Bound

Nodes will be expanded in three ways.• Search the tree using a breadth-first search

(FIFO branch and bound).

• Search the tree as in a BFS, but replace the FIFO queue

with a stack (LIFO branch and bound).

• Replace the FIFO queue with a priority queue

(Least-Cost (or max priority) branch and bound).

Page 9: Branch & Bound - Vidyarthiplus

• Least-cost branch and bound directs the search

to the parts which most likely to contain the answer.

Page 10: Branch & Bound - Vidyarthiplus

Ex:- 4 – Queens Problem

FIFO Branch And Bound Algorithm

Page 11: Branch & Bound - Vidyarthiplus

9 11 14 16 30 32 36 38 52 54 57 59

3 8 13 19 24 29 35 40 45 51 56 61

2 18 34 50

1

31

Answer node

2 3 45

6 7 8 9 1011 12

13 14 15 16 17

18 19 20 21 22 23 24 25 26 27 28 29

30

Portion of 4 – queens state space tree

generated by FIFO branch and bound1

2 3 4 1 3 4 1 2 4 12

3

x1=12

3 4

Page 12: Branch & Bound - Vidyarthiplus

In this case backtracking method is

superior than branch and bound method.

Page 13: Branch & Bound - Vidyarthiplus

Least Cost ( LC) search :-

• In both FIFO and LIFO branch and bound the selection

rule for the next E-node does not give any preference to

a node that has a very good chance of getting an answer

node quickly.

• In the above example when node 30 is generated, it

should have become obvious that this node will lead to

an answer node in one move.

• However , the FIFO rule first requires the expansion of

all live nodes generated before node 30 was expanded.

Page 14: Branch & Bound - Vidyarthiplus

• The search for an answer node can be speeded by using

an “intelligent “ ranking function c (.) for live nodes.

• The next E-node is selected on the basis of this ranking

function.

• If we use ranking function that assigns node 30 a better

rank than all other live nodes , then node 30 will become

the E-node following node 29.

^

Page 15: Branch & Bound - Vidyarthiplus

• The ideal way to assign ranks will be on the basis of the additional effort ( cost) needed to reach an answer node from the live node.

For any node x, this could be

1) The number of nodes in the subtree x that need to be generated before an answer node is generated.

OR

2) The number of levels in the subtree x that need to be

generated to get an answer node.

Using cost measure 2,

In the above fig. the cost of the root is 4 ( node 31 is four levels from node 1) .

Page 16: Branch & Bound - Vidyarthiplus

The difficulty with cost functions is that computing the

cost of the node usually involves a search of the subtree

x for an answer node.

Hence , by the time the cost of a node is determined ,

that subtree has been searched and there is no need to

explore x again. For this reason , search algorithms

usually rank nodes only on the basis of an estimated

cost g( . ) .^

Page 17: Branch & Bound - Vidyarthiplus

Let g(x) be an estimate of the additional cost needed to

reach an answer node from x.

Then , node x is assigned a rank using a function c(.) such

that

c(.) = h(x) + g(x)

where

h(x) is the cost of reaching x from the root

^

^

^ ^

Page 18: Branch & Bound - Vidyarthiplus

Actual cost function c(.) is defined as follows:

if x is an answer node , then c(x) is the cost of reaching x from the root of the state space tree.

if x is not an answer node , then c(x)=∞, it means that subtree x contains no answer node.

otherwise c(x) equal to the cost of a minimum costnode in the subtree x.

c(.) is an approximation to c(.)^

Page 19: Branch & Bound - Vidyarthiplus

Ex:- The 15- puzzle

9

5 6 7

1 2 3

12

13 14 15

10 11

4

8

Goal arrangement

1 2 3

65 8

9 10 117

1213 14 15

4

An arrangement

Page 20: Branch & Bound - Vidyarthiplus

1 2 3 4

5 6 8

9 7

13 14 15

10 11

12

9

1 2

3

4

5 6

7

8

9 10 11

1213 14 15

1 2 3 4

5 6 7 8

1 2 3 4

5 8

1 2 3 4

665 8

9 10 117

1213 14 15 1213 14 15 1213 14 15

10 11 9 10 117

up

goal

right

left

down

1 2

3

4

5 6

7

8

9 10 11

1213 14 15

right left

1 2

3

4

5 6

7

8

9 10 11

1213 14 15

up

1 2 3

465 8

9 10 117

1213 14 15

down

1 2 3 4

65 8

9 10

11

7

1213 14 15

right

9

5 6 7 8

1 2 3 4

1213 14 15

10 11

down

9

5 6 7 8

1 2 3 4

1213 14

1510 11

left

9

5 6 7 8

1 2 3 4

1213 14 15

10 11

up

downleft

5 8

1

2

3 4

6

1213 14 15

9 10 117

5 8

1 2 3 4

6

1213 14 15

9 10 117

58

1 2 34

6

1213 14 15

9

10

117

down

1 2

3

4

5 6

79 10

13 14 15

11

12

8

left updown

downdown left left

1 2 3

65 8

9 10 117

1213 14 15

4

9

5 6 7

1 2 3

1213 14 15

10 11

4

89

5 6 7

1 2 3

12

13 14 15

10 11

4

8

1 2

3

4

5

6

7

8

9 10 11

1213 14 15

1 2

3

4

5 6

7

8

9 10 11

1213 14 15

1 2 3 4

65 8

9 10

11

7 12

14 15

1 2 3

65 8

9 10

11

7

1214 15

4

543

2

6 7 8 9 10 11 12 13 1415

16 19 22 23

2118 2017

1

Page 21: Branch & Bound - Vidyarthiplus

A FIFO or LIFO search always generates the state space tree by

levels.

What we need is more “intelligent” search method .

We can associate a cost c(x) with each node x in the state space

tree.

The cost c(x) is the length of a path from the root to a nearest goal

node( if any ) in the subtree with root x.

Thus in the above fig c(1)=c(4)=c(10)=c(23)=3.

When such a cost function is available, a very efficient search can

be carried out.

In this search strategy , the only nodes to become E-nodes are

nodes on the path from the root to a nearest goal node.

Page 22: Branch & Bound - Vidyarthiplus

Unfortunately, this is an impractical.

We can only compute estimate c(x) of c(x). we can write

c(x)=f(x) +g(x), where f(x) is the length of the path from

the root to node 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

g( x ) = number of nonblank tiles not in their goal

position.

^

^ ^

^

^

^

Page 23: Branch & Bound - Vidyarthiplus

Control Abstraction of LC-Search:-

Algorithm LCSearch( t )

// search tree t for answer node

{

if *t is an answer node then output *t and return;

E=t // E-node

repeat

{

for each child x of E do

{

if x is an answer node then output the path from x to t and return;

Add( x ); // x is a new live node

( x ->parent )=E // pointer for path to root

}

Page 24: Branch & Bound - Vidyarthiplus

if there are no more live nodes then

{

write(“ No answer node “);

return;

}

E=Least();

} until ( false )

}

• ( x ->parent )=E is to print answer path.

Page 25: Branch & Bound - Vidyarthiplus

Bounding:- The bounding functions are used to avoid the generation of sub

trees that do not contain the answer nodes. In bounding upper and

lower bounds are generated at each node.

A cost function c(.) such that c (x)<=c(x) is used to provide the lower

bounds on solutions obtainable from any node x.

If upper is an upper bound on the cost of a minimum cost solution,

then all live nodes x with c (x) >upper can be killed.

upper is updated whenever a child is generated.

^

^

^

Page 26: Branch & Bound - Vidyarthiplus

Job sequencing with deadlines• The objective of this problem is to select a subset j of n

jobs such that all jobs in j can be completed by their

deadlines and the penalty incurred is minimum among all

possible subsets j. such a j is optimal.

Page 27: Branch & Bound - Vidyarthiplus

Ex:- let n=4Job index pi di ti

1 5 1 1

2 10 3 2

3 6 2 1

4 3 1 1

The solution space for this instance consists of all possible subsets of

the job index set (1,2,3,4 ).

This space can be organized into a tree in two ways .

1. Using fixed size tuple formulation.

2.Using variable size tuple formulation.

Page 28: Branch & Bound - Vidyarthiplus

1

2

3 4

5

6 7

12 1413

8

9 10

15

11

X1=1 X1=2 X1=3X1=4

X2=2X2=3

X2=4

X3=3 X3=4 X3=4

X2=3 X2=4 X2=4

X3=4

C =0^

C =0

C =0

C =10

C =5 C =15 C =21

C =15

C =11

C =5

^

^^

^

^^

^^^

U =19

U =24

U =14U =18

U =21

U =9

U =13U =8

U =11U =15

C =8

Page 29: Branch & Bound - Vidyarthiplus

The above fig corresponds to the variable tuple size

formulation.

Square nodes represent infeasible subsets.

All nonsquare nodes are answer nodes.

Node 9 represents an optimal solution and is the only

minimum-cost answer node. For this node j=(2,3) and

the penalty ( cost ) is 8.

Page 30: Branch & Bound - Vidyarthiplus

A cost function c() for the above solution space can be

defined as

• For any circular node x, c(x) is the minimum penalty

corresponding to any node in the subtree with root x.

• The value of c(x)=∞ for a square node.

In the above fig c(3)=8 , c(2)=9 , and c(1)=8 etc.

Clearly c(1) is the penalty corresponding to an optimal

selection j.

Page 31: Branch & Bound - Vidyarthiplus

4 5 6 7

2 3

1

9 10 11 12 13 14 15

19 21 22 23 25 26 27 28 29 30 31

24

0

24

0

24

0

X1=1 X1=0

X2=1 X2=0 X2=0X2=1

X3=1X3=1 X3=1 X3=1 X3=0X3=0X3=0

X4=0X4=1

X3=0

Job sequencing with deadlines

Fixed size tuple formulation

Page 32: Branch & Bound - Vidyarthiplus

FIFO Branch and Bound

Refer page no.391

Page 33: Branch & Bound - Vidyarthiplus

LIFO Branch and Bound

Do it yourself.

Page 34: Branch & Bound - Vidyarthiplus

LC Branch and Bound

Refer page no.392

Page 35: Branch & Bound - Vidyarthiplus

0/1 Knapsack Problem Generally Branch and Bound will minimize the objective

function.

The 0/1 knapsack problem is a maximization problem.

This difficulty can be avoided by replacing the objective

function ∑ pixi by - ∑ pixi .

Page 36: Branch & Bound - Vidyarthiplus

Note:

1. All live nodes with c(x) > upper can be

killed when they are about to become

E-nodes .

^

^

Page 37: Branch & Bound - Vidyarthiplus

1

2 3

7

8 9

4

6

5

-38-32

-38-32

-38-32

-38-32 -38

-38

-38-38

-20-20

-32-22

-22-36

Upper number = c

Lower number = u

^LC Branch and Bound Solution

kAnswer node

EX:- n=4, ( p1,p2,p3,p4 )= (10,10,12,18 )

( w1,w2,w3,w4 ) = ( 2,4,6,9 ), m=15

Process: The calculation of U and C is as

follows.

U(1) - Scan through the objects from left to

right and put into the knapsack until

the first object that does not fit is

encontered.

C(1) – Similar to U(1) except that it also

considers a fraction of the first object

that does not fit the knapsack.

Continue this process until an answer node is

found.

^

^

Page 38: Branch & Bound - Vidyarthiplus

FIFO Branch and Bound

1

23

9

12 13

4

8

5

-38-32

-38-32

-38-32

-38-32 -38

-38

-38-38

-20-20

-32-27

-22-36

6 7

10 11

-32-27

k

-28-28

Upper number = c

Lower number = u

^

Answer node