DSA Crash Course [Part 78] - Max Path Sum Walkthrough

In this lesson, Alvin walks through the python implementation for the *max_path_sum* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/max-path-sum?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 77] - Max Path Sum Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function, *max_path_sum*, that takes in a grid as an argument. The function should return the maximum sum possible by traveling a path from the top-left corner to the bottom-right corner. You may only travel through the grid by moving down or right.
>
> You can assume that all numbers are non-negative.

```
grid = [
[1, 3, 12],
[5, 1, 1],
[3, 6, 1],
]

max_path_sum(grid) # -> 18
```

```
grid = [
[1, 2, 8,  1],
[3, 1, 12, 10],
[4, 0, 6,  3],
]

max_path_sum(grid) # -> 36
```

```
grid = [
[1, 2, 8, 1],
[3, 10, 12, 10],
[4, 0, 6, 3],
]

max_path_sum(grid) # -> 39
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 76] - Counts Paths Walkthrough

In this lesson, Alvin walks through the python implementation for the *count_paths* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/count-paths?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 75] - Count Paths Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function, *count_paths*, that takes in a grid as an argument. In the grid, 'X' represents walls and 'O' represents open spaces. You may only move down or to the right and cannot pass through walls. The function should return the number of ways possible to travel from the top-left corner of the grid to the bottom-right corner.

```
grid = [
["O", "O"],
["O", "O"],
]

count_paths(grid) # -> 2
```

```
grid = [
["O", "O", "X"],
["O", "O", "O"],
["O", "O", "O"],
]

count_paths(grid) # -> 5
```

```
grid = [
["O", "O", "O"],
["O", "O", "X"],
["O", "O", "O"],
]

count_paths(grid) # -> 3
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 74] - Minimum Change Walkthrough

In this lesson, Alvin walks through the python implementation for the *min_change* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/min-change?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 73] - Minimum Change Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function *min_change* that takes in an amount and a list of coins. The function should return the minimum number of coins required to create the amount. You may use each coin as many times as necessary.
>
> If it is not possible to create the amount, then return -1.

```
min_change(8, [1, 5, 4, 12]) # -> 2, because 4+4 is the minimum coins possible
```

```
min_change(13, [1, 9, 5, 14, 30]) # -> 5
```

```
min_change(23, [2, 5, 7]) # -> 4
```

```
min_change(102, [1, 5, 10, 25]) # -> 6
```

```
min_change(200, [1, 5, 10, 25]) # -> 8
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 72] - Sum Possible Walkthrough

In this lesson, Alvin walks through the python implementation for the *sum_possible* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/sum-possible?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 71] - Sum Possible Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function *sum_possible* that takes in an amount and a list of positive numbers. The function should return a boolean indicating whether or not it is possible to create the amount by summing numbers of the list. You may reuse numbers of the list as many times as necessary.
>
> You may assume that the target amount is non-negative.

```
sum_possible(8, [5, 12, 4]) # -> True, 4 + 4
```

```
sum_possible(15, [6, 2, 10, 19]) # -> False
```

```
sum_possible(13, [6, 2, 1]) # -> True
```

```
sum_possible(103, [6, 20, 1]) # -> True
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 70] - Tribonacci Walkthrough

In this lesson, Alvin walks through the python implementation for the *tribonacci* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/tribonacci?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 69] - Tribonacci Approach

In this lesson, Alvin explores the strategy to solving the following problem using dynamic programming:

> Write a function *tribonacci* that takes in a number argument, *n*, and returns the *n*\-th number of the Tribonacci sequence.
>
> The 0-th and 1-st numbers of the sequence are both 0.
>
> The 2-nd number of the sequence is 1.
>
> To generate further numbers of the sequence, calculate the sum of previous three numbers.
>
> Solve this recursively.

```
tribonacci(0) # -> 0
```

```
tribonacci(1) # -> 0
```

```
tribonacci(2) # -> 1
```

```
tribonacci(5) # -> 4
```

```
tribonacci(7) # -> 13
```

```
tribonacci(14) # -> 927
```

```
tribonacci(20) # -> 35890
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 68] - Fibonacci Walkthrough

In this lesson, Alvin walks through the python implementation for the *fib* problem. The goal here is to solve it recursively and then apply dynamic programming to speed it up.

Code along and test your work in the following editor workspace: <https://structy.net/problems/fib?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 67] - Fibonacci Approach

In this lesson, Alvin explains the fundamentals of dynamic programming by applying dynamic programming to fibonacci:

> Write a function *fib* that takes in a number argument, *n*, and returns the *n*\-th number of the Fibonacci sequence.
>
> The 0-th number of the sequence is 0.
>
> The 1-st number of the sequence is 1.
>
> To generate further numbers of the sequence, calculate the sum of previous two numbers.
>
> Solve this recursively.

```
fib(0); # -> 0
```

```
fib(1); # -> 1
```

```
fib(2); # -> 1
```

```
fib(3); # -> 2
```

```
fib(4); # -> 3
```

```
fib(5); # -> 5
```

```
fib(35); # -> 9227465
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 66] - Minimum Island Walkthrough

In this lesson, Alvin walks through the python implementation for the *minimum_island* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/minimum-island?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 65] - Minimum Island Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function, *minimum_island*, that takes in a grid containing Ws and Ls. W represents water and L represents land. The function should return the size of the smallest island. An island is a vertically or horizontally connected region of land.
>
> You may assume that the grid contains at least one island.

```
grid = [
['W', 'L', 'W', 'W', 'W'],
['W', 'L', 'W', 'W', 'W'],
['W', 'W', 'W', 'L', 'W'],
['W', 'W', 'L', 'L', 'W'],
['L', 'W', 'W', 'L', 'L'],
['L', 'L', 'W', 'W', 'W'],
]

minimum_island(grid) # -> 2
```

```
grid = [
['L', 'W', 'W', 'L', 'W'],
['L', 'W', 'W', 'L', 'L'],
['W', 'L', 'W', 'L', 'W'],
['W', 'W', 'W', 'W', 'W'],
['W', 'W', 'L', 'L', 'L'],
]

minimum_island(grid) # -> 1
```

```
grid = [
['L', 'L', 'L'],
['L', 'L', 'L'],
['L', 'L', 'L'],
]

minimum_island(grid) # -> 9
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 64] - Island Count Walkthrough

In this lesson, Alvin walks through the python implementation for the *island_count* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/island-count?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 63] - Island Count Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function, *island_count*, that takes in a grid containing Ws and Ls. W represents water and L represents land. The function should return the number of islands on the grid. An island is a vertically or horizontally connected region of land.

```
grid = [
['W', 'L', 'W', 'W', 'W'],
['W', 'L', 'W', 'W', 'W'],
['W', 'W', 'W', 'L', 'W'],
['W', 'W', 'L', 'L', 'W'],
['L', 'W', 'W', 'L', 'L'],
['L', 'L', 'W', 'W', 'W'],
]

island_count(grid) # -> 3
```

```
grid = [
['L', 'W', 'W', 'L', 'W'],
['L', 'W', 'W', 'L', 'L'],
['W', 'L', 'W', 'L', 'W'],
['W', 'W', 'W', 'W', 'W'],
['W', 'W', 'L', 'L', 'L'],
]

island_count(grid) # -> 4
```

```
grid = [
['L', 'L', 'L'],
['L', 'L', 'L'],
['L', 'L', 'L'],
]

island_count(grid) # -> 1
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 62] - Shortest Path Walkthrough

In this lesson, Alvin walks through the python implementation for the *shortest_path* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/shortest-path?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 61] - 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**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 60] - Largest Component Walkthrough

In this lesson, Alvin walks through the python implementation for the *largest_component* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/largest-component?language=py>

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 59] - Largest Component Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function, *largest_component*, that takes in the adjacency list of an undirected graph. The function should return the size of the largest connected component in the graph.

```
largest_component({
  0: [8, 1, 5],
  1: [0],
  5: [0, 8],
  8: [0, 5],
  2: [3, 4],
  3: [2, 4],
  4: [3, 2]
}) # -> 4
```

```
largest_component({
  1: [2],
  2: [1,8],
  6: [7],
  9: [8],
  7: [6, 8],
  8: [9, 7, 2]
}) # -> 6
```

```
largest_component({
  3: [],
  4: [6],
  6: [4, 5, 7, 8],
  8: [6],
  7: [6],
  5: [6],
  1: [2],
  2: [1]
}) # -> 5
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). 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**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: [**https://www.linkedin.com/in/alvin-zablan-b73a92117/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

Tech Career Growth Videos

Our instructional videos provide software engineers with insights needed for career growth. Masterclasses go incredibly in-depth on a specific tech topic while case studies are real examples from established engineering leaders.