Search

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

Outline
• Problem space/ State space
• Exhaustive search
• Depth-first search
• Backtracking
• Branch-and-bound

Search

### Problem Space

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

Search

Example: Shortest path
• 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

Example: 0/1 Knapsack
• 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

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.

Search

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

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

(0,1,0, …, ?)

(0,1,1, …, ?)

Search

State-Space Tree: Shortest Path

(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

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 p

fornext = 1 ton

donp = p

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

thennp = np || next

path(np)

elsereturn

Search

State-Space Tree : 0/1 Knapsack
• 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

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

for each node k adjacent to v

doif notvisited[k]

then depthFirst(k)

Search

0/1 Knapsack: Depth-first 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

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

Search

0/1 Knapsack: Backtracking

{}

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

0/1 Knapsack: Backtracking

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

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-Space Tree with Bound

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

State

bound

Search

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.

Search

0/1 Knapsack: Branch-and-Bound

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

0/1 Knapsack: Branch-and-bound

{} 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