- Access to all expert-led courses
- Earn certificates when you complete courses
- Network with other engineers from top tech companies
- Unlock private in-person and masterclass events
- Get personalized career advice in our exclusive forum
Overview
Core Problems And Concepts
Array and String Basics
Recursion Basics
Linked Lists
Linked List Intro Lecture
Linked List Warm Up Lecture
Linked List Values Approach
Linked List Values Walkthrough
Sum List Approach
Sum List Walkthrough
Linked List Find Approach
Linked List Find Walkthrough
Get Node Value Approach
Get Node Value Walkthrough
Reverse List Approach
Reverse List Walkthrough
Zipper Lists Approach
Zipper Lists Walkthrough
Intermission: Go Deeper
Binary Trees
Binary Tree Intro Lecture
Binary Tree Warm Up Lecture
Depth First Values Approach
Depth First Values Walkthrough
Breadth First Values Approach
Breadth First Values Walkthrough
Tree Sum Approach
Tree Sum Walkthrough
Tree Includes Approach
Tree Includes Walkthrough
Tree Min Value Approach
Tree Min Value Walkthrough
Max Root to Leaf Path Sum Approach
Max Root to Leaf Path Sum Walkthrough
Graphs
Graph Intro Lecture
Graph Warm Up Lecture
Has Path Approach
Has Path Walkthrough
Undirected Path Approach
Undirected Path Walkthrough
Connected Components Count Approach
Connected Components Count Walkthrough
Largest Component Approach
Largest Component Walkthrough
Shortest Path Approach
Shortest Path Walkthrough
Island Count Approach
Island Count Walkthrough
Minimum Island Approach
Minimum Island Walkthrough
Dynamic Programming
Fibonacci Approach
Fibonacci Walkthrough
Tribonacci Approach
Tribonacci Walkthrough
Sum Possible Approach
Sum Possible Walkthrough
Minimum Change Approach
Minimum Change Walkthrough
Count Paths Approach
Counts Paths Walkthrough
Max Path Sum Approach
Max Path Sum Walkthrough
Non Adjacent Sum Approach
Non Adjacent Sum Walkthrough
Summing Squares Approach
Summing Squares Walkthrough
Counting Change Approach
Counting Change Walkthrough
Array Stepper Approach
Array Stepper Walkthrough
Wrapping Up
Shortest Path Approach
In this lesson, Alvin explores the strategy to solving the following interview problem:
Write a function, shortest_path, that takes in a list of edges for an undirected graph and two nodes (*node_A*, node_B). The function should return the length of the shortest path between A and B. Consider the length as the number of edges in the path, not the number of nodes. If there is no path between A and B, then return -1. You can assume that A and B exist as nodes in the graph.
edges = [
['w', 'x'],
['x', 'y'],
['z', 'y'],
['z', 'v'],
['w', 'v']
]
shortest_path(edges, 'w', 'z') # -> 2
edges = [
['w', 'x'],
['x', 'y'],
['z', 'y'],
['z', 'v'],
['w', 'v']
]
shortest_path(edges, 'y', 'x') # -> 1
edges = [
['a', 'c'],
['a', 'b'],
['c', 'b'],
['c', 'd'],
['b', 'd'],
['e', 'd'],
['g', 'f']
]
shortest_path(edges, 'a', 'e') # -> 3
If you need additional support taking these DSA skills and actually applying them, take Alvin's complete data structures and algorithms course on Structy. You can try out the concepts yourself in their interactive code editor and learn advanced DSA patterns like stack exhaustive recursion.
Use this link to get 20% off the entire Structy DSA learning experience.
Follow Alvin on LinkedIn: https://www.linkedin.com/in/alvin-zablan-b73a92117/
