Breadth First Search (BFS) Algorithm :
Explanation :
This code represents the Breadth-First Search algorithm. Here's a breakdown of
what each part does:
Initialization: It initializes a node with the initial state of the problem and sets
the path cost to 0.
Goal Test: It checks if the initial state is already a goal state. If so, it returns the
solution.
Frontier: It initializes a FIFO queue (first-in, first-out) called frontier with the
initial node.
Explored set: It initializes an empty set called explored to keep track of the
states that have already been explored.
Main Loop: The algorithm runs in a loop until either a solution is found or the
frontier becomes empty.
Expanding nodes: It pops a node from the frontier (FIFO, so it picks the
shallowest node) and adds its state to the explored set.
Goal Test (child): It checks if the popped node is a goal state. If so, it returns
the solution.
Child Nodes Generation: It generates child nodes by applying actions available
in the problem to the current node's state.
Child Nodes Check: It checks if the child node's state is not already explored or
in the frontier. If not, it adds the child node to the frontier.
Here's a brief explanation of each function used:
POP(frontier): Removes and returns the node at the front of the queue.
INSERT(child, frontier): Inserts the child node into the frontier queue.
problem.GOAL-TEST(state): Checks whether the given state is a goal state.
problem.ACTIONS(state): Returns a list of actions that can be executed in the
given state.
CHILD-NODE(problem, node, action): Generates a child node by applying the
given action to the parent node.
This algorithm systematically explores all possible states in a breadth-first
manner until it finds a goal state or exhausts all possibilities without
finding a solution.
Example
The root node is expanded first and then all the successors of the nodes
are expended next, and their successors and so on.
In general, all the nodes at a given depth are expanded in the search three
before any node at next level are expanded.
Mark any node as start(initial) node
explore and traverse un-visited nodes adjacent to starting node
mark nodes as completed and move to next adjacent and un-visited node.
Completeness : yes (if b is finite),the shallowest solution is returned
Time complexity : b+b2+b3+….+bd=O(bd)
time requirement is still a major factor
space complexity : O(bd) (keeps every node in memory)
space is the bigger problem (more than time)
optimal : yes if step costs are all identical or path cost is a nondecreasing
function of the depth of the node.
Example 2:
Steps to solve:
1. 2.
3. 4.
5. 6.
7.
