Introduction to Graph Data Structures
What are Graphs?
Vertices Explained
Edges Explained
Graph Terminology
Graph Properties
Directed Graphs
Undirected Graphs
Directed vs. Undirected
Weighted Graphs
Unweighted Graphs
Weighted vs. Unweighted
Social Networks
Navigation Systems
Recommendation Systems
Dependencies
Adjacency Matrix Representation
What is a Matrix?
Intro to Adjacency Matrix
Directed Graphs
Undirected Graphs
Weighted Graphs
Setting Up the Matrix
Adding Edges
Removing Edges
Checking for Edges
Printing the Matrix
Space Complexity
Time Complexity
Advantage: Dense Graphs
Disadvantage: Sparse Graphs
When to Use?
Adjacency List Representation
What is an Adj. List?
Adj. List vs. Arrays
Adj. List with Linked List
Adj. List with Hash Maps
Directed Graph Adj. List
Undirected Graph Adj. List
Adding a Vertex
Adding an Edge
Removing a Vertex
Removing an Edge
Space Complexity
Time Complexity
Sparse Graphs
Dense Graphs
Use Cases
What is an Edge List?
Edge List Components
Edge List Example
When to Use Edge Lists
Edge List vs. Arrays
Edge List Implementation
Adding Edges
Removing Edges
Edge List Traversal
Edge List Search
Space Complexity
Time Complexity
Edge List Trade-offs
Edge List Optimizations
Edge List Summary
Weighted vs. Unweighted Graphs
What are Weighted Graphs?
What are Unweighted Graphs?
Key Differences
Real-World Examples
When to Use Which?
Adj Matrix: Unweighted
Adj Matrix: Weighted
Adj List: Unweighted
Adj List: Weighted
Code Demo: Representations
BFS on Unweighted
Dijkstra on Weighted
Bellman-Ford
MST Algorithms
Algorithm Choice
Directed vs. Undirected Graphs
Directed Graph Intro
Undirected Graph Intro
Directed vs. Undirected
Adj Matrix: Directed
Adj Matrix: Undirected
Adj List: Directed
Adj List: Undirected
Matrix vs. List: Space
Matrix vs. List: Time
DFS: Directed Graphs
DFS: Undirected Graphs
BFS: Directed Graphs
BFS: Undirected Graphs
Cycle Detection
Real World Impact
What are Sparse Graphs?
What are Dense Graphs?
Calculating Graph Density
Density Thresholds
Impact of Density
Adj Matrix for Dense Graphs
Adj List for Sparse Graphs
Space Complexity Tradeoff
Time Complexity Tradeoff
Edge List Considerations
Social Network Example
Road Network Example
Complete Graph Example
Real-World Considerations
Summary: Representation
Introduction to Graph Traversal
What is Traversal?
Visiting All Vertices
Order Matters!
Intro to DFS
DFS Use Cases
Intro to BFS
BFS Use Cases
DFS vs BFS
Memory Footprint
Time Complexity
Visited Nodes
Traversal Starting Point
Disconnected Graphs
Directed Traversal
Traversal Summary
Depth-First Search (DFS) - Recursive Implementation
Intro to DFS Recursion
DFS Algorithm Explained
Call Stack in DFS
Coding DFS: Base Case
Coding DFS: Visit & Mark
Coding DFS: Explore
Putting it All Together
Tracing DFS: Example 1
Tracing DFS: Example 2
DFS on Disconnected Graph
DFS: Pre/Post-processing
DFS: Node Distances
DFS: Path Reconstruction
DFS: Space Complexity
DFS: Time Complexity
Depth-First Search (DFS) - Iterative Implementation
Iterative DFS Intro
The Stack's Role
From Recursion to Stack
Iterative DFS Algorithm
Visited Nodes
Setting Up the Graph
Stack Initialization
The Main Loop
Visiting Neighbors
Putting It All Together
Tracing Example 1
Tracing Example 2
Tracing Example 3
When to use Iterative
Iterative DFS Summary
Cycle Detection in Directed Graphs using DFS
What is a Cycle?
Review: Depth First Search
DFS and Directed Graphs
Why DFS for Cycles?
Introducing Color Marking
White: Undiscovered Nodes
Gray: Node in Progress
Black: Node Completed
What are Back Edges?
Back Edges == Cycles
Detecting Cycles with DFS
Coding: Color Marking
Coding: Cycle Detection
Walkthrough Example
Practice Makes Perfect
Edge Cases and Caveats
Topological Sorting of a Directed Acyclic Graph (DAG)
What is Topological Sort?
DAG or Not a DAG?
Topological Sort Example
DFS Refresher
DFS and Finish Times
Coding DFS-Based Sort
DFS Sort Code Example
DFS Sort Time Complexity
Intro to Kahn's Algorithm
What are Indegrees?
Kahn's Algorithm Steps
Coding Kahn's Algorithm
Kahn's Time Complexity
Multiple Sorts?
Cycle Detection Revisited
Breadth-First Search (BFS)
What is BFS?
BFS: The Queue
BFS Algorithm Steps
Visited Nodes in BFS
BFS: A Simple Example
BFS Implementation
Adding Neighbors to Queue
Handling Disconnected Graphs
BFS Code Walkthrough
BFS Time Complexity
Shortest Path with BFS
Level Order Traversal
Bipartite Graph Check
BFS on a Grid
Practice Problems
Shortest Path in an Unweighted Graph using BFS
Intro to Shortest Path
Why BFS Works
Setting up for BFS
BFS Core Logic
BFS Code Walkthrough
Path Reconstruction Intro
Tracking Predecessors
Reconstructing the Path
Path Reconstruction Code
Putting it All Together
Disconnected Graphs
Multiple Shortest Paths
Space Optimization
Time Complexity
Real-World Examples
Level Order Traversal of a Binary Tree using BFS
What is Level Order?
Why Level Order Matters
BFS Intro
BFS and Trees
Queue Data Structure
Algorithm Overview
Step-by-Step Example
Coding Setup
Enqueue the Root
Main Traversal Loop
Visiting the Node
Enqueue Children
Complete Code
Testing
Complexity Analysis
Check Bipartiteness of a Graph using BFS
What is Bipartiteness?
Bipartite Graph Examples
Why Bipartiteness Matters
BFS Refresher
Graph Coloring Basics
Coloring with BFS
Setting Up the Graph
BFS Coloring Logic
Conflict Detection
Handling Disconnected Parts
Putting It All Together
Testing Bipartiteness
Edge Case: Empty Graph
Edge Case: Single Node
Edge Case: Self-Loops
Introduction to Shortest Path Algorithms
What is a Shortest Path?
Graphs for Shortest Path
Single-Source Shortest Path
All-Pairs Shortest Path
Weighted vs Unweighted
Positive Edge Weights
Negative Edge Weights
Negative Weight Cycles
Optimal Substructure
Triangle Inequality
Dijkstra's Algorithm Intro
Bellman-Ford Intro
Floyd-Warshall Intro
BFS for Shortest Path
Real-World Examples
Dijkstra's Intro
Core Concepts
Non-Negative Weights
Algorithm Overview
Worked Example Part 1
Worked Example Part 2
Worked Example Part 3
Path Reconstruction
Pseudocode
Time Complexity
Priority Queue Intro
PQ Implementation
PQ Time Complexity
Real-World Uses
Edge Cases
Dijkstra’s Algorithm Implementation with Priority Queue
Review: Dijkstra's Algo
Why Priority Queues?
Priority Queue Refresher
PQ Implementation Options
Binary Heap Explained
Setting Up the Priority Queue
Extracting the Minimum
Relaxation Step with PQ
PQ Distance Updates
Looping Until Empty
Time Complexity: PQ Ops
Time Complexity: Relaxation
Overall Time Complexity
Space Complexity
PQ vs. No PQ
Intro to Bellman-Ford
When to Use BF?
BF: Negative Weights
BF: Array Refresher
BF: Algorithm Overview
BF: Initialization
BF: Edge Relaxation
BF: Iteration Counts
BF: Code Walkthrough
BF: Cycle Detection
BF: Example 1
BF: Example 2
BF vs Dijkstra
BF: Time Complexity
BF: Real World
Detecting Negative Weight Cycles using Bellman-Ford
What are Neg. Weights?
Impact on Shortest Path
Negative Weight Cycles
Why Cycles Matter
Real-World Examples
Bellman-Ford Recap
Core Idea
The Detection Step
What Relaxation Means
Why It Works
Code Setup
Implementing the Algo
Return True or False
Time Complexity
Space Complexity
Single-Source Shortest Paths with Bellman-Ford
Bellman-Ford Intro
When to Use Bellman-Ford
Bellman-Ford: The Idea
Bellman-Ford Steps
Initialization
Edge Relaxation
Iterating for Shortest Path
Code: Edge Relaxation
Code: Iteration
Putting It Together
Detecting Neg. Cycles
Code: Cycle Detection
Bellman-Ford vs. Dijkstra
Performance Trade-offs
Real-World Examples
All-Pairs Shortest Path
Floyd-Warshall Intro
Core Idea
Dynamic Programming
When to Use It
Initialization
Iteration
Distance Matrix Update
Code Setup
Coding the Algorithm
Negative Cycle Check
Path Reconstruction
Transitive Closure
Real-World Apps
Complexity Analysis
All-Pairs Shortest Paths with Floyd-Warshall
All-Pairs Shortest Path
Intro to Floyd-Warshall
Dynamic Programming
Floyd-Warshall Intuition
When to use it?
Adjacency Matrix
Algorithm Steps
Coding the Algorithm
Handling No Edges
Negative Weight Edges
Negative Cycle Detection
Path Reconstruction
Predecessor Matrix
Complexity Analysis
Optimization Tips
Detecting Negative Weight Cycles using Floyd-Warshall
What are Neg. Cycles?
Impact on Shortest Path
Real-World Examples
Review: Floyd-Warshall
Distance Matrix Basics
Iterative Updates
The Key Insight
Diagonal Check
Algorithm Modification
Code Example
Step-by-Step Example
Edge Cases
Time Complexity
When to Use It?
Introduction to Minimum Spanning Trees (MST)
What is a Spanning Tree?
Minimum Spanning Tree
MST Example
MST Properties: Connected
MST Properties: Acyclic
MST Properties: Edges
MST Uniqueness
Cut Property of MST
Cycle Property of MST
Recap: MST Properties
Network Design
Clustering
Image Segmentation
Approximation Algorithms
Real-World Examples
What is MST?
Kruskal's: The Idea
Kruskal's: Step-by-Step
Union-Find: Intro
Union-Find: Find Op
Union-Find: Union Op
Union-Find: Code
Kruskal's: Putting It All Together
Kruskal's: Code Time!
Kruskal's: Example Run
Kruskal's: Time Complexity
Kruskal's: Space Complexity
Kruskal's vs Prim's
Kruskal's: Real World
Kruskal's: Variations
Kruskal’s Algorithm Implementation with Union-Find
Kruskal's Algorithm Recap
The Union-Find Data Struct
Why Union-Find for Kruskal's?
Union-Find: Initialization
Union-Find: The Find Op
Path Compression Explained
Union-Find: The Union Op
Union by Rank Explained
Kruskal's: Sort the Edges
Kruskal's: Iterate & Union
Kruskal's: Cycle Detection
Kruskal's: MST Construction
Kruskal's: Time Complexity
Kruskal's: Space Complexity
Kruskal's: Recap & Review
Cycle Detection using Union-Find
What is Union-Find?
The 'Find' Operation
The 'Union' Operation
Naive Implementation
Quick Find
Cycle Detection Intro
Adding Edges
Detecting a Cycle
Cycle Detection Algorithm
Coding Cycle Detection
Path Compression
Union by Rank
Optimized Implementation
Kruskal's Algorithm
Connected Components
What is MST?
Prim's Algorithm Intro
Greedy Approach
When to Use Prim's?
Prim's Algorithm Steps
Data Structures
Priority Queue
Adjacency List/Matrix
Pseudocode
Step-by-Step Example
Code Implementation
Time Complexity
Space Complexity
Edge Cases
Real-World Applications
Prim’s Algorithm Implementation with Priority Queue
Review: Prim's Algorithm
Priority Queue Refresher
Why Priority Queue?
Data Structures Needed
Adjacency List Review
Initialize Priority Queue
Main Loop
Extract Min Vertex
Mark Vertex as Visited
Updating Neighbor Weights
Complete Implementation
Example Run
Time Complexity
Space Complexity
Edge Cases & Optimizations
Kruskal's vs Prim's Algorithm
Kruskal's Algorithm Recap
Prim's Algorithm Recap
Core Differences
Kruskal's Time Complexity
Prim's Time Complexity
Complexity Comparison
Kruskal's Space Complexity
Prim's Space Complexity
Space Comparison
Sparse Graphs
Dense Graphs
Practical Considerations
Edge Cases
Kruskal's vs Prim's: Recap
Introduction to Topological Sorting
Topological Sort Intro
What is a DAG?
Why No Cycles?
Topological Sort Example
Dependencies & Ordering
Task Scheduling
Course Scheduling
Build Systems
Dependency Resolution
Data Serialization
DFS Approach
Kahn's Algorithm Intro
Algorithm Comparison
Multiple Valid Sorts
Algorithm Tradeoffs
Intro to Kahn's Algorithm
Kahn's Algorithm: The Idea
Kahn's Algorithm: Steps
Data Structures for Kahn's
Kahn's: Zero In-Degree
Calculate In-Degrees
Initialize the Queue
Process Nodes
Update In-Degrees
Build Topological Order
Detecting Cycles
Handling Cycles
Empty Graph
Disconnected Graph
Self-Loops
Kahn’s Algorithm Implementation with BFS
Kahn's Algorithm Intro
Indegree Explained
Zero Indegree Matters
BFS and Kahn's
Kahn's: Step-by-Step
Setting Up the Graph
Indegree Calculation
Initializing the Queue
BFS Traversal
Building the Sorted List
Empty Graph Case
Cycle Detection
Time Complexity
Space Complexity
Kahn's: Recap
Cycle Detection using Kahn's Algorithm
Intro to Kahn's Algorithm
Review: Directed Graphs
Indegree: The Basics
Zero Indegree Vertices
Kahn's Algorithm Steps
Cycle Detection Logic
Processed Vertices Count
No Zero Indegree Case
Algorithm's Termination
Edge Cases
Coding Setup
Coding: Indegree Calc
Coding: Cycle Detection
Example: No Cycle
Example: With Cycle
DFS-based Topological Sort
Topological Sort Intro
Review of DFS
Post-Order Traversal
Adapting DFS
Coding Setup
DFS Implementation
Post-Order Addition
Main Function
Complete Code
Example Graph
Time Complexity
Space Complexity
Cycle Detection
Error Handling
Real World Examples
Handling Multiple Valid Topological Sorts
Topological Sort Recap
Non-Uniqueness Explained
Visualizing Multiplicity
Factors Affecting Sorts
DFS Sort: The Algorithm
Coding DFS Sort
Kahn's Algorithm
Coding Kahn's Algorithm
Choosing a Sort
Lexicographical Sort
Real-World Examples
Tradeoffs
Edge Cases
Introduction to Strongly Connected Components (SCC)
What are Components?
Strongly Connected
SCCs Explained
SCCs: Visual Examples
SCCs vs. Components
Uniqueness of SCCs
SCCs as Meta-Nodes
Condensed Graph is a DAG
SCC Size Matters
Edges Between SCCs
Network Analysis
Web Crawling
Compiler Design
Data Mining
Game Development
Intro to Kosaraju's
Kosaraju's: Step 1
Kosaraju's: Step 2
Kosaraju's: Step 3
Kosaraju's: Putting it All
DFS Finishing Times
Transpose Graph Deeper
DFS on Transpose Graph
Kosaraju's: Edge Cases
Kosaraju's: Correctness
SCCs in Network Analysis
SCCs in Dependency Graphs
SCCs in Social Networks
Kosaraju's: Limitations
Kosaraju's: Summary
Finding SCCs with Kosaraju’s Algorithm
Intro to SCCs
Kosaraju's: The Big Idea
DFS Primer
Graph Reversal
DFS Pass #1: Ordering
DFS Pass #2: Finding SCCs
Putting it Together
Coding: Graph Reversal
Coding: DFS Pass #1
Coding: DFS Pass #2
Complete Implementation
Time Complexity
Space Complexity
Edge Cases & Caveats
Kosaraju's vs. Tarjan's
Kosaraju’s Algorithm Implementation
Kosaraju's Algorithm
Step 1: DFS on Original
Finishing Time Explained
Creating Reverse Graph
Why Reverse the Graph?
Step 2: DFS on Reversed
Coding DFS - Original
Coding DFS - Reversed
Putting It All Together
Example Run-Through
Time Complexity
Space Complexity
Optimization Tips
Edge Cases
Kosaraju vs. Tarjan
Intro to Tarjan's
DFS Refresher
Discovery Time
Low-Link Value
The Algorithm's Stack
Initialization
DFS Traversal
Updating Low-Link
SCC Identification
Handling Visited Nodes
Pseudocode Overview
Code Implementation
Complexity Analysis
Real-World Applications
Practice Problems
Finding SCCs with Tarjan’s Algorithm
Intro to Tarjan's
DFS Refresher
Low-Link Values
The Algorithm Stack
SCC Root Identification
Setting Up the Stage
The DFS Function
Exploring Neighbors
SCC Root Found!
Putting It All Together
Handling Disconnected
Complexity Analysis
Tarjan's vs Kosaraju's
Real-World Applications
Practice Problems
Tarjan’s Algorithm Implementation
Recap: Strongly Connected
Tarjan's Algorithm Intro
DFS Refresher
The Algorithm's Tools
Low-Link Values Explained
Initialization
The DFS Function
Updating Low-Link Values
SCC Detection
Putting It All Together
Code Walkthrough
Example Graph Run
Time Complexity
Space Complexity
When to Use Tarjan's?
Introduction to Graph Connectivity
What is Connectivity?
Connected vs. Disconnected
Paths and Reachability
Connected Components
Real-World Examples
What are Articulation Points?
What are Bridges?
Articulations vs. Bridges
Importance of Articulations
Importance of Bridges
Biconnected Components
Strongly Connected Graphs
Connectivity and Arrays
Connectivity Algorithms
Review and Next Steps
Connected Components in an Undirected Graph
What are Components?
Graph Representation
Why Find Components?
DFS Intro
DFS Algorithm
DFS Code
DFS Example
BFS Intro
BFS Algorithm
BFS Code
BFS Example
DFS vs BFS
Time Complexity
Space Complexity
Challenge 1
Challenge 2
Connected Components Implementation
DFS Setup
DFS Core Logic
DFS Connected Region
DFS Main Function
DFS Code Example
BFS Setup
BFS Core Logic
BFS Connected Region
BFS Main Function
BFS Code Example
DFS Time Complexity
BFS Time Complexity
DFS vs BFS
Graph Representation Impact
Complexity Summary
Articulation Points and Bridges
What are Cut Vertices?
What are Bridges?
Articulations vs. Bridges
Significance in Networks
Real-World Examples
Naive Approach
DFS Introduction
Discovery Time
Low-Link Value
DFS Algorithm
Code Implementation
Bridge Detection
Bridge Code
Time Complexity
Biconnected Components
Finding Articulation Points using DFS
What are Articulation Pts
Connectivity Refresher
Naive Approach
DFS Foundation
Discovery Time
Low-Link Value
Root Node Condition
Non-Root Condition
Algorithm Steps
Coding Setup
DFS Implementation
Root Node in Code
Non-Root in Code
Putting it Together
Time Complexity
Real World Applications
Identifying Bridges in a Graph
What is a Bridge?
Bridge Properties
Why Bridges Matter?
DFS Refresher
Low-Link Values
Discovery Time
Bridge Condition
DFS for Bridges
Code Setup
DFS Traversal
Bridge Identification
Putting It All Together
Handling Disconnected
Time Complexity
Introduction to Cycle Detection
What is a Cycle?
Why Detect Cycles?
Directed vs. Undirected
Self-Loops and Cycles
Simple Cycle Examples
Cycle Length
Overlapping Cycles
Cycle Detection Methods
Directed Cycle Types
Undirected Cycle Types
Complexity Matters
Space Considerations
Large Graphs
Algorithm Selection
Edge Cases
Cycle Detection in Directed Graphs using DFS
What is a Cycle?
Directed Graph Review
Why Detect Cycles?
DFS Refresher
DFS and Arrays
Introducing Color Marking
White: Undiscovered
Gray: Currently Visiting
Black: Fully Explored
Color Transitions
What are Back Edges?
Back Edges == Cycles
Detecting Back Edges
Putting It All Together
Practice Makes Perfect
Cycle Detection in Undirected Graphs using DFS/BFS
Intro to Cycle Detection
Back Edges Explained
DFS vs. BFS for Cycles
DFS Setup for Detection
DFS Core Logic
DFS: Code It Out
DFS Edge Cases
BFS Setup for Detection
BFS Core Logic
BFS: Code It Out
BFS Edge Cases
Directed vs. Undirected
Code Comparison
When to Use Which?
Introduction to Graph Search Applications
Intro to Graph Apps
Pathfinding Problems
Word Ladder Problem
Social Networks
Network Connectivity
Network Delay Time
Game Playing
Route Finding
Puzzle Solving
Resource Allocation
Dependency Resolution
Recommendation Systems
Constraint Satisfaction
Robotics
Graph Databases
What is Word Ladder?
Word Ladder Example
Core Constraints
Why is it a Graph?
From Words to Nodes
Edges: One-Letter Away
Building the Graph
Graph Properties
Graph Search Algorithms
BFS for Shortest Path
Dictionary as a Set
Optimizing Edge Creation
Handling Edge Cases
Complexity Analysis
Recap: Graph Modeling
Word Ladder Problem Implementation with BFS
Recap: Word Ladder
Graph Representation
Building the Adjacency List
Coding: Adjacency List
Finishing the Adjacency List
BFS Core Concepts
BFS Algorithm Steps
Coding: BFS Setup
BFS Traversal
Finding the End Word
Marking Visited Nodes
Path Length Tracking
Reconstructing the Path
Optimization Techniques
Complete Code & Walkthrough
Social Network Connectivity
Social Networks as Graphs
Graph Representation
Adjacency Matrix
Choosing a Representation
Path Existence
BFS for Connectivity
DFS for Connectivity
BFS vs DFS
Connected Components
Connectivity Code
DFS Code
Time Complexity
Space Complexity
Real-World Networks
Strong Connectivity
Social Network Connectivity Implementation
Representing Users
Representing Connections
Adjacency List for Social
Adjacency Matrix for Social
Choosing the Right Rep
BFS Overview
BFS Implementation
Finding a Connection
Shortest Connection Path
BFS Time Complexity
DFS Overview
DFS Implementation
Finding a Connection DFS
DFS Time Complexity
BFS vs DFS
Networks as Graphs
Nodes & Edges
Edge Weights = Delay
Network Delay Time
Problem Modeling
Dijkstra's Refresher
Adapting Dijkstra's
Initialization
Priority Queue
Relaxation Step
Implementation
Disconnected Graphs
Edge Case: No Edges
Edge Case: Self-Loop
Time Complexity
Network Delay Time Implementation with Dijkstra’s Algorithm
Problem Intro
Graph Representation
Initial Distance Values
Priority Queue Setup
Main Loop
Relaxation Step
Updating the Queue
Handling Disconnected
Finding Max Delay
Edge Case: Empty Graph
Edge Case: No Edges
Code Review
Time Complexity
Space Complexity
Introduction to Graph Coloring
What is Graph Coloring?
Chromatic Number
Types of Graph Coloring
Graph Coloring Constraints
Graph Representation
Map Coloring
Scheduling Problems
Register Allocation
Sudoku as Graph Coloring
Mobile Radio Frequency
Planar Graphs
Bipartite Graphs
NP-Completeness
Heuristics
Applications Recap
What is Graph Coloring?
Chromatic Number
Applications of Coloring
Constraints Explained
Coloring & Adjacency Matrix
Vertex Coloring
Edge Coloring
Face Coloring
Planar Graphs
Chromatic Polynomials
NP-Completeness
Greedy Coloring
Backtracking
Welsh-Powell Algorithm
DSatur Algorithm
Graph Coloring Implementation with Backtracking
Graph Coloring Intro
Backtracking Explained
Coloring with Backtracking
Arrays for Graph Coloring
Base Case
Color Assignment
Conflict Detection
Backtracking Step
No Valid Color
Algorithm Overview
Heuristics
Color Ordering
Vertex Ordering
Complexity Analysis
Real-World Applications
What is Graph Coloring?
M Coloring Defined
Constraints of M Coloring
M Coloring Use Cases
M Coloring Examples
Backtracking Intro
Backtracking Algorithm
Color Assignment Strategy
Conflict Detection
Base Cases
Code Setup
Backtracking Function
Running the Algorithm
Time Complexity
Space Complexity
M Coloring Implementation with Backtracking
Recap: Graph Coloring
What is M Coloring?
M Coloring Constraints
M Coloring Use Cases
Backtracking Intro
Backtracking Algorithm
Color Assignment Strategy
Checking for Conflicts
Base Case
Backtracking Step
Code Setup
Coding the Algorithm
Running the Code
Time Complexity
Space Complexity
Introduction to Flow Algorithms
What is a Flow Network?
Flow Network Properties
Residual Graph Intro
Augmenting Paths
Max Flow Intuition
Network Bandwidth
Bipartite Matching
Airline Scheduling
Image Segmentation
Project Selection
Data Mining
Supply Chain Optimization
Resource Allocation
Traffic Flow
Circulation with Demands
What is a Flow Network?
Flow Network Properties
Real-World Applications
Flow Network Example
Arrays and Flow Networks
Defining Max Flow
Flow Value
Residual Graph Intro
Augmenting Paths
Arrays and Max Flow
Capacity Constraints
Flow Conservation
Optimality Condition
Arrays and Constraints
Putting it All Together
What is a Flow Network?
Flow Network Properties
Residual Graph Intro
Building Residual Graphs
What are Augmenting Paths?
Finding Augmenting Paths
Increasing the Flow
Augmenting Path Example
Ford-Fulkerson Steps
Algorithm in Action
Max Flow Calculation
Algorithm Correctness
Time Complexity
Edmonds-Karp Intro
Augmenting Paths
Residual Graph
BFS for Shortest Path
Edmonds-Karp Steps
Code: Graph Setup
Code: BFS
Code: Augmenting Flow
Code: Main Loop
Code: Putting It Together
Time Complexity
Space Complexity
When to Use It?
Real-World Apps
EK vs FF
What is a Cut?
Cut Capacity
Flow Across a Cut
Valid Cuts
Residual Graph Reminder
The Min-Cut Theorem
Proof Intuition
Max Flow <= Min Cut
Max Flow >= Min Cut
Putting it Together
Network Reliability
Image Segmentation
Bipartite Matching
Project Selection
Theorem Summary
Minimum Cut Implementation
Review: Max Flow
What is a Cut?
Cut Capacity
Min Cut Definition
Min-Cut Max-Flow Theorem
Ford-Fulkerson Review
Residual Graph
Identifying the Min Cut
Sink Set (T)
Edges Across the Cut
Code: Find the Min Cut
Walkthrough
Time Complexity
Space Complexity
Edge Cases
Introduction to Graph Traversal Variants
Beyond Basic Traversal
When to Use Variants?
Preview: Bidirectional Search
Preview: A* Search
Bidirectional Search
Pros & Cons
Meeting in the Middle
Implementation Details
When is it a Good Fit?
A* Search Explained
Heuristics: The Key
Admissibility & Consistency
Implementation
A* vs. Dijkstra
A* Applications
Intro to Bi-Directional
Why Bidirectional Search?
Core Concepts
Assumptions & Requirements
Algorithm Overview
Data Structures
Forward Search
Backward Search
Meeting in the Middle
Path Reconstruction
Choosing Search Strategy
Heuristics
Irreversible Graphs
Complexity Analysis
Real World Examples
Bidirectional Search Implementation
Setting the Stage
BFS from Source
BFS from Target
Collision Detection
Putting it Together
Prioritizing Search
Heuristics?
Data Structure Choices
Early Exit Conditions
Memory Management
Time Complexity
Space Complexity
Best-Case Scenarios
Worst-Case Scenarios
Trade-offs
Intro to A* Search
The Heuristic Function
Admissible Heuristics
Consistent Heuristics
Cost Function
Evaluation Function f(n)
Open and Closed Sets
A* Search Algorithm Steps
Path Reconstruction
Visualizing A* Search
Manhattan Distance
Euclidean Distance
Diagonal Distance
Recap: A* Algorithm
Heuristic Functions
Admissible Heuristics
Consistent Heuristics
Heuristic Examples
Data Structures
Priority Queue
Node Representation
A* Pseudocode
Initialization
Expanding Nodes
Path Reconstruction
Dijkstra vs. A*
Time Complexity
Space Complexity
Eulerian and Hamiltonian Paths
Eulerian Path Intro
Eulerian Circuit Intro
Euler's Theorem
Path Existence Example
Circuit Existence Example
Hierholzer's Algorithm
Hierholzer's: Start Node
Hierholzer's: Traversal
Hierholzer's: Building Path
Hierholzer's: Example
Hamiltonian Path Intro
Hamiltonian Circuit Intro
NP-Completeness
Backtracking Approach
Hamiltonian Example
Eulerian Path/Circuit Detection
Eulerian Path Intro
Eulerian Circuit Intro
Eulerian Graph Properties
Directed vs Undirected
Connectivity Matters
Hierholzer's Algorithm
Hierholzer's Walk
Hierholzer's Pseudocode
Hierholzer's Example
Fleury's Algorithm
Fleury's Implementation
Time Complexity
Space Complexity
Code It: Hierholzer's
Code It: Fleury's
Hamiltonian Path/Circuit Detection
Hamiltonian Path Intro
Hamiltonian Circuit Intro
Path vs. Circuit
NP-Completeness
Brute-Force Approach
Backtracking Intro
Backtracking Steps
Base Case
Pseudocode
Code Implementation
Backtracking for Circuit
Circuit Check
Modified Pseudocode
Circuit Implementation
Optimization
What is Isomorphism?
Why Care About It?
Basic Properties
Adjacency Matrices
Simple Example
Complexity
Brute-Force Approach
Invariants
Refinement Algorithms
Limitations
Spectral Isomorphism
Machine Learning
Practical Considerations
Open Problems
Summary
What is Isomorphism?
Why Check Isomorphism?
Isomorphism Properties
Simple Isomorphism Example
Non-Isomorphic Example
Adjacency Matrix Review
Matrix for Isomorphism
Permutation Explained
Permutation Example
Algorithm Overview
Complexity Issues
Matrix Limitations
Beyond Adjacency
Real-World Challenges
Summary and Next Steps
Graph Representation in Memory Optimization
Intro to Optimization
Hash Maps Refresher
Adj List with Hash Maps
Coding: Hash Map Adj List
Space Complexity
Time Complexity Analysis
Trade-offs: Space vs Time
Dense vs Sparse Graphs
Coding: Benchmarking
Real-World Examples
Custom Hash Functions
Collision Resolution
Dynamic Resizing
Memory Pools
Compression Techniques