AI and Meta-Heuristics (Combinatorial Optimization) Python

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Lecture 2: Slides and source code

Chapter 2: ### GRAPH ALGORITHMS ###

Lecture 1: Why to consider graph algorithms?

Chapter 3: Breadth-First Search (DFS) Algorithm

Lecture 1: What is breadth-first search?

Lecture 2: Breadth-first search implementation

Lecture 3: Applications of breadth-first search

Chapter 4: Challange #1 – WebCrawler

Lecture 1: Course challenge #1 – WebCrawler problem

Lecture 2: What are WebCrawlers (core of search engines)?

Lecture 3: WebCrawler basic implementation

Chapter 5: Depth-First Search (DFS) Algorithm

Lecture 1: What is depth-first search?

Lecture 2: Depth-first search implementation

Lecture 3: Depth-first search implementation with recursion

Lecture 4: Depth-first search and stack memory visualization

Lecture 5: Memory comparison of graph traversal algorithms

Lecture 6: Applications of depth-first search

Chapter 6: Challange #2 – Maze Solver

Lecture 1: Course challenge #2 – maze problem

Lecture 2: Maze problem introduction

Lecture 3: Maze problem implementation

Lecture 4: Maze problem stack memory visualization

Chapter 7: A* Search Algorithm

Lecture 1: What is the A* search algorithm?

Lecture 2: A* search illustration

Lecture 3: A* search implementation I

Lecture 4: A* search implementation II

Lecture 5: A* search implementation III

Lecture 6: Path finding algorithms comparison

Chapter 8: ### META-HEURISTICS ###

Lecture 1: What are meta-heuristic approaches?

Chapter 9: Simulated Annealing

Lecture 1: What is simulated annealing?

Chapter 10: Simulated Annealing Implementation – Continuous Functions

Lecture 1: Simulated annealing implementation I

Lecture 2: Simulated annealing implementation II

Lecture 3: Simulated annealing implementation III

Chapter 11: Simulated Annealing Implementation – Combinatorial Optimization

Lecture 1: What is the travelling salesman problem (TSP)?

Lecture 2: Travelling salesman problem implementation I

Lecture 3: Travelling salesman problem implementation II

Lecture 4: Travelling salesman problem implementation III

Lecture 5: Travelling salesman problem implementation IV

Chapter 12: Simulated Annealing Implementation – Sudoku

Lecture 1: What is the Sudoku problem?

Lecture 2: Sudoku problem implementation I

Lecture 3: Sudoku problem implementation II

Lecture 4: Sudoku problem implementation III

Lecture 5: Sudoku problem implementation IV

Chapter 13: Genetic Algorithms

Lecture 1: Genetic algorithms introduction – basics

Lecture 2: Genetic algorithms introduction – chromosomes

Lecture 3: Genetic algorithms introduction – crossover

Lecture 4: Genetic algorithms introduction – mutation

Lecture 5: Genetic algorithms introduction – selection

Lecture 6: Genetic algorithms introduction – the algorithm

Lecture 7: What is elitism?

Lecture 8: Advantages and limitations of genetic algorithms

Chapter 14: Genetic Algorithms Implementation – Simple Example

Lecture 1: Genetic algorithm implementation I

Lecture 2: Genetic algorithm implementation II

Lecture 3: Genetic algorithm implementation III

Lecture 4: Genetic algorithm implementation IV

Lecture 5: Genetic algorithm implementation V – elitism

Chapter 15: Genetic Algorithms Implementation – Constraint Satisfaction Problems

Lecture 1: What is the N-queens problem?

Lecture 2: N queens problem implementation I

Lecture 3: N queens problem implementation II

Chapter 16: Challenge #3 – Knapsack Problem

Lecture 1: Course challenge #3 – knapsack problem overview

Lecture 2: What is the knapsack problem?

Lecture 3: Knapsack problem implementation

Chapter 17: Particle Swarm Optimization

Lecture 1: What is swarm intelligence?

Lecture 2: Particle swarm optimization introduction – basics

Lecture 3: Particle swarm optimization introduction – the algorithm

Lecture 4: Exploration and exploitation trade-off

Chapter 18: Particle Swarm Optimization – Simple Example

Lecture 1: Particle swarm optimization implementation I

Lecture 2: Particle swarm optimization implementation II

Lecture 3: Particle swarm optimization implementation III

Chapter 19: ### TWO PLAYER GAMES ###

Lecture 1: Game trees introduction

Chapter 20: Minimax Algorithm – Game Engines

Lecture 1: Minimax algorithm introduction – basics

Lecture 2: Minimax algorithm introduction – the algorithm

Lecture 3: Minimax algorithm introduction – relation to tic-tac-toe

Lecture 4: Alpha-beta pruning introduction

Lecture 5: Alpha-beta pruning example