PROBLEM SOLVING State Space Search

THROUGH SEARCH Depth First Search

Breadth first search
METHODS
INTRODUCTION
In the field of Artificial Intelligence (AI), problem-solving is one
of the core concepts. Search algorithms play a fundamental role
in solving a wide range of problems by systematically exploring
possible solutions to find an optimal or acceptable one. In Artificial
Intelligence: A Modern Approach by Russell and Norvig,
search methods are introduced as techniques for navigating
through a problem space—a set of possible configurations of a
problem defined by the initial state, goal state, and operators
(or actions) that move from one state to another.
SEARCH ALGORITHMS
Search algorithms can be categorized into two broad types:
Uninformed (or Blind) Search: No information beyond the
problem's definition is available.
Informed (or Heuristic) Search: Utilizes domain-specific
knowledge or heuristics to guide the search more efficiently.
we will focus on uninformed search methods, specifically
Depth-First Search (DFS) and Breadth-First Search (BFS), as
examples of state space search.
STATE SPACE SEARCH
A state space is a formal representation of all possible configurations
(states) of a problem, where each state represents a possible solution or
partial solution. A state space is commonly represented by a search tree
or graph. Each node in the tree represents a state, and each edge
represents an action that transitions from one state to another.
Components of a State Space:
Initial State: The state at which the search begins.
Goal State: The desired final state or condition.
Successor Function: Defines possible actions and transitions from one
state to another.
Cost Function (Optional): The cost incurred in transitioning from one
state to another.
DEPTH-FIRST SEARCH (DFS)
Depth-First Search (DFS) is an uninformed search strategy where the
search tree is expanded by exploring one branch as deep as possible
before backtracking and trying alternative branches. DFS uses a stack
(either explicit or recursive) to keep track of the path being explored.
Key Characteristics:
Search Strategy: DFS follows the "LIFO" (Last In, First Out)
principle for the nodes, meaning it explores the most recently generated
node first.
Space Complexity: O(bm), where:
 b is the branching factor (maximum number of successors at any node),
 m is the maximum depth of the search tree. DFS has a relatively low memory
requirement because it only stores the current path and unexplored siblings.
DEPTH-FIRST SEARCH (DFS)
Time Complexity: O(b^m), which is potentially high because DFS
may explore large portions of the tree.
Completeness: DFS is incomplete if it follows infinite paths (e.g.,
in problems with cycles or infinite trees). However, it can be
complete if the search is limited by a predefined depth.
Optimality: DFS is not optimal because it does not necessarily
find the least-cost path to the goal.
DEPTH-FIRST SEARCH (DFS)
Algorithm:
Start at the initial state and explore the first child node.
If the child node is the goal state, terminate and return the path.
If not, recursively explore the next child.
If a dead-end (no successors) is reached, backtrack and try unexplored
siblings.
Repeat the process until the goal is found or all nodes have been explored.
Example:
Consider a simple tree structure with nodes. DFS will explore the deepest
node in the tree before moving to adjacent nodes, potentially resulting in
long backtracking if it chooses the wrong path early.
DEPTH-FIRST SEARCH (DFS)
BREADTH-FIRST SEARCH (BFS)

Breadth-First Search (BFS) is an uninformed search algorithm

that explores all nodes at the current depth level before moving on
to nodes at the next depth level. It uses a queue to keep track of the
frontier, ensuring that the shallowest nodes are expanded first.
Key Characteristics:
Search Strategy: BFS follows the "FIFO" (First In, First Out)
principle, meaning it explores nodes in the order they were
discovered, layer by layer.
Space Complexity: O(b^d), where:
 b is the branching factor,
 d is the depth of the shallowest goal node. BFS requires significant memory to
store all nodes at a given depth, making it less memory efficient than DFS.
BREADTH-FIRST SEARCH
(BFS)
Time Complexity: O(b^d), where d is the depth of the solution.
BFS systematically explores all possible paths of length d or less.
Completeness: BFS is complete, meaning it is guaranteed to find
a solution if one exists, assuming the branching factor is finite.
Optimality: BFS is optimal if all actions have the same cost (or no
cost function is provided), as it finds the shallowest solution.
BREADTH-FIRST SEARCH
(BFS)
Algorithm:
Start at the initial state and expand all child nodes at depth 1.
For each child, add it to the queue if it hasn't been explored.
Expand the next node in the queue.
If a goal state is found, return the path.
Continue expanding nodes level by level until the goal is found or the
queue is empty.
Example:
In the same tree structure as DFS, BFS explores all nodes at each depth
level before moving deeper, ensuring that the shallowest path to the goal is
found.
BREADTH-FIRST SEARCH
(BFS)
Comparison of DFS and BFS

Characteristic DFS BFS

Space Complexity O(bm) O(b^d)
Time Complexity O(b^d) O(b^d)
Incomplete (unless depth-
Completeness Complete
limited)
Optimality Not optimal Optimal (for uniform cost)
Memory Usage Low High
Best for deep solutions or Best for finding shallowest
Use Cases
when memory is limited solution
Comparison of DFS and BFS
Both DFS and BFS are fundamental search techniques in problem-
solving within the AI domain. DFS is more memory-efficient but can
get stuck in deep or infinite paths, while BFS guarantees finding
the shortest solution but requires significantly more memory. The
choice of algorithm depends on the specific problem and
constraints such as the depth of the solution, available memory,
and whether optimality is required.
These foundational search techniques form the basis for more
advanced algorithms such as A*, greedy best-first search, and
other heuristic-based searches that make use of domain-specific
knowledge to improve efficiency. Understanding DFS and BFS is
crucial before diving into these more complex strategies.