Warehouse Route Optimizer - Problem

You're managing a large warehouse with a complex grid layout where delivery robots need to find the shortest path from a starting position to a destination. The warehouse has several complications:

Grid Constraints:

0 represents open corridors where robots can move freely
-1 represents blocked sections (walls, shelves, obstacles)
Positive integers represent weighted corridors with movement costs

Movement Rules:

Robots can move in 4 directions (up, down, left, right)
Some paths may be one-way based on conveyor belts or traffic flow
Movement cost from cell A to cell B is determined by the destination cell's weight

Given a warehouse grid, starting position, and destination position, find the minimum total cost to reach the destination. If no path exists, return -1.

Input & Output

Example 1 — Basic Warehouse Grid

$ Input: grid = [[0,1,2],[1,0,3],[2,3,0]], start = [0,0], end = [2,2]

› Output: 6

💡 Note: Optimal path: (0,0) → (1,0) → (2,1) → (2,2). Cost = 0 + 1 + 3 + 0 = 4. Wait, let me recalculate: movement cost is destination cell's weight, so (0,0)→(1,0) costs 1, (1,0)→(2,0) costs 2, (2,0)→(2,1) costs 3, (2,1)→(2,2) costs 0. Total = 1+2+3 = 6.

Example 2 — Blocked Path

$ Input: grid = [[0,1,-1],[1,-1,2],[3,2,0]], start = [0,0], end = [2,2]

› Output: 9

💡 Note: Direct path blocked by -1 cells. Must go: (0,0) → (0,1) → (1,0) → (2,0) → (2,1) → (2,2). Cost = 1 + 1 + 3 + 2 + 0 = 7. Actually, checking valid moves more carefully: (0,0)→(1,0) costs 1, then (1,0)→(2,0) costs 3, then (2,0)→(2,1) costs 2, then (2,1)→(2,2) costs 0. Total = 6. Or (0,0)→(0,1) costs 1, but (0,1)→(1,1) blocked. Let me trace: viable path is (0,0)→(1,0)→(2,0)→(2,1)→(2,2) = 1+3+2+0 = 6.

Example 3 — No Path Available

$ Input: grid = [[0,-1],[−1,0]], start = [0,0], end = [1,1]

› Output: -1

💡 Note: All adjacent cells to start (0,0) are blocked (-1), so no path exists to reach destination (1,1).

Constraints

1 ≤ grid.length, grid[0].length ≤ 100
-1 ≤ grid[i][j] ≤ 1000
0 ≤ start[0], start[1] < grid.length
0 ≤ end[0], end[1] < grid.length

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 M Microsoft 32 U Uber 28

The optimal solution uses Dijkstra's algorithm with a priority queue to always explore the cheapest path first. This guarantees finding the minimum cost route through the weighted warehouse grid. Time: O((m×n) log(m×n)), Space: O(m×n).

Common Approaches

✓ Brute Force DFS

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

Explore every possible path from start to destination using DFS recursion, tracking visited cells to avoid cycles. Calculate the total cost for each complete path and return the minimum.

Dijkstra's Algorithm

⏱️ Time: O((m×n) log(m×n)) Space: O(m×n)

Apply Dijkstra's shortest path algorithm using a min-heap to always process the cell with minimum cost first. This guarantees finding the optimal solution efficiently.

Brute Force DFS — Algorithm Steps

Start DFS from the starting position
For each cell, try all 4 directions
Skip blocked cells and already visited cells
When reaching destination, update minimum cost
Backtrack and try other paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at starting position, mark as visited

Try All Directions

For each cell, attempt all 4 directions

Recursive Exploration

Continue DFS on valid neighboring cells

Backtrack

When path ends, backtrack and try other routes

Find Minimum

Track minimum cost among all complete paths

Code -

solution.c — C

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

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

void dfs(int grid[10][10], int r, int c, int endR, int endC, int cost, 
         int visited[10][10], int m, int n) {
    if (r == endR && c == endC) {
        if (cost < minCost) {
            minCost = cost;
        }
        return;
    }
    
    if (cost >= minCost) return; // Pruning
    
    for (int i = 0; i < 4; i++) {
        int nr = r + directions[i][0];
        int nc = c + directions[i][1];
        
        if (nr >= 0 && nr < m && nc >= 0 && nc < n && 
            !visited[nr][nc] && grid[nr][nc] != -1) {
            visited[nr][nc] = 1;
            dfs(grid, nr, nc, endR, endC, cost + grid[nr][nc], visited, m, n);
            visited[nr][nc] = 0;
        }
    }
}

int solution(int grid[10][10], int start[2], int end[2], int m, int n) {
    int startR = start[0], startC = start[1];
    int endR = end[0], endC = end[1];
    
    if (grid[startR][startC] == -1 || grid[endR][endC] == -1) return -1;
    
    minCost = INT_MAX;
    int visited[10][10] = {0};
    visited[startR][startC] = 1;
    
    dfs(grid, startR, startC, endR, endC, 0, visited, m, n);
    
    return minCost == INT_MAX ? -1 : minCost;
}

int main() {
    int grid[10][10] = {{0, 1, 2}, {1, 0, 3}, {2, 3, 0}};
    int start[2] = {0, 0};
    int end[2] = {2, 2};
    
    int result = solution(grid, start, end, 3, 3);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(m×n))

In worst case, explores all possible paths in grid, branching factor of 4 directions

⚡ Linearithmic

Space Complexity

O(m×n)

Recursion stack depth can be as deep as total grid cells

⚡ Linearithmic Space

28.5K Views

High Frequency

~35 min Avg. Time

842 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

Warehouse Route Optimizer - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler