Table of Content

Introduction......................................................................................................................................1
The Word Ladder Problem...............................................................................................................1
Problem Description and Modeling................................................................................................. 1
Core Search Algorithms...................................................................................................................2
Breadth-First Search (BFS)........................................................................................................2
Depth-First Search (DFS).......................................................................................................... 4
Comparative Analysis......................................................................................................................6
Visualization and Simulation........................................................................................................... 8
Why BFS is Preferred.................................................................................................................... 10
Challenges......................................................................................................................................10
Conclusion..................................................................................................................................... 10
References......................................................................................................................................10
Introduction

Intelligent agents are systems capable of perceiving their environment and taking actions that
maximize their chances of success in achieving specific goals. In artificial intelligence, these
agents are used to automate decision-making processes, optimize solutions, and adapt to complex
problem spaces.

One fundamental use of intelligent agents is in search and pathfinding where the agent is tasked
with discovering the optimal sequence of actions to transform an initial state into a goal state.
Search algorithms form the backbone of these agents, allowing them to efficiently explore
possibilities and reason through large solution spaces.

The Word Ladder Problem

The Word Ladder problem involves transforming a starting word into a goal word by changing
one letter at a time, with each intermediate step being a valid dictionary word. This
transformation can be modeled as a graph where each word is a node, and edges connect words
differing by a single letter.

To solve this, we employ two search algorithms: Breadth-First Search (BFS) and Depth-First
Search (DFS). BFS is optimal for finding the shortest path, while DFS is memory-efficient and
suited for deep exploration. This report compares these strategies based on how an intelligent
agent can use them to find effective word transformations.

Problem Description and Modeling

To design an intelligent agent capable of solving the Word Ladder problem, we first need a
formal description of the environment and the problem parameters. The agent operates in a
well-defined space where it must find a sequence of valid words that transforms a starting word
into a target word by altering one character at a time. This section breaks down the key elements
that make up this problem and how they are represented computationally.

1
Given:

●​ A start word (e.g., "toon")

●​ A target word (e.g., "plea")
●​ A dictionary of valid intermediate words (e.g., {"toon", "poon", "poin", ..., "plea"})

Objective: Find the shortest transformation sequence from the start word to the goal word,
where each intermediate word differs by only one letter and is in the dictionary.

Graph Representation:

●​ Nodes: Valid dictionary words

●​ Edges: Two words are connected if they differ by a single character

Constraints:

●​ All words must be the same length

●​ All words must exist in the dictionary

Environment Characteristics:

●​ Observable: Fully observable (all words and rules are known)

●​ Deterministic: Yes, the outcome of each move is predictable
●​ Static: Environment does not change during computation
●​ Discrete: Finite number of words and transitions

Core Search Algorithms

Breadth-First Search (BFS)

2
BFS is an uninformed search algorithm that explores all neighbors at the present depth before
moving to nodes at the next depth level. It is particularly suitable for scenarios where all actions
have equal cost and the goal is to find the shortest number of steps to reach a solution.

Functioning:

1.​ Initialize a queue with the start word.

2.​ Track visited words to avoid cycles.
3.​ Expand the shallowest node first.
4.​ Stop when the target word is found.

Procedure

In the Word Ladder problem, BFS ensures that the very first time we reach the goal word, we've
done so using the fewest possible transformations. Since BFS explores all words one step away
from the start before considering words two steps away, it guarantees minimal transformations.

Pseudocode:

Example: Start: "toon", Goal: "plea", Dictionary includes intermediate valid transformations like
"poon", "poin", ..., "plea". BFS will find: toon → poon → poin → poie → plie → plea (or
similar minimal path).

3
Advantages:

●​ Guarantees the shortest path (in number of transformations)

●​ Suitable for problems where all moves have equal cost

Limitations:

●​ High memory consumption (due to storing all paths)

●​ Less suitable for very large graphs where branching factor is high

Depth-First Search (DFS)

Definition: DFS explores as far as possible along a branch before backtracking. It is well-suited
for tasks where reaching any solution is acceptable or when exploring deeper reasoning chains is
prioritized over finding the shortest one.

Functioning:

1.​ Start at the root node (start word).

2.​ Recursively explore neighbors.
3.​ Backtrack when no unvisited neighbors remain.
4.​ Track visited paths and limit depth to prevent infinite loops.

4
Procedure

DFS attempts to find a path from the start word to the goal word by going as deep as possible in
one direction. While this can lead to finding a valid path faster in some cases, it is not guaranteed
to be the shortest. The result may vary based on exploration order and depth limits.

Example: Using the same dictionary, DFS might find a path like toon → poon → plon → plea,
depending on neighbor order. However, this path may not be minimal.

Advantages:

●​ Simple to implement
●​ Uses less memory than BFS
●​ Can find solutions faster in favorable graph structures

Limitations:

●​ May not find shortest path

●​ May get stuck in deep paths unless depth is limited
●​ Result depends on search order and depth configuration

5
Comparative Analysis

The two algorithms have their strengths and weaknesses and we will explore those areas in order
for us to make the best choice based on our constraints.

Criterion BFS DFS

Path Optimality Yes Not guaranteed

Memory Usage High Low

Completeness Yes No (without depth limit)

6
 Time Complexity O(N × L × A) O(A^D) (A = alphabet, D = depth)

Space Complexity O(N × L) O(D)

Use Case Fit Best for minimal transformations Best for exploring alternatives

Explanation of Evaluation Criteria:

●​ Path Optimality: BFS always finds the shortest sequence because it explores the
shallowest nodes first, ensuring minimal steps. DFS, on the other hand, might find a valid
path faster, but not necessarily the shortest one.
●​ Memory Usage: BFS requires more memory since it keeps track of all nodes at the
current level (breadth), storing entire paths in a queue. DFS is more memory-efficient as
it goes deep, storing only the current path and backtracking as needed.
●​ Completeness: BFS is complete; it will always find a solution if one exists. DFS,
however, may miss a solution if the depth is not sufficient or if it falls into deep or
infinite branches.
●​ Time Complexity:
○​ BFS: For each word (N), check all letter positions (L), and all 26 possible
replacements (A), leading to O(N × L × A).
○​ DFS: In the worst case, explores A options at each position for D depth levels,
resulting in exponential time O(A^D).
●​ Space Complexity:
○​ BFS stores all visited nodes and full paths in the queue, hence space grows with
the number of nodes and path length → O(N × L).
○​ DFS uses space proportional to the recursion stack depth, which is the maximum
depth D of the path.

7
These distinctions help justify which algorithm is better suited based on the problem constraints
whether optimality, performance, or memory is prioritized.

Visualization and Simulation

A real-time simulation was implemented to visualize the decision-making process of BFS and
DFS agents. At each step:

●​ Current word, neighbors, and decisions were logged to the console

●​ A CSV log was saved for inspection
●​ A graph was plotted using networkx, showing explored paths and the final transformation
sequence

Here is a sample example we tested with implemented algorithm we wrote and we also add the
results to this page too

Start Word: toon

Goal Word: plea
Word Set: {'plie', 'lean', 'plea', 'moon', 'poon', 'soon', 'loon', 'toon', 'plee', 'poin', 'moan', 'poie',
'loan'}

You can see below the various paths each of the algorithms considered before moving to
destination.

8
9
Why BFS is Preferred

In the context of the Word Ladder problem:

●​ All edges have equal cost (one character change)

●​ The goal is to minimize the number of steps (shortest sequence)

Therefore: BFS is preferred as it always finds the shortest path with minimal computation time
and avoids the pitfalls of unnecessary exploration seen in DFS.

DFS is useful when:

●​ The path cost is not uniform

●​ Exploring diverse paths is more valuable than finding the shortest one

Challenges

●​ Large dictionaries increase the state space

●​ BFS memory limitations on large graphs
●​ DFS depth tuning can be tricky

Conclusion

This study explored how intelligent agents can solve the Word Ladder problem using search
strategies. BFS proved more effective for optimal transformation paths, while DFS offered
insight into depth-first reasoning. Visual simulations and real-time logs helped expose internal
decision-making. As a learning model, this exercise mirrors how intelligent agents can be
deployed in problem-solving domains with defined rules and goals.

10
References

1.​ Russell, S., & Norvig, P. (2021). Artificial Intelligence: A Modern Approach (4th ed.).
Pearson. A foundational text in AI, covering intelligent agents, search algorithms, and
decision-making.
2.​ Leiserson, C., Cormen, T., Rivest, R., & Stein, C. (2009). Introduction to Algorithms (3rd
ed.). MIT Press. Comprehensive explanation of algorithmic complexity and techniques
like BFS and DFS.
3.​ Kleinberg, J., & Tardos, É. (2005). Algorithm Design. Pearson. — Includes real-world
applications of graph algorithms and heuristic search strategies.
4.​ https://en.wikipedia.org/wiki/Word_ladder Provides background and history of the Word
Ladder puzzle.
5.​ https://networkx.org/documentation/stable/ Documentation of the Python library used for
graph generation and visualization.
6.​ https://realpython.com/python-queue/ Guides on Python data structures used in BFS and
DFS implementations.

11