1. Lecture 3: Uninformed Search
ICS 270a Winter 2003

2. Summary Uninformed Blind search Breadth-first uniform first
depth-first
Iterative deepening depth-first
Bidirectional
Branch and Bound
Informed Heuristic search (next class)
Greedy search, hill climbing, Heuristics
Important concepts:
Completeness
Time complexity
Space complexity
Quality of solution

3. Graph and Tree notations

4. Search Tree Notation d = Depth S b=2 1 2 G Branching degree, b
b is the number of children of a node
Depth of a node, d
number of branches from root to a node
Arc weight, Cost of a path
n  n’ , n parent node of n’, a child node
Node generation
Node expansion
Search policy:
determines the order of nodes expansion
Two kinds of nodes in the tree
Open Nodes (Fringe)
nodes which are not expanded (i.e., the leaves of the tree)
Closed Nodes
nodes which have already been expanded (internal nodes)
d = Depth 1 2 S
b=2 G

5. Example: Map NavigationS G A B D E C F
S = start, G = goal, other nodes = intermediate states, links = legal transitions

6. Example of a Search TreeD B D E C E
Note: this is the search tree at some particular point in
in the search.

7. Search Method 1: Breadth First Search
(Use the simple heuristic of not generating a child node if that node is a parent to avoid “obvious” loops: this clearly does not avoid all loops and there are other ways to do this)

8. Breadth-First Search

9. Breadth-First-Search (*)
1. Put the start node s on OPEN
2. If OPEN is empty exit with failure.
3. Remove the first node n from OPEN and place it on CLOSED.
4. If n is a goal node, exit successfully with the solution obtained by tracing back pointers from n to s.
5. Otherwise, expand n, generating all its successors attach to them pointers back to n, and put them at the end of OPEN in some order.
Go to step 2.
For Shortest path or uniform cost:
5’ Otherwise, expand n, generating all its successors attach to them pointers back to n, and put them in OPEN in order of shortest cost path.
* This simplified version does not check for loops

10. What is the Complexity of Breadth-First Search?
Time Complexity
assume (worst case) that there is 1 goal leaf at the RHS
so BFS will expand all nodes = 1 + b + b bd = O (bd)
Space Complexity
how many nodes can be in the queue (worst-case)?
at depth d-1 there are bd unexpanded nodes in the Q = O (bd)
d=0
d=1
d=2 G
d=0
d=1
d=2 G

11. Examples of Time and Memory Requirements for Breadth-First Search
Depth of Nodes
Solution Expanded Time Memory
millisecond 100 bytes
seconds 11 kbytes
4 11, seconds 1 megabyte
hours 11 giabytes
years 111 terabytes
Assuming b=10, 1000 nodes/sec, 100 bytes/node

12. Properties of BFS Finds shortest length solution
Generates every node just once
Exponential time
Exponential space

13. Breadth-First Search (BFS) Properties
Solution Length: optimal
Generates every node just once
Search Time: O(Bd)
Memory Required: O(Bd)
Drawback: require exponential space 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

14. Search Method 2: Depth First Search (DFS)B D C E
Here, to avoid repeated states assume we don’t expand any child node which appears already in the path from the root S to the parent. (Again, one could use other strategies) F D G

15. Depth-First Search

17. Depth-First-Search (*)
1. Put the start node s on OPEN
2. If OPEN is empty exit with failure.
3. Remove the first node n from OPEN and place it on CLOSED.
4. If n is a goal node, exit successfully with the solution obtained by tracing back pointers from n to s.
5. Otherwise, expand n, generating all its successors attach to them pointers back to n, and put them at the top of OPEN in some order.
6. Go to step 2.

18. What is the Complexity of Depth-First Search?
Time Complexity
assume (worst case) that there is 1 goal leaf at the RHS
so DFS will expand all nodes =1 + b + b bd = O (bd)
Space Complexity
how many nodes can be in the queue (worst-case)?
at depth l < d we have b-1 nodes
at depth d we have b nodes
total = (d-1)*(b-1) + b = O(bd)
d=0
d=1
d=2 G
d=0
d=1
d=2
d=3
d=4

19. Techniques for Avoiding Repeated StatesB S B C C C S B S
State Space
Example of a Search Tree
Method 1
do not create paths containing cycles (loops)
Method 2
never generate a state generated before
must keep track of all possible states (uses a lot of memory)
e.g., 8-puzzle problem, we have 9! = 362,880 states
Method 1 is most practical, work well on most problems

20. Example, diamond networks

21. Depth-First Search (DFS) Properties
Non-optimal solution path
Incomplete unless there is a depth bound
Reexpansion of nodes,
Exponential time
Linear space

22. Comparing DFS and BFS Same worst-case time Complexity, but
In the worst-case BFS is always better than DFS
Sometime, on the average DFS is better if:
many goals, no loops and no infinite paths
BFS is much worse memory-wise
DFS is linear space
BFS may store the whole search space.
In general
BFS is better if goal is not deep, if infinite paths, if many loops, if small search space
DFS is better if many goals, not many loops,
DFS is much better in terms of memory

23. Search Method 3: Iterative Deepening Search
Basic Idea: every iteration is a DFS with a depth cutoff i
Increment i
this avoids the problem of infinite paths
It avoid space problems
Procedure Iterative deepening DFS
for i = 1 to infinity
while no solution do
DFS from initial state S0 with cutoff I
If found goal state, return solution.
end

24. Iterative Deepening (DFS)
Every iteration is a DFS with a depth cutoff.
Iterative deepening (ID)
i = 1
While no solution, do
DFS from initial state S0 with cutoff i
If found goal, stop and return solution, else, increment cutoff
Comments:
ID implements BFS with DFS
Only one path in memory
BFS at step i may need to keep 2i nodes in OPEN

25. Iterative deepening search

26. Comments on Iterative Deepening Search
Complexity
Space complexity = O(bd)
(since its like depth first search run different times)
Time Complexity
1 + (1+b) + (1 +b+b2) (1 +b+....bd)
= O(bd) (i.e., asymptotically the same as BFS or DFS in the the worst case)
The overhead in repeated searching of the same subtrees is small relative to the overall time
e.g., for b=10, only takes about 11% more time than DFS
A useful practical method
combines
guarantee of finding an optimal solution if one exists (as in BFS)
space efficiency, O(bd) of DFS
But still has problems with loops like DFS

27. Iterative Deepening (DFS)
Time:
BFS time is O(bn)
B is the branching degree
ID is asymptotically like BFS
For b=10 d=5 d=cut-off
DFS = ,…,=111,111
IDS = 123,456
Ratio is

28. Bidirectional Search Idea
simultaneously search forward from S and backwards from G
stop when both “meet in the middle”
need to keep track of the intersection of 2 open sets of nodes
What does searching backwards from G mean
need a way to specify the predecessors of G
this can be difficult,
e.g., predecessors of checkmate in chess?
what if there are multiple goal states?
what if there is only a goal test, no explicit list?
Complexity
time complexity is best: O(2 b(d/2)) = O(b (d/2)), worst: O(bd+1)
memory complexity is the same

29. Bi-Directional Search

30. Bi-Directional Search (continued)

31. Uniform Cost Search Requirement g(successor)(n))  g(n)
Expand lowest-cost OPEN node (g(n))
In BFS g(n) = depth(n)
Requirement
g(successor)(n))  g(n)

32. Uniform cost search DFS Branch and Bound
1. Put the start node s on OPEN
2. If OPEN is empty exit with failure.
3. Remove the first node n from OPEN and place it on CLOSED.
4. If n is a goal node, exit successfully with the solution obtained by tracing back pointers from n to s.
5. Otherwise, expand n, generating all its successors attach to them pointers back to n, and put them at the end of OPEN in order of shortest cost
Go to step 2.
DFS Branch and Bound
hjhjh
At step 4: compute the cost of the solution found and update the upper bound U.
at step 5: expand n, generating all its successors attach to them
pointers back to n, and put in OPEN in order of shortest cost.
Compute cost of paretial path to node and prune if larger than U. .

33. Comparison of Algorithms

34. Summary A review of search
a search space consists of states and operators: it is a graph
a search tree represents a particular exploration of search space
There are various strategies for “uninformed search”
breadth-first
depth-first
iterative deepening
bidirectional search
Uniform cost search
Depth-first branch and bound
Repeated states can lead to infinitely large search trees
we looked at methods for for detecting repeated states
All of the search techniques so far are “blind” in that they do not look at how far away the goal may be: next we will look at informed or heuristic search, which directly tries to minimize the distance to the goal. Example we saw: greedy search