Artificial Intelligence I: Meta-Heuristics and Games in Java

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Chapter 2: Why Should You Learn Artificial Intelligence?

Lecture 1: What is AI good for?

Chapter 3: ### PATHFINDING ALGORITHMS (GRAPHS) ###

Lecture 1: Why to consider graph algorithms?

Chapter 4: Breadth-First Search (BFS)

Lecture 1: What is breadth-first search?

Lecture 2: Breadth-first search implementation

Lecture 3: Applications of breadth-first search

Chapter 5: Depth-First Search (DFS)

Lecture 1: What is depth-first search?

Lecture 2: Depth-first search implementation I – with stack

Lecture 3: Depth-first search implementation II – 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: Course Challenge #1 – Maze Escape

Lecture 1: Maze problem introduction

Lecture 2: Course challenge #1 – maze problem

Lecture 3: Maze problem implementation

Lecture 4: Maze problem stack memory visualization

Chapter 7: Iterative Deepening Depth-First Search (IDDFS)

Lecture 1: Enhanced search algorithms introduction (IDDFS)

Lecture 2: Iterative deepening depth-first search (IDDFS) implementation

Chapter 8: A* Search Algorithm

Lecture 1: A* search introduction

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 9: ### OPTIMIZATION ###

Lecture 1: Brute-force method

Lecture 2: Brute-force method implementation

Lecture 3: Hill climbing method

Lecture 4: Hill climbing method implementation

Chapter 10: ### META-HEURISTICS ###

Lecture 1: Heuristics and meta-heuristics

Chapter 11: Simulated Annealing

Lecture 1: What is simulated annealing?

Chapter 12: Simulated Annealing Implementation – Continuous Functions

Lecture 1: Simulated annealing – function extremum I

Lecture 2: Simulated annealing – function extremum II

Lecture 3: Simulated annealing – function extremum III

Chapter 13: Simulated Annealing Implementation – Combinatorial Optimization

Lecture 1: What is the travelling salesman problem?

Lecture 2: Travelling salesman problem I – city

Lecture 3: Travelling salesman problem II – tour

Lecture 4: Travelling salesman problem III – annealing algorithm

Lecture 5: Travelling salesman problem IV – testing

Chapter 14: 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 15: Genetic Algorithms Implementation – Simple Example

Lecture 1: Genetic algorithm implementation I – individual

Lecture 2: Genetic algorithm implementation II – population

Lecture 3: Genetic algorithm implementation III – the algorithm

Lecture 4: Genetic algorithm implementation IV – testing

Lecture 5: Genetic algorithm implementation V – function optimum

Chapter 16: Course Challenge #2 – Knapsack Problem

Lecture 1: Knapsack problem introduction

Lecture 2: Course challenge #2 – knapsack problem

Lecture 3: Knapsack problem with genetic algorithms

Chapter 17: Particle Swarm Optimization

Lecture 1: What is swarm intelligence?

Lecture 2: Particle swarm optimization introduction I – basics

Lecture 3: Particle swarm optimization introduction II – the algorithm

Lecture 4: Exploration and exploitation trade-off

Chapter 18: Particle Swarm Optimization – Simple Example

Lecture 1: Particle swarm optimization implementation I – particle

Lecture 2: Particle swarm optimization implementation II – initialize

Lecture 3: Particle swarm optimization implementation III – the algorithm

Lecture 4: Particle swarm optimization implementation IV – testing

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

Lecture 6: Chess problem