Path With Minimum Effort - Practice Coding Problems

Path With Minimum Effort - Problem

Array Binary Search Depth-First Search Breadth-First Search Union Find Heap (Priority Queue) Matrix Medium

The Mountain Hiker's Challenge

You're a hiker preparing for an epic mountain adventure! 🏔️ You have a detailed heights map represented as a 2D grid where heights[row][col] shows the elevation at each point.

Your mission: Travel from the top-left corner (0, 0) to the bottom-right corner (rows-1, columns-1) using the path that requires the minimum effort.

You can move up, down, left, or right to adjacent cells. The effort of any path is defined as the maximum absolute difference in heights between any two consecutive cells along that route.

Goal: Find the minimum effort required to complete your hike from start to finish.

Example: If you move from height 5 to height 8, then to height 3, your effort for this path would be max(|5-8|, |8-3|) = max(3, 5) = 5.

Input & Output

example_1.py — Basic Mountain Path

$ Input: heights = [[1,2,2],[3,8,2],[5,3,5]]

› Output: 2

💡 Note: The path [1,3,5,3,5] has a maximum effort of 2. This is better than the path [1,2,2,2,5] which has maximum effort of 3.

example_2.py — Steep Terrain

$ Input: heights = [[1,2,3],[3,8,4],[5,3,5]]

› Output: 1

💡 Note: The path [1,2,3,4,5] has maximum effort of 1, which is the minimum possible for this terrain.

example_3.py — Single Cell

$ Input: heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]

› Output: 0

💡 Note: This path has no effort required since we can find a route where all consecutive cells have the same height.

Visualization

Tap to expand

Understanding the Visualization

Map the Terrain

Analyze the height differences in the mountain grid

Test Rope Strength

Binary search to find minimum rope strength needed

Validate Path

Use BFS to check if destination is reachable with current strength

Adjust Strategy

Narrow down the search range based on validation results

Find Optimal Route

Converge on the minimum effort required for successful traverse

Key Takeaway

🎯 Key Insight: Binary search on the answer transforms a complex pathfinding problem into a series of simple reachability questions, achieving optimal O(mn log(max_height)) complexity.

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n))

In worst case, we explore 4 directions for each of m*n cells

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack depth can go up to m*n in worst case

⚡ Linearithmic Space

Constraints

rows == heights.length
columns == heights[i].length
1 ≤ rows, columns ≤ 100
1 ≤ heights[i][j] ≤ 10⁶

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28

The optimal solution uses Binary Search on the Answer combined with BFS. We search for the minimum effort value where a valid path exists, using BFS to validate each candidate effort in O(mn log(max_height)) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS All Paths)	O(4^(m*n))	O(m*n)	Explore all possible paths and track the minimum effort
Binary Search + BFS (Optimal)	O(mn * log(max_height))	O(mn)	Binary search on the answer combined with BFS to check feasibility

Brute Force (DFS All Paths) — Algorithm Steps

Start DFS from (0, 0) with effort 0
For each cell, try all 4 directions
Calculate effort as max of current effort and height difference to next cell
If we reach destination, update minimum effort
Backtrack and try other paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at (0,0)

Begin DFS from top-left corner with effort 0

Explore Neighbors

Try all 4 directions, calculate effort for each move

Track Maximum

Keep track of maximum effort encountered in current path

Backtrack

When path ends, backtrack and try other routes

Update Minimum

Keep global minimum of all successful paths

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

int minEffort = INT_MAX;
int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

void dfs(int** heights, int rows, int cols, int r, int c, bool** visited, int currentEffort) {
    if (r == rows - 1 && c == cols - 1) {
        if (currentEffort < minEffort) {
            minEffort = currentEffort;
        }
        return;
    }
    
    if (currentEffort >= minEffort) return;
    
    for (int i = 0; i < 4; i++) {
        int nr = r + directions[i][0];
        int nc = c + directions[i][1];
        
        if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && !visited[nr][nc]) {
            int effort = abs(heights[nr][nc] - heights[r][c]);
            int newEffort = (currentEffort > effort) ? currentEffort : effort;
            
            visited[nr][nc] = true;
            dfs(heights, rows, cols, nr, nc, visited, newEffort);
            visited[nr][nc] = false;
        }
    }
}

int minimumEffortPath(int** heights, int heightsSize, int* heightsColSize) {
    minEffort = INT_MAX;
    int rows = heightsSize;
    int cols = heightsColSize[0];
    
    bool** visited = (bool**)malloc(rows * sizeof(bool*));
    for (int i = 0; i < rows; i++) {
        visited[i] = (bool*)calloc(cols, sizeof(bool));
    }
    
    visited[0][0] = true;
    dfs(heights, rows, cols, 0, 0, visited, 0);
    
    for (int i = 0; i < rows; i++) {
        free(visited[i]);
    }
    free(visited);
    
    return minEffort;
}

int main() {
    int heights[3][3] = {{1,2,2},{3,8,2},{5,3,5}};
    int* heightsArray[3];
    int heightsColSize[3] = {3, 3, 3};
    
    for (int i = 0; i < 3; i++) {
        heightsArray[i] = heights[i];
    }
    
    printf("%d\n", minimumEffortPath(heightsArray, 3, heightsColSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n))

In worst case, we explore 4 directions for each of m*n cells

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack depth can go up to m*n in worst case

⚡ Linearithmic Space

Constraints

rows == heights.length
columns == heights[i].length
1 ≤ rows, columns ≤ 100
1 ≤ heights[i][j] ≤ 10⁶

42.3K Views

High Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (DFS All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler