Upload
duongminh
View
219
Download
1
Embed Size (px)
Citation preview
Computer Science and Software Engineering
University of Wisconsin - Platteville
Computer Science and Software Engineering
University of Wisconsin - Platteville
3. Search (Part 1)
CS 3030 Lecture Notes
Yan Shi
UW-Platteville
Read: Textbook Chapter 3.7-3.9,3.12, 4.
Problem Solving as Search
Problem: — Initial state to start
— A description of all possible actions at any state
— Transition model: what each action does
— The goal states
— A path cost function that assign a cost to each path.
Problem solution: an action sequence that leads from the initial state to a goal state.
State Space
The river crossing puzzle
Initial state: PFCG||
Actions: Person can take one item to cross the river
Transition model: fox eats chicken, chicken eats grain if left alone
Goal state: ||PFCG
Path cost function: equal efforts
State space is usually represented as a graph.
Search tree is more often used for problem solving.— All possible paths through a graph.
Can you construct the state space and search tree for the river crossing puzzle?
Search in Search Tree
Start from the initial state (or the goal state)
Expand a state by applying the search actions to that state, generating ALL of its successor states.
These successors are in the next level down of the search tree
The order in which we choose states for expansion is determined by the search strategy— Different strategies result in different behavior
KEY: We want to find the solution while realizing in memory as few as possible of the nodes in the search space.
More Examples
The 8-squares puzzle
— Initial state:
— Goal state:
— Actions: up, down, left, right
Maze:
— Initial state: entrance
— Goal state: exit
— Actions: north, south, east, west
7 2 4
5 6
8 3 1
1 2 3
4 5 6
7 8
A quick review on graph
Graph: G = {V, E}— V: a set of vertices (nodes)— E: a set of edges
Directed graph Path, loop Connected graph and disconnected graph Complete graph Root Tree:
— Root, leaf, parent, child, siblings, ancestors, decedents, branching factor
How to represent a graph?
Adjacency list
— Intuitive
— Less memory for sparse graph
Adjacency matrix
— Faster access: O(1) vs. O(n)
A
BC
E
D
Graph Problem Examples
Konigsberg bridges problem:
— a walk that crosses each bridge once?
Traveling salesperson:
— a route that visits each city once?
Map coloring:
— can map be painted so no two adjacent countries have the same color?
Data-Driven or Goal-Driven Search
Data-driven search:— Start from an initial state and move forward until a
goal is reached— Top-down approach— A.K.A. forward chaining— When initial data is available and goal is not clear
Goal-driven search:— Start at the goal and work back toward a start state— Bottom-up approach— A.K.A. backward chaining— When goal is clear: exit a maze, medical diagnosis
Example: The Towers of Hanoi
Initial State: (123)()()Actions:
Op1: Move disk from peg 1 to peg 2Op2: Move disk from peg 1 to peg 3Op3: Move disk from peg 2 to peg 1Op4: Move disk from peg 2 to peg 3Op5: Move disk from peg 3 to peg 1Op6: Move disk from peg 3 to peg 2
Goal test: ()()(123)Path cost: 1 per step
Goal Tree
A.K.A. and-or tree— Goal: solution
— Subgoal: each step along the way
— And-node: a goals can be achieved only by solving all its subgoals.
— Or-node: a goals can be achieved by solving any of its subgoals.
Leaf nodes are either success nodes or failure nodes.
Properties of Search Methods
Complexity— Time and space
Completeness— Is it guaranteed to find a goal state if one exists?
Optimality (often used to mean admissibility)— Is it guaranteed to find a solution in the quickest time?
Admissibility— Is it guaranteed to find the best solution?
Irrevocability— No backtracking
— Called tentative if there is backtracking
P, NP and NP-hard
In real-world, the search problem can be classified to two classes: P and NP.— class P is the set of all problems for which solutions
with polynomial time behavior have been found.
— class NP is the set of all problems for which solutions with exponential behavior have been found.
If an optimization of the problem cannot be solved in polynomial time, it is called NP-hard.
If a decision problem is both NP and NP-hard, it is NP-complete.
Uninformed Search
Brute-force search (exhaustive search, blind search, generate and test)— Examine every node until it finds a goal
— Simplest form of search
— Assume no additional knowledge other than how to traverse the search tree and detect a leaf and goal node
How many possible states do we have?— TSP of n cities
— Sliding-block puzzle (8-squares)
— Rubik’s cube (3 by 3)
Breadth-First Search
Check all siblings before children;; breadth_first_search: StartState->SUCCESS|FAILURE
Open <- [Start] // states to be considered
Closed <- [] // states that have been considered
while open != []
Next ← first(Open)
Open ← rest(Open) // remove first item from open
if isgoal(Next), return SUCCESS
let Kids = children(Next) - (Open union Closed)
Closed ← Closed union [Next]
Open ← append (Open, Kids)
end-while
return FAILURE
Use a queue
Depth-First Search
Check all decedents before siblings;; depth_first_search: StartState->SUCCESS|FAILURE
Open <- [Start] // states to be considered
Closed <- [] // states that have been considered
while open != []
Next ← first(Open)
Open ← rest(Open) // remove first item from open
if isgoal(Next), return SUCCESS
let Kids = children(Next) - (Open union Closed)
Closed ← Closed union [Next]
Open ← append (Kids, Open)
end-while
return FAILURE
Use a stack
Example: TSP
Appleton Brookfield
Cuba City
Dodgeville
Eau Claire
100
150
180
200150120
240
190
40180
Can we solve TSP using BFS and DFS?
Initial State: ?Actions:
Travel from one city to anotherTransition model:
roadsGoal test:
visit each city exactly once & return to APath cost:
traveling distance
How to order siblings?
Breadth-first vs. Depth-first
BFS DFS
Complexity
Completeness
Optimality
Admissibility
Irrevocability
b is the branching factor of the tree d is the depth of the shallowest goal state reachedm is the depth of the deepest goal state reached
Breadth-first vs. Depth-first
BFS DFS
Complexity Time: O(bd)Space: O(bd)
Time: O(bm)Space: O(bm)
Completeness Yes No
Optimality No No
Admissibility Yes (if no weight) No
Irrevocability Yes Yes
b is the branching factor of the tree d is the depth of the shallowest goal state reachedm is the depth of the deepest goal state reached
Breadth-first vs. Depth-first
When to use which?
Some paths are extremely long
All path are of similar length
All path are of similar length and all lead to a goal state
High branching factor: a state may lead to many different states
Internet search engine?
Variations of BFS and DFS
Uniform-cost search:— Instead of expanding the shallowest node, expand
the node with the smallest path cost.— e.g. Dijkstra’s Algorithm— If all steps are equal, it is the same as BFS— The first goal found is an optimal solution
Depth-limited search:— DFS with depth limit x— Avoid getting stuck in infinitely deep path or loops— will find a solution if it is within the depth limit
Review: Dijkstra’s algorithm
Dijkstra’s algorithm: single source shortest path algorithm
G = (V,E} S = {vertices whose shortest paths from the source is determined} di = best estimate of shortest path to vertex i pi = predecessors
Initialize di and pi, Set S to empty, While there are still vertices in V-S,
— Sort the vertices in V-S according to the current best estimate of their distance from the source,
— Add u, the closest vertex in V-S, to S, — Update all the vertices still in V-S connected to u to a better estimation if
possible
Dijkstra’s algorithm example
1
2
3
4
5
6
7
10
10
5
4
6 1
2
80
0+7=7
0+10=10 7+6=13
7+6+1=14 7+6+8=21
Dijkstra’s algorithm example
1
2
3
4
5
6
7
10
10
5
4
6 1
2
80
0+7=7
0+10=10 7+6=13
7+6+1=14 7+6+1+2=16
Dijkstra’s algorithm example
1
2
3
4
5
6
7
10
10
5
4
6 1
2
80
0+7=7
0+10=10 7+6=13
7+6+1=14 7+6+1+2=16
Depth-First Iterative Deepening
DFID, a.k.a. Iterative Deepening Search or IDS Exhaustive search technique that combines depth-first
with breadth-first search:— repeatedly carrying out depth-limit search on the tree, — starting with a depth-first search limited to a depth of 1,
then a depth-first search of depth 2, 3, and so on, until a goal node is found.
Combines the benefit of BFS that it will always find the shortest-step path and of DFS in the efficiency of memory use.
Avoid the problem of DFS that it may be trapped in infinitely deep path.
Is DFID too time consuming?
It is almost as efficient as DFS and BFS because for most trees, the majority of nodes are in the deepest level— All three approaches spend most of their time
examining these node
For a tree of depth d and with a branching factor of b, the total number of nodes is
1 + b + b^2 + b^3 + . . . + b^d = (1-bd+1)/(1-b) O(bd)
The total # of nodes DFID checks is
(d + 1) + b(d) + b^2 (d-1) + b^3(d-2) + . . . + b^d O(bd)