Hello Interview | Data Structures and Algorithms

Limited Time Offer:Up to 25% off Hello Interview Premium

Up to 25% off Hello Interview Premium 🎉

Back to Main

Your Dashboard

Learn Code

Introduction

Overview

Container With Most Water

Two Sum (Sorted Array)

3-Sum

Triangle Numbers

Move Zeroes

Sort Colors

Trapping Rain Water

Overview

Longest Substring Without Repeating Characters

Longest Repeating Character Replacement

Overview

Maximum Sum of Subarrays of Size K

Max Points You Can Obtain From Cards

Max Sum of Distinct Subarrays Length k

Overview

Can Attend Meetings

Insert Interval

Non-Overlapping Intervals

Merge Intervals

Employee Free Time

Overview

Valid Parentheses

Decode String

Longest Valid Parentheses

Overview

Daily Temperatures

Largest Rectangle in Histogram

Overview

Linked List Cycle

Palindrome Linked List

Remove Nth Node From End of List

Reorder List

Swap Nodes in Pairs

Overview

Apple Harvest (Koko Eating Bananas)

Search in Rotated Sorted Array

Overview

Kth Largest Element in an Array

K Closest Points to Origin

Find K Closest Elements

Merge K Sorted Lists

Introduction

Overview

Level Order Sum

Rightmost Node

Zigzag Level Order

Maximum Width of Binary Tree

Graphs Overview

Minimum Knight Moves

Rotting Oranges

01-Matrix

Bus Routes

Overview

Word Search

Solution Space Trees

Subsets

Generate Parentheses

Combination Sum

Overview

Course Schedule

Course Schedule II

Fundamentals

Solving a Question with Dynamic Programming

Counting Bits

Decode Ways

Maximal Square

Unique Paths

Longest Increasing Subsequence

Word Break

Maximum Profit in Job Scheduling

Overview

Best Time to Buy and Sell Stock

Gas Station

Jump Game

Overview

Implement Trie Methods

Prefix Matching

Overview

Count Vowels in Substrings

Subarray Sum Equals K

Spiral Matrix

Rotate Image

Set Matrix Zeroes

Vote For New Content

Pricing

Become a Coach

⌘K

Pricing Become a Coach

⌘K

Tutor

Get Premium

Types of DFS

There are a few common "types" of depth-first search problems you'll encounter in coding interviews. Understanding these patterns will help you quickly recognize and solve similar problems.

Connected Components

The Problem: Given a 2D grid where 1 represents land and 0 represents water, count the number of distinct islands. An island is a group of 1s connected horizontally or vertically.

Example Input:

[0, 1, 0, 0, 0, 0]
[0, 1, 1, 0, 1, 0]
[0, 0, 0, 1, 1, 0]
[1, 1, 0, 0, 0, 1]
[1, 1, 0, 0, 0, 1]

Expected Output: 4 (there are 4 separate islands)

How it works:

We iterate through every cell in the grid
When we find an unvisited 1, we've discovered a new island—increment the count
We then use DFS to "flood fill" the entire island, marking all connected 1s as visited (by setting them to 0)
After DFS returns, that island is fully explored and won't be counted again

What to watch for in the animation:

Notice how we scan the grid from top-left to bottom-right
When we find a 1, we start a DFS that "floods" the entire island, marking all connected cells
The count variable increments each time we find an unvisited 1 (the start of a new island)
Watch how the DFS explores deeply in one direction before backtracking

Visualization


def count_islands(grid):
    rows, cols = len(grid), len(grid[0])
    visited = set()
    count = 0
    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == 1 and (r, c) not in visited:
                dfs(grid, r, c, visited)
                count += 1
    return count

Count islands using DFS

0 / 59

Key insight: The outer loop finds new islands, and the DFS "consumes" each island so we don't count the same island twice.

Boundary DFS

The Problem: Given a 2D grid, find all 1s that are connected to the boundary of the matrix. This is a key step in solving problems like "Surrounded Regions" where you need to identify cells that cannot be captured because they're connected to the edge.

Example Input:

[0, 1, 0, 0, 1, 0]
[0, 1, 1, 0, 1, 0]
[0, 0, 1, 0, 1, 0]
[0, 1, 0, 0, 1, 1]
[0, 1, 1, 0, 1, 1]
[1, 0, 0, 0, 0, 0]

How it works:

Instead of scanning every cell, we only start DFS from cells on the boundary (edges) of the grid
We iterate through the first and last rows, and the first and last columns
For each boundary cell that contains a 1, we run DFS to mark all connected cells
After this process, any 1 that was visited is connected to the boundary; any unvisited 1 is "surrounded"

What to watch for in the animation:

Notice how DFS starts from cells on the edges of the matrix (not from the top-left corner)
The algorithm only explores cells that are connected to the boundary
Any 1 that gets visited is "safe" because it touches the edge
Cells in the middle that aren't reached would be "surrounded"

Visualization


def find_boundary_connected(grid):
    rows, cols = len(grid), len(grid[0])
    visited = set()
    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
    def dfs(r, c):
        if (r, c) in visited:
            return
        if r < 0 or r >= rows or c < 0 or c >= cols:
            return
        if grid[r][c] != 1:
            return
        visited.add((r, c))
        for dr, dc in directions:
            dfs(r + dr, c + dc)
    # Start DFS from boundary cells with value 1
    for r in range(rows):
        if grid[r][0] == 1: dfs(r, 0)
        if grid[r][cols-1] == 1: dfs(r, cols-1)
    for c in range(cols):
        if grid[0][c] == 1: dfs(0, c)
        if grid[rows-1][c] == 1: dfs(rows-1, c)

Boundary DFS - find cells connected to edge

0 / 220

Key insight: Instead of checking if each cell is surrounded (hard), we flip the problem—find all cells that are NOT surrounded by starting from the boundary and working inward.

Mark as read

Next: Number of Islands

Your account is free and you can post anonymously if you choose.

Types of DFS

Connected Components

Boundary DFS

Questions

Learn

Links

Legal

Contact