Path with Maximum Gold - Practice Coding Problems

Path with Maximum Gold - Problem

Path with Maximum Gold

Imagine you're a treasure hunter exploring an ancient gold mine! You have a rectangular grid representing the mine, where each cell contains a certain amount of gold (or 0 if it's empty rock).

Your mission is to find the path that allows you to collect the maximum amount of gold possible. Here are the rules of your expedition:

🏃 Movement: From any cell, you can move one step in any of the 4 directions (up, down, left, right)
💰 Collection: You automatically collect all gold in each cell you visit
🚫 No Revisiting: Once you've been to a cell, you can't return to it in the same path
⛔ No Empty Cells: You cannot step on cells with 0 gold
🎯 Flexible Start/End: You can begin and end your journey at any cell containing gold

Return the maximum amount of gold you can collect in a single expedition!

Example: In a 3×3 grid with gold values [[1,2,3],[0,2,0],[7,6,5]], you could start at cell (2,0) with value 7, then move to collect 6, then 2, then 3 for a total of 18 gold!

Input & Output

example_1.py — Basic Grid

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

› Output: 18

💡 Note: The optimal path starts at (2,0) with value 7, moves to (2,1) with value 6, then to (1,1) with value 2, and finally to (0,2) with value 3. Total: 7 + 6 + 2 + 3 = 18

example_2.py — Single Row

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

› Output: 10

💡 Note: We can traverse the entire row from left to right (or right to left) collecting all gold: 1 + 2 + 3 + 4 = 10

example_3.py — All Zeros

$ Input: grid = [[0,0],[0,0]]

› Output: 0

💡 Note: No cells contain gold, so we cannot collect anything. The maximum gold is 0.

Constraints

1 ≤ m, n ≤ 15 (grid dimensions)
0 ≤ grid[i][j] ≤ 100
Grid will have at least one cell with gold > 0

Visualization

Tap to expand

Understanding the Visualization

Survey the Mine

Look at all possible starting positions with gold

Pick Starting Point

Begin DFS from a cell with gold, mark it as visited

Explore Neighbors

Check all 4 directions for valid moves (gold > 0, not visited)

Go Deeper

Recursively explore the best neighboring cell

Hit Dead End

When no more moves possible, record the gold collected

Backtrack

Unmark current cell and try alternative paths

Find Maximum

Compare all path totals and return the maximum

Key Takeaway

🎯 Key Insight: This problem requires exploring all possible paths systematically. Backtracking allows us to 'undo' our moves and try alternatives, ensuring we find the path with maximum gold while respecting the constraint of not revisiting cells.

Asked in

a Amazon 42 G Google 35 ⊞ Microsoft 28 f Meta 18

This problem is best solved using backtracking with DFS. The key insight is to try every possible starting cell and explore all valid paths from each one. We use the grid itself to mark visited cells (by temporarily setting them to 0) and restore them when backtracking. The time complexity is O(4^(m*n)) in worst case, but the constraint that we can't visit cells with 0 gold significantly reduces the search space in practice.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with DFS	O(4^(m*n))	O(m*n)	Try every possible path from every starting cell using depth-first search with backtracking

Backtracking with DFS — Algorithm Steps

Iterate through each cell in the grid as a potential starting point
For each non-zero cell, start a DFS traversal
In DFS: mark current cell as visited, add its gold to current sum
Recursively explore all 4 directions (up, down, left, right)
Only visit cells that are within bounds, non-zero, and not visited
Backtrack by unmarking the current cell as visited
Keep track of maximum gold collected across all paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin DFS from cell (2,0) with value 7

Explore Path

Move to adjacent cells, marking visited ones

Hit Dead End

No more valid moves available

Backtrack

Unmark current cell and try different direction

Find Maximum

Keep track of best path found so far

Code -

solution.c — C

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

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

int dfs(int** grid, int row, int col, int m, int n) {
    if (row < 0 || row >= m || col < 0 || col >= n || 
        grid[row][col] == 0) {
        return 0;
    }
    
    // Store original value and mark as visited
    int original = grid[row][col];
    grid[row][col] = 0;
    
    // Explore all 4 directions
    int currentMax = 0;
    for (int i = 0; i < 4; i++) {
        int gold = dfs(grid, row + directions[i][0], col + directions[i][1], m, n);
        if (gold > currentMax) {
            currentMax = gold;
        }
    }
    
    // Backtrack - restore original value
    grid[row][col] = original;
    
    return original + currentMax;
}

int getMaximumGold(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0) return 0;
    
    int m = gridSize, n = gridColSize[0];
    int maxGold = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] != 0) {
                int gold = dfs(grid, i, j, m, n);
                if (gold > maxGold) {
                    maxGold = gold;
                }
            }
        }
    }
    
    return maxGold;
}

int main() {
    // Example usage
    int row1[] = {1, 2, 3};
    int row2[] = {0, 2, 0};
    int row3[] = {7, 6, 5};
    int* grid[] = {row1, row2, row3};
    int gridColSize[] = {3, 3, 3};
    
    printf("%d\n", getMaximumGold(grid, 3, gridColSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n))

In worst case, from each cell we can move in 4 directions, and we might visit all m*n cells

✓ Linear Growth

Space Complexity

O(m*n)

Recursion depth can go up to m*n in worst case (visiting all cells in one path)

⚡ Linearithmic Space

35.2K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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

Backtracking with DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler