Path with Maximum Gold

Problem statement

In a gold mine grid of size m x n, each cell in this mine has an integer representing the amount of gold in that cell, 0 if it is empty.

Return the maximum amount of gold you can collect under the conditions:

• Every time you are located in a cell you will collect all the gold in that cell.
• From your position, you can walk one step to the left, right, up, or down.
• You can't visit the same cell more than once.
• Never visit a cell with 0 gold.
• You can start and stop collecting gold from any position in the grid that has some gold.

Example 1:

Input: grid = [[0,6,0],[5,8,7],[0,9,0]]Output: 24Explanation:[[0,6,0], [5,8,7], [0,9,0]]Path to get the maximum gold, 9 -> 8 -> 7.

Example 2:

Input: grid = [[1,0,7],[2,0,6],[3,4,5],[0,3,0],[9,0,20]]Output: 28Explanation:[[1,0,7], [2,0,6], [3,4,5], [0,3,0], [9,0,20]]Path to get the maximum gold, 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7.

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 15
• 0 <= grid[i][j] <= 100
• There are at most 25 cells containing gold.

My solution

/**
 * @param {number[][]} grid
 * @return {number}
 */
var getMaximumGold = function(grid) {
    // let count = 0;
    if (grid.length == 0) {
        return count;
    }
    const outer = grid.length;
    const inner = grid[0].length;
    const directions = [[0, 1], [0, -1], [1, 0], [-1, 0]];
    let currentMax = 0
    
    for (let i = 0; i < outer; i++) {
        for (let j = 0; j < inner; j++) {
            if (grid[i][j] !== 0) {
                // console.log(i, j);
                currentMax = Math.max(currentMax, dfs(i, j));
            }
        }
    }
    
    function dfs(i, j) {
        if (i < 0 || i >= outer || j < 0 || j >= inner || grid[i][j] === 0) {
            return 0;
        }
        let currentValue = grid[i][j];
        let currentMax = currentValue;
        // console.log(j, currentValue);
        grid[i][j] = 0;
        
        for (const dir of directions) {
            const nextI = i + dir[0];
            const nextJ = j + dir[1];
            
            if (!(nextI < 0 || nextI >= outer || nextJ < 0 || nextJ >= inner || grid[nextI][nextJ] === 0)) {
                currentMax = Math.max(currentMax, currentValue + dfs(nextI, nextJ)) 
            }
        }
        grid[i][j] = currentValue;
        return currentMax;
        
    }
    
    return currentMax;
};