Problem Solving

State space search

Before an agent can start searching for solutions, a goal must be identified
and a well defined problem must be formulated.
A problem can be defined formally by these components:
• The initial state that the agent starts in.
• A description of the possible actions available to the agent.
• A description of what each action does; the formal name for this is the
transition model.

Together, the initial state, actions, and transition model implicitly define
the state space of the problem—the set of all states reachable from the
initial state by any sequence of actions.
Simple algorithm for any search problem:

Do until a solution is found or the state space is exhausted.

1. Check the current state
2. Execute allowable actions to find the successor states.
3. Pick one of the new states.
4. Check if the new state is a solution state
If it is not, the new state becomes the current state and the process is
repeated.
Real world search problems
Route-finding problems
• GPS-based navigation systems, Google maps
Touring problems
• TSP problem
• VLSI layout problems
• Robot navigation problems
• Internet searching
• Searching paths in metabolic networks in bioinformatics
Search Algorithm Terminologies
• Search: Searching is a step by step procedure to solve a search-problem in a
given search space. A search problem can have three main factors:
– Search Space: Search space represents a set of possible solutions, which a
system may have.
– Start State: It is a state from where agent begins the search.
– Goal test: It is a function which observe the current state and returns
whether the goal state is achieved or not.
• Search tree: A tree representation of search problem is called Search tree. The
root of the search tree is the root node which is corresponding to the initial
state.
• Actions: It gives the description of all the available actions to the agent.
• Transition model: A description of what each action do, can be represented as a
transition model.
• Path Cost: It is a function which assigns a numeric cost to each path.
• Solution: It is an action sequence which leads from the start node to the goal
node.
• Optimal Solution: If a solution has the lowest cost among all solutions.
Properties of Search Algorithms
• Completeness: A search algorithm is said to be complete if it guarantees
to return a solution if at least any solution exists for any random input.

• Optimality: If a solution found for an algorithm is guaranteed to be the

best solution (lowest path cost) among all other solutions, then such a
solution for is said to be an optimal solution.

• Time Complexity: Time complexity is a measure of time for an algorithm

to complete its task.

• Space Complexity: It is the maximum storage space required at any point

during the search, as the complexity of the problem
Types of search algorithms
Uninformed search
• Uninformed search applies a way in which search tree is searched without
any information about the search space like initial state operators and test
for the goal, so it is also called blind search.
• It can be divided into these main types:
1. Breadth-first Search
2. Depth-first Search
3. Depth-limited Search
4. Iterative deepening depth-first search
5. Uniform cost search
6. Bidirectional Search
Informed search or Heuristic search
1. Simple heuristic search
Greedy best-first search
A* search algorithm
2. Memory bounded heuristic
a. Iterative deepening A*(IDA*)
b. Recursive best-first search
c. Simplified memory bounded A*
3. Local search algorithms & optimization problems
a. Hill climbing search
b. simulated annealing search
c. local beam search
d. genetic algorithms
4. Constraint satisfaction search
5. Adversary search
1. Breadth-first Search:
• Breadth-first search is the most common search strategy for traversing a
tree or graph. This algorithm searches breadth wise in a tree or graph, so
it is called breadth-first search.
• BFS algorithm starts searching from the root node of the tree and expands
all successor node at the current level before moving to nodes of next
level.
• S---> A--->B---->C--->D---->G--->H--->E---->F---->I---->K
S---> A--->B---->C--->D---->G--->H--->E---->F---->I---->K
 2. Depth-first Search
• Depth-first search is a recursive algorithm for traversing a tree or graph
data structure.
• It is called the depth-first search because it starts from the root node and
follows each path to its greatest depth node before moving to the next
path.
• It will start searching from root node S, and traverse A, then B, then D and
E, after traversing E, it will backtrack the tree as E has no other successor
and still goal node is not found. After backtracking it will traverse node C
and then G, and here it will terminate as it found goal node.
3. Depth-Limited Search Algorithm
• A depth-limited search algorithm is similar to depth-first search with a
predetermined limit. Depth-limited search can solve the drawback of the
infinite path in the Depth-first search. In this algorithm, the node at the
depth limit will treat as it has no successor nodes further.

• Depth-limited search can be terminated with two Conditions of failure:

• Standard failure value: It indicates that problem does not have any
solution.
• Cutoff failure value: It defines no solution for the problem within a
given depth limit.
Advantages:
• Depth-limited search is Memory efficient.

Disadvantages:
• Depth-limited search also has a disadvantage of incompleteness.
• It may not be optimal if the problem has more than one solution.
4. Iterative deepening depth-first Search
• This algorithm performs depth-first search up to a certain "depth limit",
and it keeps increasing the depth limit after each iteration until the goal
node is found.
• This Search algorithm combines the benefits of Breadth-first search's fast
search and depth-first search's memory efficiency.
• The iterative search algorithm is useful uninformed search when search
space is large, and depth of goal node is unknown.
• 1'st Iteration-----> A
2'nd Iteration----> A, B, C
3'rd Iteration------>A, B, D, E, C, F, G
4'th Iteration------>A, B, D, H, I, E, C, F, K, G
In the fourth iteration, the algorithm will find the goal node.
 Advantages
• IDDFS gives us the hope to find the solution if it exists in the tree.

• IDS is memory-efficient. IDS minimizes the algorithm's memory footprint

by only storing the nodes up to the current depth limit.

• IDS's ability to be utilized for both tree and graph search is its third
benefit. This is due to the fact that IDS is a generic search algorithm that
works on any search space, including a tree or a graph.

Disadvantages
• The time taken is exponential to reach the goal node.

• The main problem with IDDFS is the time and wasted calculations that
take place at each depth.
5. Uniform-cost Search Algorithm:

• Uniform-cost search is a searching algorithm used for traversing a

weighted tree or graph
• The primary goal of the uniform-cost search is to find a path to the goal
node which has the lowest cumulative cost.
• It can be used to solve any graph/tree where the optimal cost is in
demand.
• A uniform-cost search algorithm is implemented by the priority queue.
• It gives maximum priority to the lowest cumulative cost.
Advantages:
• Uniform cost search is optimal because at every state the path with the
least cost is chosen.
Disadvantages:
• It does not care about the number of steps involve in searching and only
concerned about path cost. Due to which this algorithm may be stuck in
an infinite loop.
6. Bidirectional Search Algorithm:

• Bidirectional search algorithm runs two simultaneous searches, one form

initial state called as forward-search and other from goal node called as
backward-search, to find the goal node. Bidirectional search replaces one
single search graph with two small sub-graphs in which one starts the
search from an initial vertex and other starts from goal vertex. The search
stops when these two graphs intersect each other.

• Bidirectional search can use search techniques such as BFS, DFS, DLS, etc.

• In bidirectional search, one should know the goal state in advance.

• In the below search tree, bidirectional search algorithm is applied. This
algorithm divides one graph/tree into two sub-graphs. It starts traversing
from node 1 in the forward direction and starts from goal node 16 in the
backward direction.
• The algorithm terminates at node 9 where two searches meet.
Informed Search Algorithms

Heuristics function:
• Heuristic is a function which is used in Informed Search, and it
finds the most promising path.
• It might not always give the best solution, but it guaranteed to find
a good solution in reasonable time.
Admissibility of the heuristic function is given as:
h(n) <= h*(n)
Here h(n) is heuristic cost, and h*(n) is the estimated cost. Hence
heuristic cost should be less than or equal to the estimated cost.
Pure Heuristic Search:

• Pure heuristic search is the simplest form of heuristic search algorithms. It

expands nodes based on their heuristic value h(n).
• In the informed search we will discuss two main algorithms which are
given below:
• Best First Search Algorithm(Greedy search)
• A* Search Algorithm
1.Best-first Search Algorithm (Greedy Search)

Greedy best-first search algorithm always selects the path which appears best
at that moment. With the help of best-first search, at each step, we can
choose the most promising node.
Best first search algorithm:
• Step 1: Place the starting node into the OPEN list.
• Step 2: If the OPEN list is empty, Stop and return failure.
• Step 3: Remove the node n, from the OPEN list which has the lowest
value of h(n), and places it in the CLOSED list.
• Step 4: Expand the node n, and generate the successors of node n.
• Step 5: Check each successor of node n, and find whether any node is
a goal node or not. If any successor node is goal node, then return
success and terminate the search, else proceed to Step 6.
• Step 6: For each successor node, algorithm checks for evaluation
function f(n), and then check if the node has been in either OPEN or
CLOSED list. If the node has not been in both list, then add it to the
OPEN list.
• Step 7: Return to Step 2.
• Advantages:
– Best first search can switch between BFS and DFS by gaining the
advantages of both the algorithms.
– This algorithm is more efficient than BFS and DFS algorithms.
• Disadvantages:
– It can behave as an unguided depth-first search in the worst case
scenario.
– It can get stuck in a loop as DFS.
– This algorithm is not optimal.
• In this search example, we are using two lists which are OPEN and CLOSED Lists.
Following are the iteration for traversing the above example.
• Expand the nodes of S and put in the CLOSED list
• Initialization: Open [A, B], Closed [S]
• Iteration 1: Open [A], Closed [S, B]
• Iteration 2: Open [E, F, A], Closed [S, B]
: Open [E, A], Closed [S, B, F]
• Iteration 3: Open [I, G, E, A], Closed [S, B, F]
: Open [I, E, A], Closed [S, B, F, G]
• Hence the final solution path will be: S----> B----->F----> G

• Time Complexity: The worst case time complexity of Greedy best first search is
O(bm).
• Space Complexity: The worst case space complexity of Greedy best first search is
O(bm). Where, m is the maximum depth of the search space.
• Complete: Greedy best-first search is also incomplete, even if the given state
space is finite.
• Optimal: Greedy best first search algorithm is not optimal.
2. A* Search Algorithm:
• It uses heuristic function h(n), and cost to reach the node n from the start
state g(n).
• A* search algorithm finds the shortest path through the search space using
the heuristic function.
• This search algorithm expands less search tree and provides optimal result
faster
• In A* search algorithm, we use search heuristic as well as the cost to reach
the node. Hence we can combine both costs as following, and this sum is
called as a fitness number.

• At each point in the search space, only those node is expanded which have
the lowest value of f(n)
Algorithm of A* search:

• Step1: Place the starting node in the OPEN list.

• Step 2: Check if the OPEN list is empty or not, if the list is empty then
return failure and stops.
• Step 3: Select the node from the OPEN list which has the smallest
value of evaluation function (g+h), if node n is goal node then return
success and stop, otherwise
• Step 4: Expand node n and generate all of its successors, and put n into
the closed list. For each successor n', check whether n' is already in the
OPEN or CLOSED list, if not then compute evaluation function for n'
and place into Open list.
• Step 5: Else if node n' is already in OPEN and CLOSED, then it should be
attached to the back pointer which reflects the lowest g(n') value.
• Step 6: Return to Step 2.
Example:
In this example, we will traverse the given graph using the A* algorithm.
The heuristic value of all states is given in the below table so we will
calculate the f(n) of each state using the formula f(n)= g(n) + h(n), where
g(n) is the cost to reach any node from start state.
Here we will use OPEN and CLOSED list.
• Initialization: {(S, 5)}
• Iteration1: {(S--> A, 4), (S-->G, 10)}
• Iteration2: {(S--> A-->C, 4), (S--> A-->B,
7), (S-->G, 10)}
• Iteration3: {(S--> A-->C--->G, 6), (S--> A--
>C--->D, 11), (S--> A-->B, 7), (S-->G, 10)}
• Iteration 4 will give the final result,
as S--->A--->C--->G it provides the
optimal path with cost 6.
Initialization: {(S, 5)}
Iteration1: {(S--> A, 4), (S-->G, 10)}
Iteration2: {(S--> A-->C, 4), (S--> A-->B, 7), (S-->G, 10)}
Iteration3: {(S--> A-->C--->G, 6), (S--> A-->C--->D, 11),
(S--> A-->B, 7), (S-->G, 10)}
Iteration 4 will give the final result, as S--->A--->C---
>G it provides the optimal path with cost 6.
Advantages:
• A* search algorithm is the best algorithm than other search
algorithms.
• A* search algorithm is optimal and complete.
• This algorithm can solve very complex problems.

Disadvantages:
• It does not always produce the shortest path as it mostly
based on heuristics and approximation.
• A* search algorithm has some complexity issues.
• The main drawback of A* is memory requirement as it
keeps all generated nodes in the memory, so it is not
practical for various large-scale problems.
Optimal: A* search algorithm is optimal if it follows below two conditions:

• Admissible: the first condition requires for optimality is that h(n)

should be an admissible heuristic for A* tree search. An admissible
heuristic is optimistic in nature.
• Consistency: Second required condition is consistency for only A*
graph-search.
Path- A → F → G → I → J