Uninformed search

Uninformed Search
Dr. Amit Kumar, Dept of CSE, JUET, Guna

Problem Solving
• Two ways to solve the problem are
– Search based approaches
– Knowledge based approaches

Search based approaches
Used some representation of problem domain, than
simulate what would happen in domain as a consequence
of action and try to find the solution
Simple trial -and -error approach can be applied to solve
the problem
In these approaches, prior knowledge of the problem
domain is not required
Can be easily applied to any real world problem
Use some knowledge to represent the domain, however,
the solution may or may not use domain knowledge
– Uninformed search
» Actions are well defined, does not use any domain knowledge to
choose most likely candidate
– Informed search
» Attempt to choose most likely candidate based on domain
knowledge

Knowledge based approach
• Can be of two types
– Memory or case based approach
• These approaches used some solved problem and then
apply their solution to solve new unknown problem.
• Use a database of that contains pair of problem and solution
• Ex: integration solving
– Rule based approach
• Use many solved problems and domain expert to infer the
knowledge
• Store knowledge in form of rules
• Apply rules to solve new problem
• Ex: Expert System

Problem Solving
Using
Uniformed search

Uninformed search
• These strategies use only the information
available in the problem definition.
– Generate and Test
– Breadth-first search
– Depth-first search
– Depth-limited Iterative deepening search

State space
• Formulate a problem as a state space by showing the
legal problem states, the legal operators/action, and
the initial and goal states .
• A state is defined by the specification of the values of
all attributes of interest in the world
• An operator changes one state into the other; it has a
precondition which is the value of certain attributes
prior to the application of the operator, and a set of
effects, which are the attributes altered by the
operator
• The initial state is where you start
• The goal state is the partial description of the solution

Generate and Test
•The algorithm always picks the first node from state space
for test.
•If the node contains a goal state, the success is returned.
• Otherwise, the successor of the node is generated and
same process is repeated

Generate and Test: Simple Search-1

Cycle formation in Simple Search-1

Generate and Test: Simple Search-2

Cycle formation in Simple Search-2

Generate and Test:
with path information

Few more refinements
• Always pick the first node in the list
• There are two choices regarding addition of
successor nodes to the open
– Add successor nodes to the head of open list
– Add successor nodes to the tail of open list

Breadth First Search (BFS)
• It expands all the states one step away from the initial state, then
expands all states two steps from initial state, then three steps etc.,
until a goal state is reached.
• It expands all nodes at a given depth before expanding any nodes at
a greater depth.
• All nodes at the same level are searched before going to the next
level down.
• We can implement it by using two lists called OPEN and CLOSED.
The OPEN list contains those states that are to be expanded and
CLOSED list keeps track of states already expanded. Here OPEN list
is used as a queue.
• BFS is effective when the search tree has a low branching factor.

BFS illustration
State Space Graph State-Space tree

BFS illustration
Step 1: Initially open contains only one node
corresponding to the source state A.
Step 2: A is removed from open. The node is
expanded, and its children B and C are
generated. They are placed at the back of
open.
Open = A
Close = {}
Open = BC
Close = {A}

Step 3: Node B is removed from open and is
expanded. Its children D, E are generated and
put at the back of open.
Step 4: Node C is removed from open and
is expanded. Its children D and G are
added to the back of open.
Open = C,D,E
Close = AB
Open = D,E,D,G
Close = A,B,C

Step 5: Node D is removed from open. Its
children C and F are generated and added to
the back of open.
Step 6: Node E is removed from open. It
has no children
Open = E, D,G,C,F
Close = A,B,C,D
Open = D,G,C,F
Close = A,B,C,D,E

Step 7: D is expanded, B and F are put in OPEN. Step 8: G is selected for expansion. It is
found to be a goal node. So the algorithm
returns the path A C G by following the
parent pointers of the node
corresponding to G. The algorithm
terminates.
Open = C,F,B,F
Close = A,B,C,D,E,G
Open = G,C,F,B,F
Close = A,B,C,D,E,D

Algorithm (BFS)
Input: Two states in the state space START and GOAL
Local Variables: OPEN, CLOSED, STATE-X, SUCCS
Output: Yes or No
Method:
Initially OPEN list contains a START node and CLOSED list is empty;
Found = false;
While (OPEN ≠empty and Found = false)
Do {
Remove the first state from OPEN and call it STATE-X;
Put STATE-X in the front of CLOSED list;
If STATE-X = GOAL
then Found = true

else
{
-perform EXPAND operation on STATE-X,
producing a list of SUCCESSORS;
-Remove from successors those states, if any,
that are in the CLOSED list;
-Append SUCCESSORS at the end of the OPEN
list/*queue*/
}
} /* end while */
If Found = true
then return Yes
else
return No and Stop

Breadth First Search
• Advantages of Breadth First Search
– Finds the path of minimal length to the goal.
– BFS can work even in trees that are infinitely deep.
• Disadvantages of Breadth First Search
– Requires the generation and storage of a tree
whose size is exponential

Depth-First Search
• In depth-first search we go as far down as possible into
the search tree / graph before backing up and trying
alternatives.
• It works by always generating a descendent of the most
recently expanded node until some depth cut off is
reached and then backtracks to next most recently
expanded node and generates one of its descendants.
• So only path of nodes from the initial node to the
current node is stored in order to execute the algorithm.

• Again use two lists called OPEN and
CLOSED with the same conventions explained
earlier.
• Here OPEN list is used as a stack.
• If we discover that first element of OPEN is
the Goal state, then search terminates
successfully.

DFS illustration
State Space Graph State-Space tree

DFS illustration
Step 1: Initially open contains only one node
corresponding to the source state A.
Step 2: A is removed from open. The
node A is expanded, and its children B
and C are generated. They are placed at
the front of open.
Open = A
Close = {}
Open = BC
Close = {A}

Step 3: Node B is removed from open and is
expanded. Its children D, E are generated and
put at the front of open.
Step 4: Node D is removed from open and
is expanded. Its children C and F are
added to the front of open.
Open = D,E,C
Close = AB
Open = C,F,E,C
Close = A,B,D

Step 5: Node C is removed from open. Its
children G and F is added to the front of open.
Step 6: Node G is expanded and found to
be a goal node. The solution path A-B-D-
C-G is returned and the algorithm
terminates.
Open = G,F,E,C
Close = A,B,D,C
Open = F,E,C
Close = A,B,D,C,G

Algorithm (DFS)
Input: Two states in the state space, START and GOAL
LOCAL Variables: OPEN, CLOSED State-X, SUCCESSORS
Output: Yes or No
• Method
Form a stack consisting of START and call it OPEN list.
Initially set CLOSED list as empty; Found = false;
While (OPEN ≠empty and Found = false)
DO
{
Remove the first state from OPEN and call it State-X;
Put State-X in the front of CLOSED list;
If State-X= GOAL,
then Found = true

else
{
-perform EXPAND operation on STATE-X, producing a list of
SUCCESSORS;
-Remove from successors those states, if any, that are in the
CLOSED list;
-Insert SUCCESSORS in the front of the OPEN list /* Stack */
}
}/* end while */
If Found = true
then return yes
else
return No

Depth First Search
Advantages of Depth First Search
– It require less memory as it only stores a single
path from the root to leaf node along with the
remaining unexpanded siblings for each node on
the path.
• Disadvantages of depth First Search
– It may trapped in a blind alley because it may
follow a single, unfruitful path for a very long time
before the path terminates in a state that has no
successors.

Issues with BFS and DFS
BFS goes level by level, but requires more space. The space required by DFS is O(d)
where d is depth of tree, but space required by BFS is O(n) where n is number of
nodes in tree.
DFS : The problem with this approach is, if there is a node close to root, but not in first
few subtrees explored by DFS, then DFS reaches that node very late. Also, DFS may not
find shortest path to a node (in terms of number of edges).

Depth First Iterative Deepening (DFID)
• It suffers neither the drawbacks of BFS nor of DFS on trees
• It takes advantages of both the strategies.
• Since DFID expands all nodes at a given depth before
expanding any nodes at greater depth, it is guaranteed to find a
shortest -length (path) solution from initial state to goal state.
• At any given time, it is performing a DFS and never searches
deeper than depth ‘d’. Hence, it uses same space as DFS.
• Disadvantage of DFID is that it performs wasted computation
prior to reaching the goal depth.Dr. Amit Kumar, Dept of CSE, JUET, Guna

Algorithm (DFID)
Initialize d = 1 /* depth of search tree */ , Found = false
While (Found = false)
DO {
perform a depth first search from start to depth d.
if goal state is obtained
then Found = true
else
discarding the nodes generated in the search of depth d
d = d + 1
}/* end while */
Report the solution
Stop

Iterative deepening search L=0

Iterative Deepening Search L=3

Comparison of algorithm
• completeness: does it always find a solution if
one exists?
• time complexity: number of nodes generated
• space complexity: maximum number of nodes in
memory
• optimality: does it always find a least-cost
solution?

Depth of the tree

Comparison of BFS, DFS and DFID
Here, B represent the branching factor and d represent the depth of the tree

Uninformed search

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Uninformed search

Similar to Uninformed search (20)

More from Amit Kumar Rathi

More from Amit Kumar Rathi (20)

Recently uploaded

Recently uploaded (20)

Uninformed search