
Explore pathfinding algorithms for finding a path from A to B on maps and graphs, enabling robots to avoid obstacles and find shortest routes, implemented from scratch in Python.
Explore robotic path finding by modeling maps as discrete grids or continuous graphs, defining nodes, obstacles, and adjacency, and visualizing and solving paths with an urgency matrix.
Explore pathfinding with a Jupyter notebook by building discrete and continuous maps, adjacency matrices, and a 20 by 20 grid with obstacles, beginning with depth-first search.
Explores the depth-first search algorithm, showing how DFS traverses nodes by depth to build a path to a target and discusses trade-offs between speed and optimality.
Learn depth-first search (dfs) for traversing graphs, comparing recursive and iterative implementations, and using a stack to print all nodes or stop when a target node is found.
Implement a DFS (depth-first search) in Python to find a path between two nodes, using a stack and a discovered set, expanding neighbors and preparing for target-path extraction.
Explore python implementation – part 2 for path finding with depth-first and breadth-first search, returning the path, tracking costs, and validating node comparisons.
Explore the intuition and implementation of breadth-first search, contrast with dfs, and understand when bfs is optimal for constant-cost steps, including a python queue example.
Learn theory and implementation of the A* path finding algorithm. Use a priority queue to select nodes by estimated cost g(n)+h(n), with Manhattan or Euclidean heuristics, and compare to DFS/BFS.
Explore graph traversal algorithms on discrete and continuous maps using dfs and bfs, compare path costs, and apply a distance-based cost in A*, achieving better solutions.
We conclude the course by presenting three pathfinding algorithms with a consistent structure, linking intuition and pseudocode to Python or Java, and inviting feedback for future AI and robotics courses.
In this course, we will discover and implement three main artificial intelligence algorithms for finding paths in grids, graphs or trees.
We will implement:
The depth-first-first algorithm (DFS)
The breadth-first algorithm (BFS)
The A* search algorithm
We will apply these different algorithms to a robotics problem, enabling a robot to find its path in a room. Beyond robotics, these algorithms are ubiquitous and we will implement them in a generic way, allowing you to apply them to other problems.
This course is taught using the Python programming language and requires basic programming skills. If you do not have the required knowledge, I recommend that you brush up on your programming skills by taking a crash course in programming. Although Python is used, we will implement the various algorithms from scratch, which will allow you to easily implement them in other programming languages.
This course is primarily aimed at students, researchers, and developers who would like to add artificial intelligence to their projects, as well as artificial intelligence enthusiasts.
Concepts covered:
The depth-first-first algorithm (DFS) and its implementation
The breadth-first algorithm (BFS) and its implementation
The A* path search algorithm and its implementation
Artificial intelligence in robotics and video games
Tree traversal (depth and width)
Graph traversal
Don't wait any longer before jumping into the world of artificial intelligence!