Find online courses made by experts from around the world.
Take your courses with you and learn anywhere, anytime.
Learn and practice realworld skills and achieve your goals.
This course is about advanced algorithms focusing on graph traversal, shortest path problems, spanning trees and maximum flow problems and a lots of its applications from Google Web Crawler to taking advantage of stock market arbitrage situations.
The course is going to take approximately 11 hours to completely but I highly suggest you typing these algorithms out several times in order to get the grasp of it. You can download the source code of the whole course at the last video.
In the first section we are going to talk about the main graph traversal algorithms (BFS,Â DFS) and its applications of course such as WebCrawler or topological ordering. The next section is about shortest path algorithms: there are several applications which we are going to be familiar with from image processing to FOREX market arbitrage. The next chapter is about minimum spanning trees and clustering algorithms. Then, we are going to learn about the maximum flow problem, maybe the most important algorithm in this course. The last chapterÂ is about how to solve NP problems such as the travelling salesman problemÂ with simulated annealing.
You should definitely take this course if you are interested in advanced topics concerning algorithms. There are a bunch of fields where these methods can be used: from software engineering to scientific research.
THEÂ COURSEÂ LASTÂ UPDATE: 2016 october
Not for you? No problem.
30 day money back guarantee.
Forever yours.
Lifetime access.
Learn on the go.
Desktop, iOS and Android.
Get rewarded.
Certificate of completion.
Section 1: Introduction  

Lecture 1 
Introduction
Preview

03:29  
Lecture 2 
Graph theory  Hamiltonian and Eulerian cycles

06:54  
Lecture 3 
Complexity theory
Preview

00:05  
Section 2: Breadth First Search  
Lecture 4 
Breadthfirst search introduction
Preview

09:30  
Lecture 5 
BFS implementation

12:10  
Lecture 6 
BFS  WebCrawler (core of search engines)

05:44  
Lecture 7 
BFS  WebCrawler implementation

15:00  
Section 3: Depth First Search  
Lecture 8  10:21  
Lecture 9 
DFS implementation I  with stack

11:28  
Lecture 10 
DFS implementation II  with recursion
Preview

04:17  
Lecture 11 
Topological ordering introduction

10:31  
Lecture 12 
Topological ordering implementation I

05:49  
Lecture 13 
Topological ordering implementation II

06:07  
Lecture 14 
Cycle detection introduction

06:30  
Lecture 15 
Cycle detection implementation I

08:14  
Lecture 16 
Cycle detection implementation II

07:21  
Lecture 17 
Maze solving algorithm implementation

14:50  
Lecture 18 
Memory management: BFS vs DFS

05:23  
Section 4: Shortest Path Algorithms  
Lecture 19 
Dijkstra algorithm introduction  basics

05:35  
Lecture 20 
Dijkstra algorithm introduction  algorithm

05:44  
Lecture 21 
Dijkstra algorithm introduction  example

10:27  
Lecture 22 
BellmanFord algorithm introduction

08:59  
Lecture 23 
Dijkstra algorithm introduction  with adjacency matrix

09:22  
Lecture 24 
Shortest path algorithms applications

08:37  
Lecture 25 
Dijkstra algorithm implementation I

09:28  
Lecture 26 
Dijkstra algorithm implementation II

10:57  
Lecture 27 
BellmanFord algorithm implementation I

14:43  
Lecture 28 
BellmanFord algorithm implementation II

06:05  
Lecture 29 
DAG shortest path implementation

09:42  
Lecture 30 
Arbitrage situations on FOREX introduction

03:47  
Lecture 31 
Arbitrage situations on FOREX implementation

06:37  
Lecture 32 
Longest path implementation

03:50  
Section 5: Spanning Trees  
Lecture 33 
Unionfind data structure (disjoint sets)

10:56  
Lecture 34 
Unionfind data structure illustration

06:35  
Lecture 35 
Spanning trees introduction  Kruskal algorithm

10:36  
Lecture 36 
Kruskal algorithm implementation I

08:04  
Lecture 37 
Kruskal algorithm implementation II  disjoint set

15:40  
Lecture 38 
Kruskal algorithm implementation III

10:07  
Lecture 39 
Spanning trees introduction  lazy Prim's algorithm

07:10  
Lecture 40 
Prims lazy algorithm implementation I

11:38  
Lecture 41 
Prims lazy algorithm implementation II  the core

07:06  
Lecture 42 
Spanning trees introduction  eager Prim's algorithm

11:02  
Lecture 43 
Eager Prim's algorithm implementation

10:45  
Lecture 44 
Applications of spanning trees

07:36  
Section 6: Strongly Connected Components  
Lecture 45 
Strongly connected components introduction

06:57  
Lecture 46 
Kosaraju algorithm introduction

08:19  
Lecture 47  07:28  
We create the helper classes and again, the Graph class. We transpose our directed graph inside this Graph class, because in Kosaraju algorithm we have to do the first DFS (topological ordering) in the transposed graph. (transposing a graph is just to reverse each edge: startVertex will be targetVertex and targetVertex will be the startVertex) 

Lecture 48  07:41  
We create our class in which we will perform the first DFS on the transposed graph 

Lecture 49  01:01  
In this video we make sure the our Kosaraju implementation gives the right results 

Lecture 50  09:06  
DFS is a robust but not so fast algorithm, so Tarjan algorithm tries to get rid of the DFS. 

Lecture 51 
Tarjan implementation II  test

00:44  
Lecture 52 
Applications of strongly connected components

06:48  
Section 7: Maximum Flow Problem  
Lecture 53 
Maximum flow introduction  basics

06:55  
Lecture 54 
Maximum flow introduction  properties

09:30  
Lecture 55 
Maximum flow introduction  cuts

05:13  
Lecture 56 
Maximum flow introduction  residual networks

06:49  
Lecture 57 
Maximum flow introduction  FordFulkerson algorithm

04:50  
Lecture 58 
Maximum flow introduction  example

08:35  
Lecture 59 
Maximum flow introduction  applications

03:08  
Lecture 60 
Maximum flow implementation I  Edge, Vertex

11:58  
Lecture 61 
Maximum flow implementation II  FlowNetwork class

05:26  
Lecture 62 
Maximum flow implementation III  FordFulkerson algorithm

08:03  
Lecture 63 
Maximum flow implementation IV  augmentation

06:43  
Lecture 64 
Maximum flow implementation V  testing

02:55  
Lecture 65 
Bipartite matching problem introduction

03:50  
Lecture 66 
Bipartite matching implementation

02:37  
Section 8: Travelling Salesman Problem (TSP)  
Lecture 67 
Travelling salesman problem introduction

10:52  
Lecture 68 
TSP implementation with simulated annealing I  city

09:51  
Lecture 69 
TSP implementation with simulated annealing II  tour

13:10  
Lecture 70 
TSP implementation with simulated annealing III  algorithm

10:17  
Lecture 71 
TSP implementation with simulated annealing IV  testing

04:29  
Lecture 72 
Tabu search introduction

09:47  
Section 9: Euler cycle  Chinese Postman Problem  
Lecture 73 
Euler cycles introduction

10:49  
Section 10: Source Code  
Lecture 74 
Source code

00:01  
Lecture 75  00:01  
You can download the slides here!


Lecture 76 
Coupon codes  get any of my other courses for a discounted price

00:06 
Hi!
My name is Balazs Holczer. I am from Budapest, Hungary. I am qualified as a physicist and later on I decided to get a master degree in applied mathematics. At the moment I am working as a simulation engineer at a multinational company. I have been interested in algorithms and data structures and its implementations especially in Java since university. Later on I got acquainted with machine learning techniques, artificial intelligence, numerical methods and recipes such as solving differential equations, linear algebra, interpolation and extrapolation. These things may prove to be very very important in several fields: software engineering, research and development or investment banking. I have a special addiction to quantitative models such as the BlackScholes model, or the Mertonmodel. Quantitative analysts use these algorithms and numerical techniques on daily basis so in my opinion these topics are definitely worth learning.