Solving problems by

searching
Course Teacher: Moona
Kanwal

09/04/15

Outline

Well-defined Problems
Solutions (as a sequence of actions).
Examples
Search Trees
Uninformed Search Algorithms

09/04/15

Recall:Problem-Solving

Goal formulation (final state): limits

objectives
Problem formulation (set of states):
actions+states
Search (solution): sequence of actions
Execution (follows states in solution)

09/04/15

Recall:
Well Defined Problems
A problem is defined by four items:

2.

initial state
actions or successor function S(x) = set of

3.

goal test or predicate : S {0, 1} is 1 iff goal

1.

actionstate pairs

state

Explicit: concrete goal

implicit : abstract description of goal

path cost (additive):g, assigns a numeric cost to
a given path.

09/04/15

Well Defined Problems

State-Space

An Initial State, s0 S.
A Set of Operators (or Actions), {Ai|i = 1, 2, . . }

Formally, the state space is the set of states

that can be reached by any sequence of
actions applied to the initial state, e.g.,
S = {s0, . . . ,Ai1s0, . . . ,Ai1Ai2s0, . . . ,Ai1Ai2
Aiks0, . . . }
A path is a particular sequence of actions
applied to the initial state.

09/04/15

Solutions

A solution is a sequence of actions

leading from the initial state to a
goal state
A solution is a path that satisfies
the goal test.
An optimal solution is a solution
with minimal cost.

09/04/15

09/04/15

Example: Romania

On holiday in Romania; currently in Arad.

Flight leaves tomorrow from Bucharest
Formulate goal:

Formulate problem:

be in Bucharest
states: various cities
actions: drive between cities

Find solution:

sequence of cities, e.g., Arad, Sibiu, Fagaras,

Bucharest

09/04/15

Example: Romania

09/04/15

09/04/15

10

09/04/15

11

Vacuum world state space graph

states? integer dirt and robot location

actions? Left, Right, Suck
goal test? no dirt at all locations
path cost? 1 per action

09/04/15

12

09/04/15

13

09/04/15

14

09/04/15

15

Tree search algorithms

Basic idea:
offline, simulated exploration of state
space by generating successors of alreadyexplored states (a.k.a.expanding states)

09/04/15

16

Tree search example

09/04/15

17

Tree search example

09/04/15

18

Tree search example

09/04/15

19

Implementation: general tree

search

09/04/15

20

Implementation: states vs. nodes

A state is a (representation of) a physical configuration

A node is a data structure constituting part of a search tree
includes state, parent node, action, path cost g(x), depth

The Expand function creates new nodes, filling in the various

fields and using the Success or Fn of the problem to create the
corresponding states.

09/04/15

21

09/04/15

22

Search strategies
Time and space complexity are measured in
terms of
b: maximum branching factor of the
search tree
d: depth of the least-cost solution
m: maximum depth of the state space
(may be )

09/04/15

23

09/04/15

24

Uninformed search strategies

Uninformed search strategies use only the
information available in the problem
definition
Breadth-first search
Uniform-cost search
Depth-first search
Depth-limited search
Iterative deepening search

09/04/15

25

Breadth-first search

Expand shallowest unexpanded node

Implementation:

fringe is a FIFO queue, i.e., new successors go at

end

09/04/15

26

Breadth-first search

Expand shallowest unexpanded node

Implementation:

fringe is a FIFO queue, i.e., new successors go

at end

09/04/15

27

Breadth-first search

Expand shallowest unexpanded node

Implementation:

fringe is a FIFO queue, i.e., new successors

go at end

09/04/15

28

Breadth-first search

Expand shallowest unexpanded node

Implementation:

fringe is a FIFO queue, i.e., new successors

go at end

09/04/15

29

09/04/15

30

09/04/15

31

09/04/15

32

09/04/15

33

09/04/15

34

09/04/15

35

09/04/15

36

09/04/15

37

09/04/15

38

09/04/15

39

09/04/15

40

09/04/15

41

09/04/15

42

09/04/15

43

Properties of breadth-first
search

Complete? Yes (if b is finite)

Time? 1+b+b2+b3+ +bd + b(bd-1) = O(bd+1)
Space? O(bd+1) (keeps every node in
memory)
Optimal? Yes (if cost = 1 per step)
Space is the bigger problem (more than
time)

09/04/15

44

Uniform-cost search

Expand least-cost unexpanded node

Implementation:

fringe = queue ordered by path cost

Equivalent to breadth-first if step costs all equal

Complete? Yes, if step cost
Time? # of nodes with g cost of optimal solution,
O(bceiling(C*/ )) where C* is the cost of the optimal
solution
Space? # of nodes with g cost of optimal solution,
O(bceiling(C*/ ))
Optimal? Yes nodes expanded in increasing order
of g(n)

09/04/15

45

09/04/15

46

09/04/15

47

09/04/15

48

09/04/15

49

09/04/15

50

09/04/15

51

09/04/15

52

09/04/15

53

09/04/15

54

09/04/15

55

09/04/15

56

09/04/15

57

09/04/15

58

09/04/15

59

09/04/15

60

09/04/15

61

09/04/15

62

09/04/15

63

09/04/15

64

09/04/15

65

09/04/15

66

09/04/15

67

09/04/15

68

09/04/15

69

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

70

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

71

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

72

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

73

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

74

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

75

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

76

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

77

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

78

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

79

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

80

Depth-first search

Expand deepest unexpanded node

Implementation:

fringe = LIFO queue, i.e., put successors at front

09/04/15

81

09/04/15

82

09/04/15

83

09/04/15

84

09/04/15

85

09/04/15

86

09/04/15

87

09/04/15

88

09/04/15

89

09/04/15

90

09/04/15

91

09/04/15

92

09/04/15

93

Properties of depth-first search

Complete? No: fails in infinite-depth spaces,

spaces with loops

Modify to avoid repeated states along path

complete in finite spaces

Time? O(bm): terrible if m is much larger

than d

but if solutions are dense, may be much faster

than breadth-first

Space? O(bm), i.e., linear space!

Optimal? No

09/04/15

94

Depth-limited search
= depth-first search with depth limit l,
i.e., nodes at depth l have no successors

Recursive implementation:

09/04/15

95

Iterative deepening search

09/04/15

96

Iterative deepening search

09/04/15

97

Iterative deepening search

09/04/15

98

Iterative deepening search

09/04/15

99

Iterative deepening search

09/04/15

100

Iterative deepening search

Number of nodes generated in a depth-limited search to depth

d with branching factor b:
NDLS = b0 + b1 + b2 + + bd-2 + bd-1 + bd

Number of nodes generated in an iterative deepening search

to depth d with branching factor b:
NIDS = (d+1)b0 + d b^1 + (d-1)b^2 + + 3bd-2 +2bd-1 + 1bd

For b = 10, d = 5,
NDLS = 1 + 10 + 100 + 1,000 + 10,000 + 100,000 =
111,111
NIDS = 6 + 50 + 400 + 3,000 + 20,000 + 100,000 =
123,456

Overhead = (123,456 - 111,111)/111,111 = 11%

09/04/15

101

Properties of iterative
deepening search

Complete? Yes

Time? (d+1)b0 + d b1 + (d-1)b2 + +

bd = O(bd)
Space? O(bd)
Optimal? Yes, if step cost = 1

09/04/15

102

Summary of algorithms

09/04/15

103

Repeated states

Failure to detect repeated states can turn a

linear problem into an exponential one!

09/04/15

104

Graph search

09/04/15

105

Summary

Problem formulation usually requires

abstracting away real-world details to define
a state space that can feasibly be explored

Variety of uninformed search strategies

Iterative deepening search uses only linear

space and not much more time than other
uninformed algorithms

09/04/15

106