Path With Maximum Minimum Value - Practice Coding Problems

Path With Maximum Minimum Value - Problem

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

Imagine you're a treasure hunter navigating through a dangerous dungeon represented by an m × n grid. Each cell contains a number representing the safety level of that location. You must find a path from the top-left corner (0, 0) to the bottom-right corner (m-1, n-1), moving only up, down, left, or right.

Here's the catch: your journey is only as safe as its weakest point. The score of any path is the minimum value encountered along that route. Your goal is to find the path that maximizes this minimum value.

Example: If you traverse cells with values 8 → 4 → 5 → 9, your path score is 4 (the minimum). You want to find the path where this minimum is as large as possible!

Input & Output

example_1.py — Basic 3x3 Grid

$ Input: grid = [[5,4,5],[1,2,6],[7,4,6]]

› Output: 4

💡 Note: The optimal path is 5 → 4 → 6 → 6 with minimum value 4. Alternative paths like 5 → 1 → 2 → 6 → 6 have minimum value 1, which is worse.

example_2.py — Simple 2x3 Grid

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

› Output: 2

💡 Note: The path 2 → 2 → 2 → 2 gives minimum value 2. We cannot do better since we must end at the bottom-right corner.

example_3.py — Single Path Grid

$ Input: grid = [[3,4,6,3,4],[0,2,1,1,7],[8,8,3,2,7],[3,2,4,9,8],[4,1,2,0,0]]

› Output: 3

💡 Note: The optimal path maintains a minimum value of 3 by carefully navigating through higher-value cells and avoiding the zeros at the bottom-right area.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 100
0 ≤ grid[i][j] ≤ 10⁹
You can move in 4 directions: up, down, left, right

Visualization

Tap to expand

Optimal PathMin value: 4Alternative PathMin value: 1 (worse)Key Insight: Bottleneck OptimizationYour journey is only as safe as its most dangerous pointDijkstra's algorithm finds the path where this danger is minimizedAlways explore the safest-looking option first!

Understanding the Visualization

Understanding the Problem

Each path's score is its weakest link - we want to maximize this minimum value

Why Dijkstra Works

Instead of finding shortest path, we find the path that maximizes the bottleneck value

Priority Queue Strategy

Always explore the most promising path first - the one with highest minimum so far

Optimal Solution Found

First time we reach destination gives us the optimal maximum minimum value

Key Takeaway

🎯 Key Insight: This is a bottleneck shortest path problem - use Dijkstra's algorithm with max-heap to find the path that maximizes the minimum value encountered!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses Dijkstra's algorithm with a max-heap to always explore paths with the highest minimum value first. This approach guarantees finding the path that maximizes the minimum value in O(mn log(mn)) time, making it efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + BFS/DFS	O(mn * log(max-min))	O(mn)	Binary search on the answer, then verify if path exists with BFS/DFS
Dijkstra's Algorithm (Optimal)	O(mn log(mn))	O(mn)	Modified Dijkstra's algorithm to maximize the minimum value along the path
DFS with All Paths (Brute Force)	O(4^(m*n))	O(m*n)	Explore all possible paths using DFS and track the maximum minimum value

Binary Search + BFS/DFS — Algorithm Steps

Set binary search range: left = min(grid), right = max(grid)
For middle value, check if path exists with all cells >= middle
Use BFS/DFS visiting only cells with value >= middle
If path exists, try larger minimum (left = mid + 1)
If no path exists, try smaller minimum (right = mid - 1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Set search range

left = min(grid), right = max(grid)

Test middle value

Can we reach destination using only cells >= mid?

Adjust range

If yes, try larger values; if no, try smaller

Converge to answer

Continue until left > right

Code -

solution.c — C

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

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

typedef struct {
    int row, col;
} 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 = q->rear = 0;
    q->capacity = capacity;
    return q;
}

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

Point dequeue(Queue* q) {
    return q->data[q->front++];
}

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

bool canReachWithMinValue(int** grid, int minVal, int m, int n) {
    if (grid[0][0] < minVal || grid[m-1][n-1] < minVal) {
        return false;
    }
    
    bool** visited = (bool**)malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        visited[i] = (bool*)calloc(n, sizeof(bool));
    }
    
    Queue* queue = createQueue(m * n);
    Point start = {0, 0};
    enqueue(queue, start);
    visited[0][0] = true;
    
    bool found = false;
    while (!isEmpty(queue) && !found) {
        Point curr = dequeue(queue);
        
        if (curr.row == m - 1 && curr.col == n - 1) {
            found = true;
            break;
        }
        
        for (int i = 0; i < 4; i++) {
            int nr = curr.row + directions[i][0];
            int nc = curr.col + directions[i][1];
            
            if (nr >= 0 && nr < m && nc >= 0 && nc < n && 
                !visited[nr][nc] && grid[nr][nc] >= minVal) {
                visited[nr][nc] = true;
                Point next = {nr, nc};
                enqueue(queue, next);
            }
        }
    }
    
    for (int i = 0; i < m; i++) {
        free(visited[i]);
    }
    free(visited);
    free(queue->data);
    free(queue);
    
    return found;
}

int maximumMinimumPath(int** grid, int m, int n) {
    int left = INT_MAX, right = INT_MIN;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] < left) left = grid[i][j];
            if (grid[i][j] > right) right = grid[i][j];
        }
    }
    
    int result = left;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canReachWithMinValue(grid, mid, m, n)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn * log(max-min))

Binary search runs log(max-min) times, each iteration does BFS/DFS taking O(mn)

⚡ Linearithmic

Space Complexity

O(mn)

BFS queue or DFS recursion stack, plus visited array

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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/DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler