1 / 29

# Search - PowerPoint PPT Presentation

Search. www.math.sc.chula.ac.th/~jaruloj/C681/6_BB.ppt. Outline. Problem space/ State space Exhaustive search Depth-first search Breadth-first search Backtracking Branch-and-bound. Problem Space. or State Space. Problem Space. General problem statement Given a problem instance P,

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about ' Search' - becka

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

### Search

www.math.sc.chula.ac.th/~jaruloj/C681/6_BB.ppt

• Problem space/ State space

• Exhaustive search

• Depth-first search

• Backtracking

• Branch-and-bound

Search

### Problem Space

or State 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.

Search

• Given a graph G=(V,E), and nodesu 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 1ik}.

Search

• Given a set S of n objects, where the object i has value viand 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 viand 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.

iK iK

• Problem space

• Any subset of S.

Search

• 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.

Search

### Exhaustive Search

• 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)!

Search

• 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,0,1, …, ?)

(0,1,0, …, ?)

(0,1,1, …, ?)

Search

(1)

8

3

5

2

5

2

(1,2)

(1,3)

1

1

-6

-1

(1,2,3)

(1,2,4)

(1,3,4)

(1,3,5)

2

2

4

(1,2,3,4)

(1,2,3,5)

(1,2,4,5)

(1,3,4,5)

(1,2,3,4,5)

Search

• 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 p

fornext = 1 ton

donp = p

ifnext is not in np and E[last][next] != 0

thennp = np || next

path(np)

elsereturn

Search

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

{ }

{1}

{2}

{3}

{4}

{5}

{1,2}

{1,3}

{1,4}

{1,5}

{1,2,3}

{1,2,4}

{1,2,5}

{1,3,4}

{1,3,5}

{1,4,5}

{1,2,3,4}

{1,2,3,5}

{1,2,4,5}

{1,3,4, 5}

{1,2,3,4,5}

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] = 1

for each node k adjacent to v

doif notvisited[k]

then depthFirst(k)

Search

Global: maxV=0 maxSack={}

DFknapsack(sack, unchosen)

for each object p in unchosen

dounchosen=unchosen-{p}

sack=sack U {p}

val=evaluate(sack)

ifunchosen is empty

► A leaf is reached.

thenmaxV=max(maxV, val)

if maxV=val thenmaxSack=sack

return

else DFknapsack(sack, unchosen)

return

Search

• Traverse the tree from root until the nodes of the same depth are all visited.

• Then, visited the node in the next level.

Q = empty queue

enqueue(Q, v) visited[v] = 1

while not empty (Q)

dou = dequeue(Q)

for each node k adjacent to u

do ifnotvisited[k]

thenvisited[k] = true

enqueue(Q, k)

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 pinunchosen

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

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

if maxV=evaluate(sack) thenmaxSack = sack

Search

### Backtracking

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

Search

{}

0,0

Sack

Current weight, current value

Node

{1}

2,5

{2}

1,4

{3}

3,8

{4}

2,7

{1,2}

3,9

{1,3}

5,13

{1,4}

4,12

{2,3}

4,12

{2,4}

3,11

{3,4}

5,15

{2,3,4}

6,19

{1,2,3}

6, 17

{1,2,4}

5, 16

Capacity = 5

Search

BTknapsack(sack, unchosen)

for each object p in unchosen

dounchosen=unchosen-{p}

ifp can be put in sackthensack = sack U {p}

► Backtracking occurs when p cannot be put in sack.

val=evaluate(sack)

ifunchosen is empty

► A leaf is reached.

thenmaxV=max(maxV, val)

maxSack=sack

return

else BTknapsack(sack, unchosen)

return

Search

### 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.

Search

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

Search

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.

Search

Global: OvBound=0

BBknapsack(sack, unchosen)

if bound(sack, unchosen)>OvBound

► Estimated bound can be better than the overall bound.

then for each object p in unchosen

dounchosen=unchosen-{p}

ifp can be put in sackthensack = sack U {p}

► Backtracking occurs when p cannot be put in sack.

val=evaluate(sack)

ifunchosen is empty

► A leaf is reached.

thenmaxV = max(maxV, val)

maxSack = sack

OvBound = max(evaluate(sack), OvBound)

return

else► A leaf is not reached.

BBknapsack(sack, unchosen)

return

Search

• Current value

Search

{} 20

0,0

Sack estimated bound

Current weight, current value

Node

{1}17

2,5

{2}18

1,4

{3}16

3,8

{4}19

2,7

{1,2}16

3,9

{1,3} 13

5,13

{2,3}15.5

4,12

{2,4}16.3

3,11

{3,4}15

5,15

{1,2,4} 16

5, 16

Overall bound

16

0

Capacity = 5

Search