Path With Minimum Effort

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.

Constraints

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

Visualization

Tap to expand

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

✓ Binary Search + BFS (Optimal)

⏱️ Time: O(mn * log(max_height)) Space: O(mn)

Instead of finding the minimum effort directly, we binary search on the possible effort values. For each candidate effort, we use BFS to check if we can reach the destination without exceeding that effort limit.

Brute Force (DFS All Paths)

⏱️ Time: O(4^(m*n)) Space: O(m*n)

Use depth-first search to explore every possible path from start to destination. For each path, calculate the maximum height difference encountered and keep track of the global minimum.

Binary Search + BFS (Optimal) — Algorithm Steps

Find the range of possible efforts (0 to maximum height difference)
Binary search on this range
For each mid value, use BFS to check if path exists with max effort ≤ mid
If path exists, try smaller effort; otherwise try larger effort
Continue until we find the minimum feasible effort

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Search Range

left=0, right=max_height, search for minimum effort

Test Mid Value

Can we reach destination with effort ≤ mid?

BFS Validation

Use BFS to check if path exists within effort limit

Adjust Range

If possible, search lower; otherwise search higher

Converge

Continue until left meets right - that's our answer

Code -

solution.c — C

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

typedef struct {
    int r, c;
} Point;

typedef struct {
    Point* data;
    int front, rear, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (Point*)malloc(capacity * sizeof(Point));
    q->front = 0;
    q->rear = -1;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, Point p) {
    q->rear = (q->rear + 1) % q->capacity;
    q->data[q->rear] = p;
}

Point dequeue(Queue* q) {
    Point p = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    return p;
}

bool isEmpty(Queue* q) {
    return (q->rear + 1) % q->capacity == q->front;
}

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

bool canReach(int** heights, int rows, int cols, int maxEffort) {
    bool** visited = (bool**)malloc(rows * sizeof(bool*));
    for (int i = 0; i < rows; i++) {
        visited[i] = (bool*)calloc(cols, sizeof(bool));
    }
    
    Queue* queue = createQueue(rows * cols);
    Point start = {0, 0};
    enqueue(queue, start);
    visited[0][0] = true;
    
    while (!isEmpty(queue)) {
        Point curr = dequeue(queue);
        
        if (curr.r == rows - 1 && curr.c == cols - 1) {
            // Clean up
            for (int i = 0; i < rows; i++) free(visited[i]);
            free(visited);
            free(queue->data);
            free(queue);
            return true;
        }
        
        for (int i = 0; i < 4; i++) {
            int nr = curr.r + directions[i][0];
            int nc = curr.c + directions[i][1];
            
            if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && !visited[nr][nc]) {
                int effort = abs(heights[nr][nc] - heights[curr.r][curr.c]);
                
                if (effort <= maxEffort) {
                    visited[nr][nc] = true;
                    Point next = {nr, nc};
                    enqueue(queue, next);
                }
            }
        }
    }
    
    // Clean up
    for (int i = 0; i < rows; i++) free(visited[i]);
    free(visited);
    free(queue->data);
    free(queue);
    return false;
}

int minimumEffortPath(int** heights, int heightsSize, int* heightsColSize) {
    int rows = heightsSize;
    int cols = heightsColSize[0];
    
    int left = 0, right = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (heights[i][j] > right) {
                right = heights[i][j];
            }
        }
    }
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        
        if (canReach(heights, rows, cols, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

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(mn * log(max_height))

Binary search has log(max_height) iterations, each BFS takes O(mn) time

✓ Linear Growth

Space Complexity

O(mn)

BFS queue and visited array require O(mn) space

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search + BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler