Path With Maximum Minimum Value

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

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

✓ Binary Search + BFS/DFS

⏱️ Time: O(mn * log(max-min)) Space: O(mn)

Use binary search to find the maximum possible minimum value. For each candidate value, use BFS or DFS to check if there exists a path where all values are >= candidate.

DFS with All Paths (Brute Force)

⏱️ 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 its score (minimum value) and keep track of the maximum score found across all paths.

Dijkstra's Algorithm (Optimal)

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

Use a priority queue (max-heap) to always explore the path with the highest minimum value first. This ensures we find the optimal path efficiently without checking all possibilities.

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>
#include <string.h>

static 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) / 2;
        if (canReachWithMinValue(grid, mid, m, n)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input like "[[5,4,5],[1,2,6],[7,4,6]]"
    int** grid = NULL;
    int m = 0;
    int* colSizes = NULL;
    
    char* ptr = input;
    while (*ptr && *ptr != '[') ptr++; // find first '['
    if (*ptr) ptr++; // skip first '['
    
    // Count rows first
    char* temp = ptr;
    while (*temp) {
        if (*temp == '[') m++;
        temp++;
    }
    
    if (m == 0) {
        printf("0\n");
        return 0;
    }
    
    grid = (int**)malloc(m * sizeof(int*));
    colSizes = (int*)malloc(m * sizeof(int));
    
    int row = 0;
    while (*ptr && row < m) {
        if (*ptr == '[') {
            ptr++; // skip '['
            
            // Count columns in this row
            char* rowStart = ptr;
            int cols = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr == ',' || *ptr == ']') {
                    cols++;
                } else if (*ptr >= '0' && *ptr <= '9') {
                    // Start of number, count it
                    while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
                    if (*ptr != ',') cols++; // Last number in row
                    continue;
                }
                ptr++;
            }
            if (cols == 0) cols = 1; // single number case
            
            colSizes[row] = cols;
            grid[row] = (int*)malloc(cols * sizeof(int));
            
            // Parse numbers
            ptr = rowStart;
            int col = 0;
            char numStr[20];
            int numIdx = 0;
            
            while (*ptr && *ptr != ']' && col < cols) {
                if (*ptr >= '0' && *ptr <= '9' || *ptr == '-') {
                    numStr[numIdx++] = *ptr;
                } else if (*ptr == ',' || *ptr == ']') {
                    if (numIdx > 0) {
                        numStr[numIdx] = '\0';
                        grid[row][col++] = atoi(numStr);
                        numIdx = 0;
                    }
                }
                ptr++;
            }
            // Handle last number if no trailing comma
            if (numIdx > 0 && col < cols) {
                numStr[numIdx] = '\0';
                grid[row][col] = atoi(numStr);
            }
            
            row++;
        } else {
            ptr++;
        }
    }
    
    int result = maximumMinimumPath(grid, m, colSizes[0]);
    printf("%d\n", result);
    
    for (int i = 0; i < m; i++) {
        free(grid[i]);
    }
    free(grid);
    free(colSizes);
    
    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