search. jaruloj chongstitvatanasearch2 outline problem space/ state space exhaustive search...

Search

Jaruloj Chongstitvatana Search 2

Outline

• Problem space/ State space

• Exhaustive search• Depth-first search• Breadth-first search

• Backtracking

• Branch-and-bound

Problem Spaceor State Space


Problem Space

• General problem statement• Given a problem instance P,

find answer A=(a1, a2, …, an) such that

the criteria C(A, P) is satisfied.

• Problem space of P is the set of all possible answers A.


Example: Shortest path

• Given a graph G=(V,E), and nodes u and v, find the shortest path between u and v.

• General problem statement• Given a graph G and nodes u and v,

find the path (u, n1, n2, …, nk, v), and

(u, n1, n2,…, nk, v) is the shortest path between u and v.

• Problem space• Set of all possible path between u and v.

• {(u, n1, n2, …, nk, v)| ni is in V, for 1ik}.


Example: 0/1 Knapsack

• Given a set S of n objects, where the object i has value vi and weight wi , and a knapsack with weight capacity C, find the maximum of value of objects in S which can be put in the knapsack.

• General problem statement• Given vi and wi , for 1 i n ,

find the set K such that for each i in K, 1 i n,

vi is maximum while wi C. iK iK

• Problem space• Any subset of S.


Example: n Queens

• Given an nxn board, find the n squares in the board to put n queens so that no pair can attack.

• General problem statement• Find (p1, p2, …, pn) where pi = (xi, yi) is a

square on the board, where there is no pair (xi, yi) and (xj, yj) such that xi = xj or yi = yj.

• Problem space• A set of any n positions on the board.

Exhaustive Search


Exhaustive Search

• Generate every possible answer• Test each answer with the constraint to find the

correct answer• Inefficient because the number of answers in

the problem space can be exponential.• Examples:

• Shortest path• n! paths to be considered, where n is the number of nodes.

• 0/1 Knapsack• 2n selections, where n is the number of objects.

• n Queens• n2!/n! (n2-n)!


State-Space Tree• Let (a1, a2, …, an) be a possible answer.• Suppose ai is either 0 or 1, for 1 i nใ

(0, ?, …, ?) (1, ?, …, ?)

(?, …, ?)

(0, 0, ?, …, ?) (0, 1, ?, …, ?) (1, 0,?, …, ?) (1, 1, ?, …, ?)

(0,0,0, …, ?) (0,1,1, …, ?)(0,0,1, …, ?) (0,1,0, …, ?)


State-Space Tree: Shortest Path

1

2

3

4

52

-1

1

8

-65 2

2

(1,2) (1,3)

(1)

(1,2,3) (1,2,4) (1,3,4) (1,3,5)

(1,2,3,4) (1,3,4,5)(1,2,3,5) (1,2,4,5)

(1,2,3,4,5)


Generating Possible Paths

• Let {1,2,3, …, n} be a set of nodes and E[i][j] is the weight of the edge between node i and j.

path(p)last = last node in the path pfor next = 1 to n

do np = p if next is not in np and E[last][next] != 0

then np = np || nextpath(np)

else return


State-Space Tree : 0/1 Knapsack

• Given a set of objects o1, …, o5.{ }

{1,2}

{5}{4}{3}{2}{1}

{1,5}{1,4}

{1,2,5}{1,2,3} {1,2,4}

{1,2,3,5}

{1,2,3,4,5}

{1,2,3,4}

{1,3}

{1,2,4,5}

{1,3,4} {1,3,5}

{1,3,4, 5}

{1,4,5}


State-Space Tree : n Queen

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q

Q


Depth-first Search

• Traverse the tree from root until a leaf is reached.

• Then, traverse back up to visited the next unvisited node.

depthFirst(v)visited[v] = 1for each node k adjacent to v

do if not visited[k] then depthFirst(k)


0/1 Knapsack: Depth-first SearchGlobal: maxV=0 maxSack={}

DFknapsack(sack, unchosen)for each object p in unchosen do unchosen=unchosen-{p}

sack=sack U {p}val=evaluate(sack)if unchosen is empty► A leaf is reached.

then maxV=max(maxV, val)if maxV=val then maxSack=sackreturn

else DFknapsack(sack, unchosen) return


Breadth-first Search• Traverse the tree from root until the nodes of

the same depth are all visited.• Then, visited the node in the next level.

breadthFirst(v)Q = empty queueenqueue(Q, v) visited[v] = 1while not empty (Q)

do u = dequeue(Q) for each node k adjacent to u

do if not visited[k] then visited[k] = true

enqueue(Q, k)


0/1 Knapsack: Breadth-first Search

BFknapsack

Q = empty queue maxV=0

sack = { }

unchosen = set of all objects

enqueue(Q, <sack, unchosen>)

while not empty (Q)

do <sack, unchosen> = dequeue(Q)

if unchosen is not empty

then for each object p in unchosen

do enqueue(Q,<sackU{p}, unchosen-{p}>)

else maxV = max(maxV, evaluate(sack))

if maxV=evaluate(sack) then maxSack = sack

Backtracking


Backtracking

• Reduce the search by cutting down some branches in the tree


0/1 Knapsack: Backtracking

object weight value

1 2 5

2 1 4

3 3 8

4 2 7

Capacity = 5

{}0,0

{2}1,4

{4}2,7

{3}3,8

{1}2,5

{1,2}3,9

{1,3}5,13

{1,4}4,12

{1,2,4}5, 16

{1,2,3}6, 17

{2,4}3,11

{2,3}4,12

{2,3,4}6,19

{3,4}5,15

SackCurrent weight, current valueN

ode


0/1 Knapsack: Backtracking

BTknapsack(sack, unchosen)for each object p in unchosen do unchosen=unchosen-{p}

if p can be put in sack then sack = sack U {p}► Backtracking occurs when p cannot be put in sack.

val=evaluate(sack)if unchosen is empty► A leaf is reached.

then maxV=max(maxV, val)maxSack=sackreturn

else BTknapsack(sack, unchosen) return

Branch-and-Bound


Branch-and-bound

• Use for optimization problems

• An optimal solution is a feasible solution with the optimal value of the objective function.

• Search in state-space trees can be pruned by using bound.


State-Space Tree with Bound

Statebound

Statebound

Statebound

Statebound

Statebound

Statebound

Statebound

Statebound

Statebound

Statebound

Statebound


Branch and Bound

From a node N:

• If the bound of N is not better than the current overall bound, terminate the search from N.

• Otherwise, • If N is a leaf node

• If its bound is better than the current overall bound, update the overall bound and terminate the search from N.

• Otherwise, terminate the search from N.

• Otherwise, search each child of N.


0/1 Knapsack: Branch-and-BoundGlobal: OvBound=0BBknapsack(sack, unchosen)

if bound(sack, unchosen)>OvBound► Estimated bound can be better than the overall bound. then for each object p in unchosen

do unchosen=unchosen-{p}if p can be put in sack then sack = sack U {p}► Backtracking occurs when p cannot be put in sack.val=evaluate(sack)

if unchosen is empty► A leaf is reached. then maxV = max(maxV, val)

maxSack = sackOvBound = max(evaluate(sack), OvBound)return

else ► A leaf is not reached.BBknapsack(sack, unchosen)

return


0/1 Knapsack: Estimated bound

• Current value

• available space * best ratio value:space of unchosen objects


0/1 Knapsack: Branch-and-bound

object weight value ratio

1 2 5 2.5

2 1 4 4

3 3 8 2.67

4 2 7 3.5

Capacity = 5

{} 200,0

{2}181,4

{4}192,7

{3}163,8

{1}172,5

{1,2}163,9

{1,3} 135,13

{1,2,4} 165, 16

{2,4}16.33,11

{2,3}15.54,12

Sack estimated boundCurrent weight, current valueN

ode

Overall bound 016

{3,4}155,15

search. jaruloj chongstitvatanasearch2 outline problem space/ state space exhaustive search...

Documents