Search
Download
1 / 29

Search - PowerPoint PPT Presentation


  • 149 Views
  • Uploaded on

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,

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

PowerPoint Slideshow about ' Search' - becka


An Image/Link below is provided (as is) to download presentation

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

Search

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


Outline
Outline

  • Problem space/ State space

  • Exhaustive search

    • Depth-first search

    • Breadth-first search

  • Backtracking

  • Branch-and-bound

Search


Problem space

Problem Space

or State Space


Problem space1
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
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
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
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 search1
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)!

Search


State space tree
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
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
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
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
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
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


Breadth first search
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 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


0 1 knapsack breadth first search
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 pinunchosen

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

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

if maxV=evaluate(sack) thenmaxSack = sack

Search



Backtracking1
Backtracking

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

Search


0 1 knapsack backtracking
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 backtracking1
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 bound1
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-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 bound2
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
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 estimated bound
0/1 Knapsack: Estimated bound

  • Current value

Search


0 1 knapsack branch and bound1
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


ad