# Gold Mine Problem

Given a gold mine of n*m dimensions. Each field in this mine contains a positive integer which is the amount of gold in tons. Initially, the miner is in the first column but can be in any row. He can move only (right->,right up /,right down\) that is from a given cell, the miner can move to the cell diagonally up towards the right or diagonally down towards the right. Find out the maximum amount of gold he can collect.

Examples:

```Input : mat[][] = {{1, 3, 3},
{2, 1, 4},
{0, 6, 4}};
Output : 12
{(1,0)->(2,1)->(1,2)}

Input: mat[][] = { {1, 3, 1, 5},
{2, 2, 4, 1},
{5, 0, 2, 3},
{0, 6, 1, 2}};
Output : 16
(2,0) -> (1,1) -> (1,2) -> (0,3) OR
(2,0) -> (3,1) -> (2,2) -> (2,3)

Input : mat[][] = {{10, 33, 13, 15},
{22, 21, 04, 1},
{5, 0, 2, 3},
{0, 6, 14, 2}};
Output : 83```

Source Flipkart Interview

Recommended Practice

Method 1: Recursion

A simple method that is a direct recursive implementation

## C++

 `// C++ program to solve Gold Mine problem``#include``using` `namespace` `std;` `int` `collectGold(vector> gold, ``int` `x, ``int` `y, ``int` `n, ``int` `m) {` `    ``// Base condition.``    ``if` `((x < 0) || (x == n) || (y == m)) {  ``        ``return` `0;``    ``}``  `  `    ``// Right upper diagonal``    ``int` `rightUpperDiagonal = collectGold(gold, x - 1, y + 1, n, m); ` `     ``// right``    ``int` `right = collectGold(gold, x, y + 1, n, m);` `    ``// Lower right diagonal``    ``int` `rightLowerDiagonal = collectGold(gold, x + 1, y + 1, n, m);  ` `    ``// Return the maximum and store the value``    ``return`  `gold[x][y] + max(max(rightUpperDiagonal, rightLowerDiagonal), right);  ``}` `int` `getMaxGold(vector> gold, ``int` `n, ``int` `m)``{``    ``int` `maxGold = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Recursive function call for  ith row.``        ``int` `goldCollected = collectGold(gold, i, 0, n, m);  ``        ``maxGold = max(maxGold, goldCollected);``    ``}` `    ``return` `maxGold;``}` `// Driver Code``int` `main()``{``    ``vector> gold { {1, 3, 1, 5},``        ``{2, 2, 4, 1},``        ``{5, 0, 2, 3},``        ``{0, 6, 1, 2}``    ``};``    ``int` `m = 4, n = 4;``    ``cout << getMaxGold(gold, n, m);``    ``return` `0;``}`

## Java

 `// Java program to solve Gold Mine problem``import` `java.io.*;``class` `GFG {``  ``static` `int` `collectGold(``int``[][] gold, ``int` `x, ``int` `y,``                         ``int` `n, ``int` `m)``  ``{` `    ``// Base condition.``    ``if` `((x < ``0``) || (x == n) || (y == m)) {``      ``return` `0``;``    ``}` `    ``// Right upper diagonal``    ``int` `rightUpperDiagonal``      ``= collectGold(gold, x - ``1``, y + ``1``, n, m);` `    ``// right``    ``int` `right = collectGold(gold, x, y + ``1``, n, m);` `    ``// Lower right diagonal``    ``int` `rightLowerDiagonal``      ``= collectGold(gold, x + ``1``, y + ``1``, n, m);` `    ``// Return the maximum and store the value``    ``return` `gold[x][y]``      ``+ Math.max(Math.max(rightUpperDiagonal,``                          ``rightLowerDiagonal),``                 ``right);``  ``}` `  ``static` `int` `getMaxGold(``int``[][] gold, ``int` `n, ``int` `m)``  ``{``    ``int` `maxGold = ``0``;` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``// Recursive function call for  ith row.``      ``int` `goldCollected``        ``= collectGold(gold, i, ``0``, n, m);``      ``maxGold = Math.max(maxGold, goldCollected);``    ``}` `    ``return` `maxGold;``  ``}``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[][] gold = { { ``1``, ``3``, ``1``, ``5` `},``                    ``{ ``2``, ``2``, ``4``, ``1` `},``                    ``{ ``5``, ``0``, ``2``, ``3` `},``                    ``{ ``0``, ``6``, ``1``, ``2` `} };``    ``int` `m = ``4``, n = ``4``;``    ``System.out.println(getMaxGold(gold, n, m));``  ``}``}` `// This code is contributed by Karandeep Singh.`

## Python3

 `# Python program to solve Gold Mine problem``def` `collectGold(gold, x, y, n, m):` `    ``# Base condition.``    ``if` `((x < ``0``) ``or` `(x ``=``=` `n) ``or` `(y ``=``=` `m)):  ``        ``return` `0` `    ``# Right upper diagonal``    ``rightUpperDiagonal ``=` `collectGold(gold, x ``-` `1``, y ``+` `1``, n, m)` `     ``# right``    ``right ``=` `collectGold(gold, x, y ``+` `1``, n, m)` `    ``# Lower right diagonal``    ``rightLowerDiagonal ``=` `collectGold(gold, x ``+` `1``, y ``+` `1``, n, m)` `    ``# Return the maximum and store the value``    ``return`  `gold[x][y] ``+` `max``(``max``(rightUpperDiagonal, rightLowerDiagonal), right)  `  `def` `getMaxGold(gold,n,m):` `    ``maxGold ``=` `0` `    ``for` `i ``in` `range``(n):` `        ``# Recursive function call for  ith row.``        ``goldCollected ``=` `collectGold(gold, i, ``0``, n, m)``        ``maxGold ``=` `max``(maxGold, goldCollected)` `    ``return` `maxGold` `# Driver Code``gold ``=` `[[``1``, ``3``, ``1``, ``5``],``        ``[``2``, ``2``, ``4``, ``1``],``        ``[``5``, ``0``, ``2``, ``3``],``        ``[``0``, ``6``, ``1``, ``2``]``]` `m,n ``=` `4``,``4``print``(getMaxGold(gold, n, m))` `# This code is contributed by shinjanpatra.`

## C#

 `// C# program to solve Gold Mine problem``using` `System;` `public` `class` `GFG{` `  ``static` `public` `int` `collectGold(``int``[,] gold, ``int` `x, ``                                ``int` `y, ``int` `n, ``int` `m)``  ``{``    ` `    ``// Base condition.``    ``if` `((x < 0) || (x == n) || (y == m)) {``      ``return` `0;``    ``}` `    ``// Right upper diagonal``    ``int` `rightUpperDiagonal = collectGold(gold, x - 1, y + 1, n, m);` `    ``// right``    ``int` `right = collectGold(gold, x, y + 1, n, m);` `    ``// Lower right diagonal``    ``int` `rightLowerDiagonal = collectGold(gold, x + 1, y + 1, n, m);` `    ``// Return the maximum and store the value``    ``return` `gold[x,y] + Math.Max(Math.Max(rightUpperDiagonal, ``                                         ``rightLowerDiagonal), right);``  ``}` `  ``static` `public` `int` `getMaxGold(``int``[,] gold, ``int` `n, ``int` `m){``    ``int` `maxGold = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``// Recursive function call for  ith row.``      ``int` `goldCollected = collectGold(gold, i, 0, n, m);``      ``maxGold = Math.Max(maxGold, goldCollected);``    ``}` `    ``return` `maxGold;``  ``}` `  ``// Driver Code``  ``static` `public` `void` `Main (){` `    ``int``[,] gold = ``new` `int``[,] { { 1, 3, 1, 5 },``                              ``{ 2, 2, 4, 1 },``                              ``{ 5, 0, 2, 3 },``                              ``{ 0, 6, 1, 2 } };` `    ``int` `m = 4, n = 4;``    ``Console.Write(getMaxGold(gold, n, m));``  ``}``}` `// This code is contributed by shruti456rawal`

## Javascript

 ``

Output
`16`

Time complexity: O(3N*M)
Auxiliary Space: O(N*M)

Method 2: Memoization

Bottom-Up Approach: The second way is to take an extra space of size m*n and start computing values of states of right, right upper diagonal, and right bottom diagonal and store it in the 2d array.

## C++

 `// C++ program to solve Gold Mine problem``#include``using` `namespace` `std;` `int` `collectGold(vector> gold, ``int` `x, ``int` `y, ``int` `n, ``int` `m, vector> &dp) {` `    ``// Base condition.``    ``if` `((x < 0) || (x == n) || (y == m)) {  ``        ``return` `0;``    ``}``  ` `    ``if``(dp[x][y] != -1){``        ``return` `dp[x][y] ;``    ``}` `    ``// Right upper diagonal``    ``int` `rightUpperDiagonal = collectGold(gold, x - 1, y + 1, n, m, dp); ` `     ``// right``    ``int` `right = collectGold(gold, x, y + 1, n, m, dp);` `    ``// Lower right diagonal``    ``int` `rightLowerDiagonal = collectGold(gold, x + 1, y + 1, n, m, dp);  ` `    ``// Return the maximum and store the value``    ``return` `dp[x][y] = gold[x][y] + max(max(rightUpperDiagonal, rightLowerDiagonal), right);  ``}` `int` `getMaxGold(vector> gold, ``int` `n, ``int` `m)``{``    ``int` `maxGold = 0;``    ``// Initialize the dp vector``    ``vector> dp(n, vector<``int``>(m, -1)) ;``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Recursive function call for  ith row.``        ``int` `goldCollected = collectGold(gold, i, 0, n, m, dp);  ``        ``maxGold = max(maxGold, goldCollected);``    ``}` `    ``return` `maxGold;``}` `// Driver Code``int` `main()``{``    ``vector> gold { {1, 3, 1, 5},``        ``{2, 2, 4, 1},``        ``{5, 0, 2, 3},``        ``{0, 6, 1, 2}``    ``};``    ``int` `m = 4, n = 4;``    ``cout << getMaxGold(gold, n, m);``    ``return` `0;``}`

## Java

 `// Java program to solve Gold Mine problem``import` `java.io.*;``class` `Gold {``  ``static` `int` `collectGold(``int``[][] gold, ``int` `x, ``int` `y,``                         ``int` `n, ``int` `m, ``int``[][] dp)``  ``{` `    ``// Base condition.``    ``if` `((x < ``0``) || (x == n) || (y == m)) {``      ``return` `0``;``    ``}` `    ``if` `(dp[x][y] != -``1``) {``      ``return` `dp[x][y];``    ``}` `    ``// Right upper diagonal``    ``int` `rightUpperDiagonal``      ``= collectGold(gold, x - ``1``, y + ``1``, n, m, dp);` `    ``// right``    ``int` `right = collectGold(gold, x, y + ``1``, n, m, dp);` `    ``// Lower right diagonal``    ``int` `rightLowerDiagonal``      ``= collectGold(gold, x + ``1``, y + ``1``, n, m, dp);` `    ``// Return the maximum and store the value``    ``return` `dp[x][y] = gold[x][y]``      ``+ Math.max(Math.max(rightUpperDiagonal,``                          ``rightLowerDiagonal),``                 ``right);``  ``}` `  ``static` `int` `getMaxGold(``int``[][] gold, ``int` `n, ``int` `m)``  ``{``    ``int` `maxGold = ``0``;``    ``int``[][] dp = ``new` `int``[n][m];``    ``for` `(``int` `row = ``0``; row < n; row++) {``      ``Arrays.fill(dp[row], -``1``);``    ``}``    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``// Recursive function call for  ith row.``      ``int` `goldCollected``        ``= collectGold(gold, i, ``0``, n, m, dp);``      ``maxGold = Math.max(maxGold, goldCollected);``    ``}` `    ``return` `maxGold;``  ``}``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[][] gold = { { ``1``, ``3``, ``1``, ``5` `},``                    ``{ ``2``, ``2``, ``4``, ``1` `},``                    ``{ ``5``, ``0``, ``2``, ``3` `},``                    ``{ ``0``, ``6``, ``1``, ``2` `} };``    ``int` `m = ``4``, n = ``4``;``    ``System.out.println(getMaxGold(gold, n, m));``  ``}``}` `// This code is contributed by Karandeep Singh.`

## Python3

 `# Python3 program to solve Gold Mine problem``def` `collectGold(gold, x, y, n, m, dp):` `    ``# Base condition.``    ``if` `((x < ``0``) ``or` `(x ``=``=` `n) ``or` `(y ``=``=` `m)):``        ``return` `0` `    ``if``(dp[x][y] !``=` `-``1``):``        ``return` `dp[x][y]` `    ``# Right upper diagonal``    ``rightUpperDiagonal ``=` `collectGold(gold, x ``-` `1``, y ``+` `1``, n, m, dp)` `        ``# right``    ``right ``=` `collectGold(gold, x, y ``+` `1``, n, m, dp)` `    ``# Lower right diagonal``    ``rightLowerDiagonal ``=` `collectGold(gold, x ``+` `1``, y ``+` `1``, n, m, dp)` `    ``# Return the maximum and store the value``    ``dp[x][y] ``=` `gold[x][y] ``+` `max``(``max``(rightUpperDiagonal, rightLowerDiagonal), right)``    ``return` `dp[x][y]`` `  `def` `getMaxGold(gold,n,m):` `    ``maxGold ``=` `0``    ``# Initialize the dp vector``    ``dp ``=` `[[``-``1` `for` `i ``in` `range``(m)]``for` `j ``in` `range``(n)]``    ` `    ``for` `i ``in` `range``(n):` `        ``# Recursive function call for  ith row.``        ``goldCollected ``=` `collectGold(gold, i, ``0``, n, m, dp)  ``        ``maxGold ``=` `max``(maxGold, goldCollected)` `    ``return` `maxGold` `# Driver Code` `gold ``=` `[ [``1``, ``3``, ``1``, ``5``],``        ``[``2``, ``2``, ``4``, ``1``],``        ``[``5``, ``0``, ``2``, ``3``],``        ``[``0``, ``6``, ``1``, ``2``] ]``m,n ``=` `4``,``4``print``(getMaxGold(gold, n, m))` `# This code is contributed by Shinjanpatra`

## C#

 `// C# program to solve Gold Mine problem``using` `System;` `public` `class` `Gold``{``  ``static` `int` `collectGold(``int``[,] gold, ``int` `x, ``int` `y, ``                         ``int` `n, ``int` `m, ``int``[,] dp)``  ``{``    ``// Base condition.``    ``if` `((x < 0) || (x == n) || (y == m)) ``    ``{``      ``return` `0;``    ``}` `    ``if` `(dp[x,y] != -1) ``    ``{``      ``return` `dp[x,y];``    ``}` `    ``// Right upper diagonal``    ``int` `rightUpperDiagonal = collectGold(gold, x - 1, y + 1, n, m, dp);` `    ``// right``    ``int` `right = collectGold(gold, x, y + 1, n, m, dp);` `    ``// Lower right diagonal``    ``int` `rightLowerDiagonal = collectGold(gold, x + 1, y + 1, n, m, dp);` `    ``// Return the maximum and store the value``    ``return` `gold[x,y] + Math.Max(Math.Max(rightUpperDiagonal, ``                                         ``rightLowerDiagonal), right);``  ``}` `  ``static` `int` `getMaxGold(``int``[,] gold, ``int` `n, ``int` `m)``  ``{``    ``int` `maxGold = 0;``    ``int``[,] dp = ``new` `int``[n, m];``    ``for` `(``int` `row = 0; row < n; row++) ``    ``{``      ``for` `(``int` `col = 0; col < m; col++) ``      ``{``        ``dp[row,col] = -1;``      ``}``    ``}``    ``for` `(``int` `i = 0; i < n; i++) ``    ``{``      ``// Recursive function call for  ith row.``      ``int` `goldCollected = collectGold(gold, i, 0, n, m, dp);``      ``maxGold = Math.Max(maxGold, goldCollected);``    ``}``    ``return` `maxGold;``  ``}``  ``static` `public` `void` `Main ()``  ``{``    ``int``[,] gold = { { 1, 3, 1, 5 },``                   ``{ 2, 2, 4, 1 },``                   ``{ 5, 0, 2, 3 },``                   ``{ 0, 6, 1, 2 } };``    ``int` `m = 4, n = 4;``    ``Console.Write(getMaxGold(gold, n, m));``  ``}``}` `// This code is contributed by kothavvsaakash`

## Javascript

 ``

Output
`16`

Time Complexity: O(m*n)
Auxiliary Space: O(m*n)

Method 3: Using Dp, Tabulation
Create a 2-D matrix goldTable[][]) of the same as given matrix mat[][]. If we observe the question closely, we can notice following.

1. Amount of gold is positive, so we would like to cover maximum cells of maximum values under given constraints.
2. In every move, we move one step toward right side. So we always end up in last column. If we are at the last column, then we are unable to move right

If we are at the first row or last column, then we are unable to move right-up so just assign 0 otherwise assign the value of goldTable[row-1][col+1] to right_up. If we are at the last row or last column, then we are unable to move right down so just assign 0 otherwise assign the value of goldTable[row+1][col+1] to right up.
Now find the maximum of right, right_up, and right_down and then add it with that mat[row][col]. At last, find the maximum of all rows and first column and return it.

## C++

 `// C++ program to solve Gold Mine problem``#include``using` `namespace` `std;` `const` `int` `MAX = 100;` `// Returns maximum amount of gold that can be collected``// when journey started from first column and moves``// allowed are right, right-up and right-down``int` `getMaxGold(``int` `gold[][MAX], ``int` `m, ``int` `n)``{``    ``// Create a table for storing intermediate results``    ``// and initialize all cells to 0. The first row of``    ``// goldMineTable gives the maximum gold that the miner``    ``// can collect when starts that row``    ``int` `goldTable[m][n];``    ``memset``(goldTable, 0, ``sizeof``(goldTable));` `    ``for` `(``int` `col=n-1; col>=0; col--)``    ``{``        ``for` `(``int` `row=0; row)``            ``int` `right = (col==n-1)? 0: goldTable[row][col+1];` `            ``// Gold collected on going to the cell to right up (/)``            ``int` `right_up = (row==0 || col==n-1)? 0:``                            ``goldTable[row-1][col+1];` `            ``// Gold collected on going to the cell to right down (\)``            ``int` `right_down = (row==m-1 || col==n-1)? 0:``                             ``goldTable[row+1][col+1];` `            ``// Max gold collected from taking either of the``            ``// above 3 paths``            ``goldTable[row][col] = gold[row][col] +``                              ``max(right, max(right_up, right_down));``                                                    ` `        ``}``    ``}` `    ``// The max amount of gold collected will be the max``    ``// value in first column of all rows``    ``int` `res = goldTable[0][0];``    ``for` `(``int` `i=1; i

## Java

 `// Java program to solve Gold Mine problem``import` `java.util.Arrays;` `class` `GFG {``    ` `    ``static` `final` `int` `MAX = ``100``;``    ` `    ``// Returns maximum amount of gold that ``    ``// can be collected when journey started ``    ``// from first column and moves allowed ``    ``// are right, right-up and right-down``    ``static` `int` `getMaxGold(``int` `gold[][], ``                              ``int` `m, ``int` `n)``    ``{``        ` `        ``// Create a table for storing ``        ``// intermediate results and initialize``        ``// all cells to 0. The first row of``        ``// goldMineTable gives the maximum ``        ``// gold that the miner can collect ``        ``// when starts that row``        ``int` `goldTable[][] = ``new` `int``[m][n];``        ` `        ``for``(``int``[] rows:goldTable)``            ``Arrays.fill(rows, ``0``);``    ` `        ``for` `(``int` `col = n-``1``; col >= ``0``; col--)``        ``{``            ``for` `(``int` `row = ``0``; row < m; row++)``            ``{``                ` `                ``// Gold collected on going to ``                ``// the cell on the right(->)``                ``int` `right = (col == n-``1``) ? ``0``                        ``: goldTable[row][col+``1``];``    ` `                ``// Gold collected on going to ``                ``// the cell to right up (/)``                ``int` `right_up = (row == ``0` `||``                               ``col == n-``1``) ? ``0` `:``                        ``goldTable[row-``1``][col+``1``];``    ` `                ``// Gold collected on going to ``                ``// the cell to right down (\)``                ``int` `right_down = (row == m-``1``                            ``|| col == n-``1``) ? ``0` `:``                          ``goldTable[row+``1``][col+``1``];``    ` `                ``// Max gold collected from taking``                ``// either of the above 3 paths``                ``goldTable[row][col] = gold[row][col]``                 ``+ Math.max(right, Math.max(right_up, ``                                       ``right_down));``                                                        ` `            ``}``        ``}``    ` `        ``// The max amount of gold collected will be``        ``// the max value in first column of all rows``        ``int` `res = goldTable[``0``][``0``];``        ` `        ``for` `(``int` `i = ``1``; i < m; i++)``            ``res = Math.max(res, goldTable[i][``0``]);``            ` `        ``return` `res;``    ``}``    ` `    ``//driver code``    ``public` `static` `void` `main(String arg[])``    ``{``        ``int` `gold[][]= { {``1``, ``3``, ``1``, ``5``},``                        ``{``2``, ``2``, ``4``, ``1``},``                        ``{``5``, ``0``, ``2``, ``3``},``                        ``{``0``, ``6``, ``1``, ``2``} };``                        ` `        ``int` `m = ``4``, n = ``4``;``        ` `        ``System.out.print(getMaxGold(gold, m, n));``    ``}``}` `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python program to solve``# Gold Mine problem` `MAX` `=` `100` `# Returns maximum amount of``# gold that can be collected``# when journey started from``# first column and moves``# allowed are right, right-up``# and right-down``def` `getMaxGold(gold, m, n):` `    ``# Create a table for storing``    ``# intermediate results``    ``# and initialize all cells to 0.``    ``# The first row of``    ``# goldMineTable gives the``    ``# maximum gold that the miner``    ``# can collect when starts that row``    ``goldTable ``=` `[[``0` `for` `i ``in` `range``(n)]``                        ``for` `j ``in` `range``(m)]` `    ``for` `col ``in` `range``(n``-``1``, ``-``1``, ``-``1``):``        ``for` `row ``in` `range``(m):` `            ``# Gold collected on going to``            ``# the cell on the right(->)``            ``if` `(col ``=``=` `n``-``1``):``                ``right ``=` `0``            ``else``:``                ``right ``=` `goldTable[row][col``+``1``]` `            ``# Gold collected on going to``            ``# the cell to right up (/)``            ``if` `(row ``=``=` `0` `or` `col ``=``=` `n``-``1``):``                ``right_up ``=` `0``            ``else``:``                ``right_up ``=` `goldTable[row``-``1``][col``+``1``]` `            ``# Gold collected on going to``            ``# the cell to right down (\)``            ``if` `(row ``=``=` `m``-``1` `or` `col ``=``=` `n``-``1``):``                ``right_down ``=` `0``            ``else``:``                ``right_down ``=` `goldTable[row``+``1``][col``+``1``]` `            ``# Max gold collected from taking``            ``# either of the above 3 paths``            ``goldTable[row][col] ``=` `gold[row][col] ``+` `max``(right, right_up, right_down)``                                                           ` `    ``# The max amount of gold``    ``# collected will be the max``    ``# value in first column of all rows``    ``res ``=` `goldTable[``0``][``0``]``    ``for` `i ``in` `range``(``1``, m):``        ``res ``=` `max``(res, goldTable[i][``0``])` `    ``return` `res``    ` `# Driver code``gold ``=` `[[``1``, ``3``, ``1``, ``5``],``    ``[``2``, ``2``, ``4``, ``1``],``    ``[``5``, ``0``, ``2``, ``3``],``    ``[``0``, ``6``, ``1``, ``2``]]` `m ``=` `4``n ``=` `4` `print``(getMaxGold(gold, m, n))` `# This code is contributed``# by Soumen Ghosh.              `

## C#

 `// C# program to solve Gold Mine problem ``using` `System; ` `class` `GFG ``{ ``    ``static` `int` `MAX = 100; ` `    ``// Returns maximum amount of gold that ``    ``// can be collected when journey started``    ``// from first column and moves allowed are ``    ``// right, right-up and right-down ``    ``static` `int` `getMaxGold(``int``[,] gold, ``                            ``int` `m, ``int` `n) ``    ``{ ``        ` `        ``// Create a table for storing intermediate ``        ``// results and initialize all cells to 0. ``        ``// The first row of goldMineTable gives``        ``// the maximum gold that the miner ``        ``// can collect when starts that row ``        ``int``[,] goldTable = ``new` `int``[m, n]; ``        ` `        ``for``(``int` `i = 0; i < m; i++)``            ``for``(``int` `j = 0; j < n; j++)``                ``goldTable[i, j] = 0;``    ` `        ``for` `(``int` `col = n - 1; col >= 0; col--) ``        ``{ ``            ``for` `(``int` `row = 0; row < m; row++) ``            ``{ ``                ``// Gold collected on going to ``                ``// the cell on the right(->) ``                ``int` `right = (col == n - 1) ? 0 :``                            ``goldTable[row, col + 1]; ``    ` `                ``// Gold collected on going to ``                ``// the cell to right up (/) ``                ``int` `right_up = (row == 0 || col == n - 1) ``                            ``? 0 : goldTable[row-1,col+1]; ``    ` `                ``// Gold collected on going ``                ``// to the cell to right down (\) ``                ``int` `right_down = (row == m - 1 || col == n - 1) ``                                ``? 0 : goldTable[row + 1, col + 1]; ``    ` `                ``// Max gold collected from taking ``                ``// either of the above 3 paths ``                ``goldTable[row, col] = gold[row, col] + ``                                ``Math.Max(right, Math.Max(right_up, ``                                                    ``right_down)); ``            ``} ``        ``} ``    ` `        ``// The max amount of gold collected will be the max ``        ``// value in first column of all rows ``        ``int` `res = goldTable[0, 0]; ``        ``for` `(``int` `i = 1; i < m; i++) ``            ``res = Math.Max(res, goldTable[i, 0]); ``        ``return` `res; ``    ``} ``    ` `    ``// Driver Code ``    ``static` `void` `Main() ``    ``{ ``        ``int``[,] gold = ``new` `int``[,]{{1, 3, 1, 5}, ``                                ``{2, 2, 4, 1}, ``                                ``{5, 0, 2, 3}, ``                                ``{0, 6, 1, 2} ``                                ``}; ``        ``int` `m = 4, n = 4; ``        ``Console.Write(getMaxGold(gold, m, n)); ``    ``}``}` `// This code is contributed by DrRoot_`

## PHP

 `= 0 ; ``\$col``--) ``    ``{``        ``for` `(``\$row` `= 0 ; ``\$row` `< ``\$m` `; ``\$row``++)``        ``{` `            ``// Gold collected on going to ``            ``// the cell on the right(->) ``            ``if` `(``\$col` `== ``\$n` `- 1)``                ``\$right` `= 0 ;``            ``else``                ``\$right` `= ``\$goldTable``[``\$row``][``\$col` `+ 1];` `            ``// Gold collected on going to ``            ``// the cell to right up (/) ``            ``if` `(``\$row` `== 0 ``or` `\$col` `== ``\$n` `- 1) ``                ``\$right_up` `= 0 ;``            ``else``                ``\$right_up` `= ``\$goldTable``[``\$row` `- 1][``\$col` `+ 1]; ` `            ``// Gold collected on going to ``            ``// the cell to right down (\) ``            ``if` `(``\$row` `== ``\$m` `- 1 ``or` `\$col` `== ``\$n` `- 1)``                ``\$right_down` `= 0 ;``            ``else``                ``\$right_down` `= ``\$goldTable``[``\$row` `+ 1][``\$col` `+ 1];` `            ``// Max gold collected from taking ``            ``// either of the above 3 paths ``            ``\$goldTable``[``\$row``][``\$col``] = ``\$gold``[``\$row``][``\$col``] + ``                                 ``max(``\$right``, ``\$right_up``, ``                                             ``\$right_down``); ``        ``}``    ``}``    ` `    ``// The max amount of gold collected will be the ``    ``// max value in first column of all rows ``    ``\$res` `= ``\$goldTable``[0][0] ;``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$m``; ``\$i``++) ``        ``\$res` `= max(``\$res``, ``\$goldTable``[``\$i``][0]); ` `    ``return` `\$res``;``}``    ` `// Driver code ``\$gold` `= ``array``(``array``(1, 3, 1, 5), ``              ``array``(2, 2, 4, 1), ``              ``array``(5, 0, 2, 3), ``              ``array``(0, 6, 1, 2));` `\$m` `= 4 ;``\$n` `= 4 ;` `echo` `getMaxGold(``\$gold``, ``\$m``, ``\$n``) ;` `// This code is contributed by Ryuga``?>`

## Javascript

 ``

Output
`16`

Time Complexity: O(m*n)
Auxiliary Space: O(m*n)

Space Complex Solution: In the above-given method we require O(m x n) space. This will not be suitable if the length of strings is greater than 2000 as it can only create 2D array of 2000 x 2000. To fill a row in DP array we require only one row the upper row. For example, if we are filling the i = 10 rows in DP array we require only values of 9th row. So we simply create a DP array of 2 x str1 length. This approach reduces the space complexity. Here is the Python3 implementation of the above-mentioned problem.

## C++

 `// C++ program to solve``// Gold Mine problem``#include ``using` `namespace` `std;` `int`  `MAX = 100;` `// Returns maximum amount of``// gold that can be collected``// when journey started from``// first column and moves``// allowed are right, right-up``// and right-down``int` `getMaxGold(vector>  gold, ``int` `m, ``int` `n)``{``  ``// Create a table for storing``  ``// intermediate results``  ``// and initialize all cells to 0.``  ``// The first row of``  ``// goldMineTable gives the``  ``// maximum gold that the miner``  ``// can collect when starts that row``  ``int` `goldTable[m][2];``  ``for` `(``int` `i = 0; i < m; i++)``  ``{``    ``goldTable[i][0] = 0;``    ``goldTable[i][1] = 0;``  ``}` `  ``for` `(``int` `col = n - 1; col > -1; col--)``  ``{``    ``for` `(``int` `row = 0; row < m; row++)``    ``{``      ``int` `right, right_up, right_down;``      ``// Gold collected on going to``      ``// the cell on the right(->)``      ``if` `(col == n-1)``        ``right = 0;``      ``else``        ``right = goldTable[row][(col+1)%2];` `      ``// Gold collected on going to``      ``// the cell to right up (/)``      ``if` `(row == 0 || col == n-1)``        ``right_up = 0;``      ``else``        ``right_up = goldTable[row-1][(col+1)%2];` `      ``// Gold collected on going to``      ``// the cell to right down (\)``      ``if` `(row == m-1 || col == n-1)``        ``right_down = 0;``      ``else``        ``right_down = goldTable[row+1][(col+1)%2];` `      ``// Max gold collected from taking``      ``// either of the above 3 paths``      ``goldTable[row][col%2] = gold[row][col] + max(right, max(right_up, right_down));``    ``}``  ``}` `  ``// The max amount of gold``  ``// collected will be the max``  ``// value in first column of all rows``  ``int` `res = goldTable[0][0];``  ``for` `(``int` `i = 1; i < m; i++) ``    ``res = max(res, goldTable[i][0]);` `  ``return` `res;``}` `// Driver code``int` `main()``{``  ``int` `m = 4;``  ``int` `n = 4;` `  ``vector> gold = {{ 1, 3, 1, 5},``                              ``{2, 2, 4, 1},``                              ``{5, 0, 2, 3},``                              ``{0, 6, 1, 2}};`  `  ``cout << getMaxGold(gold, m, n) << endl;``}` `// This code is contributed``// by phasing17       `

## Java

 `// Java program to solve``// Gold Mine problem``import` `java.io.*;``class` `GFG``{``    ``static` `int`  `MAX = ``100``;``    ` `    ``// Returns maximum amount of``    ``// gold that can be collected``    ``// when journey started from``    ``// first column and moves``    ``// allowed are right, right-up``    ``// and right-down``    ``static` `int` `getMaxGold(``int` `gold[][], ``int` `m, ``int` `n)``    ``{``      ``// Create a table for storing``      ``// intermediate results``      ``// and initialize all cells to 0.``      ``// The first row of``      ``// goldMineTable gives the``      ``// maximum gold that the miner``      ``// can collect when starts that row``      ``int` `goldTable[][] = ``new` `int``[m][``2``];``      ``for` `(``int` `i = ``0``; i < m; i++)``      ``{``        ``goldTable[i][``0``] = ``0``;``        ``goldTable[i][``1``] = ``0``;``      ``}``    ` `      ``for` `(``int` `col = n - ``1``; col > -``1``; col--)``      ``{``        ``for` `(``int` `row = ``0``; row < m; row++)``        ``{``          ``int` `right, right_up, right_down;``          ``// Gold collected on going to``          ``// the cell on the right(->)``          ``if` `(col == n-``1``)``            ``right = ``0``;``          ``else``            ``right = goldTable[row][(col+``1``)%``2``];``    ` `          ``// Gold collected on going to``          ``// the cell to right up (/)``          ``if` `(row == ``0` `|| col == n-``1``)``            ``right_up = ``0``;``          ``else``            ``right_up = goldTable[row-``1``][(col+``1``)%``2``];``    ` `          ``// Gold collected on going to``          ``// the cell to right down (\)``          ``if` `(row == m-``1` `|| col == n-``1``)``            ``right_down = ``0``;``          ``else``            ``right_down = goldTable[row+``1``][(col+``1``)%``2``];``    ` `          ``// Max gold collected from taking``          ``// either of the above 3 paths``          ``goldTable[row][col%``2``] = gold[row][col] + Math.max(right, Math.max(right_up, right_down));``        ``}``      ``}``    ` `      ``// The max amount of gold``      ``// collected will be the max``      ``// value in first column of all rows``      ``int` `res = goldTable[``0``][``0``];``      ``for` `(``int` `i = ``1``; i < m; i++) ``        ``res = Math.max(res, goldTable[i][``0``]);``    ` `      ``return` `res;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``      ``int` `m = ``4``;``      ``int` `n = ``4``;``    ` `      ``int``[][] gold = {{ ``1``, ``3``, ``1``, ``5``},``                                  ``{``2``, ``2``, ``4``, ``1``},``                                  ``{``5``, ``0``, ``2``, ``3``},``                                  ``{``0``, ``6``, ``1``, ``2``}};``    ` `    ` `      ``System.out.println(getMaxGold(gold, m, n));``    ``}``}` `// This code is contributed``// by phasing17       `

## Python3

 `# Python program to solve``# Gold Mine problem` `MAX` `=` `100` `# Returns maximum amount of``# gold that can be collected``# when journey started from``# first column and moves``# allowed are right, right-up``# and right-down``def` `getMaxGold(gold, m, n):` `    ``# Create a table for storing``    ``# intermediate results``    ``# and initialize all cells to 0.``    ``# The first row of``    ``# goldMineTable gives the``    ``# maximum gold that the miner``    ``# can collect when starts that row``    ``goldTable ``=` `[[``0` `for` `i ``in` `range``(``2``)]``                        ``for` `j ``in` `range``(m)]` `    ``for` `col ``in` `range``(n``-``1``, ``-``1``, ``-``1``):``        ``for` `row ``in` `range``(m):` `            ``# Gold collected on going to``            ``# the cell on the right(->)``            ``if` `(col ``=``=` `n``-``1``):``                ``right ``=` `0``            ``else``:``                ``right ``=` `goldTable[row][(col``+``1``)``%``2``]` `            ``# Gold collected on going to``            ``# the cell to right up (/)``            ``if` `(row ``=``=` `0` `or` `col ``=``=` `n``-``1``):``                ``right_up ``=` `0``            ``else``:``                ``right_up ``=` `goldTable[row``-``1``][(col``+``1``)``%``2``]` `            ``# Gold collected on going to``            ``# the cell to right down (\)``            ``if` `(row ``=``=` `m``-``1` `or` `col ``=``=` `n``-``1``):``                ``right_down ``=` `0``            ``else``:``                ``right_down ``=` `goldTable[row``+``1``][(col``+``1``)``%``2``]` `            ``# Max gold collected from taking``            ``# either of the above 3 paths``            ``goldTable[row][col``%``2``] ``=` `gold[row][col] ``+` `max``(right, right_up, right_down)``                                                            ` `    ``# The max amount of gold``    ``# collected will be the max``    ``# value in first column of all rows``    ``res ``=` `goldTable[``0``][``0``]``    ``for` `i ``in` `range``(``1``, m):``        ``res ``=` `max``(res, goldTable[i][``0``])` `    ``return` `res``    ` `# Driver code``gold ``=` `[[``1``, ``3``, ``1``, ``5``],``    ``[``2``, ``2``, ``4``, ``1``],``    ``[``5``, ``0``, ``2``, ``3``],``    ``[``0``, ``6``, ``1``, ``2``]]` `m ``=` `4``n ``=` `4` `print``(getMaxGold(gold, m, n))` `# This code is contributed``# by Bhagirath Sarvaiya.            `

## C#

 `// C# program to solve``// Gold Mine problem``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``    ``int`  `MAX = 100;``    ` `    ``// Returns maximum amount of``    ``// gold that can be collected``    ``// when journey started from``    ``// first column and moves``    ``// allowed are right, right-up``    ``// and right-down``    ``static` `int` `getMaxGold(``int``[,] gold, ``int` `m, ``int` `n)``    ``{``      ``// Create a table for storing``      ``// intermediate results``      ``// and initialize all cells to 0.``      ``// The first row of``      ``// goldMineTable gives the``      ``// maximum gold that the miner``      ``// can collect when starts that row``      ``int``[,] goldTable = ``new` `int``[m, 2];``      ``for` `(``int` `i = 0; i < m; i++)``      ``{``        ``goldTable[i, 0] = 0;``        ``goldTable[i, 1] = 0;``      ``}``    ` `      ``for` `(``int` `col = n - 1; col > -1; col--)``      ``{``        ``for` `(``int` `row = 0; row < m; row++)``        ``{``          ``int` `right, right_up, right_down;``          ``// Gold collected on going to``          ``// the cell on the right(->)``          ``if` `(col == n-1)``            ``right = 0;``          ``else``            ``right = goldTable[row, (col+1)%2];``    ` `          ``// Gold collected on going to``          ``// the cell to right up (/)``          ``if` `(row == 0 || col == n-1)``            ``right_up = 0;``          ``else``            ``right_up = goldTable[row-1, (col+1)%2];``    ` `          ``// Gold collected on going to``          ``// the cell to right down (\)``          ``if` `(row == m-1 || col == n-1)``            ``right_down = 0;``          ``else``            ``right_down = goldTable[row+1, (col+1)%2];``    ` `          ``// Max gold collected from taking``          ``// either of the above 3 paths``          ``goldTable[row, col%2] = gold[row, col] + Math.Max(right, Math.Max(right_up, right_down));``        ``}``      ``}``    ` `      ``// The max amount of gold``      ``// collected will be the max``      ``// value in first column of all rows``      ``int` `res = goldTable[0, 0];``      ``for` `(``int` `i = 1; i < m; i++) ``        ``res = Math.Max(res, goldTable[i, 0]);``    ` `      ``return` `res;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``      ``int` `m = 4;``      ``int` `n = 4;``    ` `      ``int``[,] gold = {{ 1, 3, 1, 5},``                                  ``{2, 2, 4, 1},``                                  ``{5, 0, 2, 3},``                                  ``{0, 6, 1, 2}};``    ` `    ` `     ``Console.WriteLine(getMaxGold(gold, m, n));``    ``}``}` `// This code is contributed``// by phasing17       `

## Javascript

 `// JS program to solve``// Gold Mine problem` `let  MAX = 100` `// Returns maximum amount of``// gold that can be collected``// when journey started from``// first column and moves``// allowed are right, right-up``// and right-down``function` `getMaxGold(gold, m, n)``{``    ``// Create a table for storing``    ``// intermediate results``    ``// and initialize all cells to 0.``    ``// The first row of``    ``// goldMineTable gives the``    ``// maximum gold that the miner``    ``// can collect when starts that row``    ``let goldTable = ``new` `Array(m);``    ``for` `(``var` `i = 0; i < m; i++)``        ``goldTable[i] = ``new` `Array(2).fill(0);``    ` `    ``for` `(``var` `col = n - 1; col > -1; col--)``    ``{``        ``for` `(``var` `row = 0; row < m; row++)``        ``{``            ``let right, right_up, right_down;``            ``// Gold collected on going to``            ``// the cell on the right(->)``            ``if` `(col == n-1)``                ``right = 0;``            ``else``                ``right = goldTable[row][(col+1)%2]` `            ``// Gold collected on going to``            ``// the cell to right up (/)``            ``if` `(row == 0 || col == n-1)``                ``right_up = 0``            ``else``                ``right_up = goldTable[row-1][(col+1)%2]` `            ``// Gold collected on going to``            ``// the cell to right down (\)``            ``if` `(row == m-1 || col == n-1)``                ``right_down = 0``            ``else``                ``right_down = goldTable[row+1][(col+1)%2]` `            ``// Max gold collected from taking``            ``// either of the above 3 paths``            ``goldTable[row][col%2] = gold[row][col] + Math.max(right, Math.max(right_up, right_down))``        ``}``    ``}``                                                            ` `    ``// The max amount of gold``    ``// collected will be the max``    ``// value in first column of all rows``    ``let res = goldTable[0][0]``    ``for` `(``var` `i = 1; i < m; i++) ``        ``res = Math.max(res, goldTable[i][0])` `    ``return` `res``}``    ` `// Driver code``let gold = [[1, 3, 1, 5],``    ``[2, 2, 4, 1],``    ``[5, 0, 2, 3],``    ``[0, 6, 1, 2]]` `let m = 4``let n = 4` `console.log(getMaxGold(gold, m, n))` `// This code is contributed``// by phasing17       `

Output
`16`

Time Complexity: O(m*n)
Auxiliary Space: O(m*2)

->Directed Array Approach

Time Complexity – O(m*n)

Space Complexity – O(m*n)

## C++

 `#include ``using` `namespace` `std;` `int` `dx[3] = { -1, 0, 1 };``int` `dy[3] = { -1, -1, -1 };` `bool` `isValid(``int` `x, ``int` `y, ``int` `n, ``int` `m)``{``    ``if` `(x >= 0 && x < n && y >= 0 && y < m)``        ``return` `true``;``    ``return` `false``;``}` `int` `maxGold(``int` `n, ``int` `m, vector > M)``{``    ``int` `dp[n][m];` `    ``// initialisation of first col``    ``for` `(``int` `i = 0; i < n; i++)``        ``dp[i][0] = M[i][0];` `    ``for` `(``int` `j = 1; j < m; j++) {``        ``for` `(``int` `i = 0; i < n; i++) {``            ``int` `mx = INT_MIN;``            ``for` `(``int` `k = 0; k < 3; k++) {``                ``int` `x = i + dx[k];``                ``int` `y = j + dy[k];` `                ``if` `(isValid(x, y, n, m))``                    ``mx = max(mx, dp[x][y] + M[i][j]);``            ``}``            ``dp[i][j] = mx;``        ``}``    ``}` `    ``int` `ans = INT_MIN;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``ans = max(ans, dp[i][m - 1]);``    ``}``    ``return` `ans;``}` `int` `main()``{` `    ``int` `n = 4;``    ``int` `m = 4;` `    ``vector > gold = { { 1, 3, 1, 5 },``                                  ``{ 2, 2, 4, 1 },``                                  ``{ 5, 0, 2, 3 },``                                  ``{ 0, 6, 1, 2 } };` `    ``cout << ``"Max Amount of gold collected = "``         ``<< maxGold(n, m, gold);``    ``return` `0;``}`

## Java

 `// java code to implement the approach` `import` `java.util.*;` `class` `GFG {``  ``static` `int``[] dx``    ``= ``new` `int``[] { -``1``, ``0``, ``1` `}; ``// used to traverse grid``  ``static` `int``[] dy``    ``= ``new` `int``[] { -``1``, -``1``, -``1` `}; ``// used to traverse grid` `  ``// method to check if given point is valid or not``  ``static` `boolean` `isValid(``int` `x, ``int` `y, ``int` `n, ``int` `m)``  ``{``    ``if` `(x >= ``0` `&& x < n && y >= ``0` `&& y < m)``      ``return` `true``;``    ``return` `false``;``  ``}` `  ``// method to find the max amount of gold that can be``  ``// collected``  ``static` `int` `maxGold(``int` `n, ``int` `m, ``int``[][] M)``  ``{``    ``int``[][] dp = ``new` `int``[n][m];` `    ``// initialisation of first col``    ``for` `(``int` `i = ``0``; i < n; i++)``      ``dp[i][``0``] = M[i][``0``];` `    ``// Dynamic programming``    ``for` `(``int` `j = ``1``; j < m; j++) {``      ``for` `(``int` `i = ``0``; i < n; i++) {``        ``int` `mx = Integer.MIN_VALUE;``        ``for` `(``int` `k = ``0``; k < ``3``; k++) {``          ``int` `x = i + dx[k];``          ``int` `y = j + dy[k];` `          ``if` `(isValid(x, y, n, m))``            ``mx = Math.max(mx,``                          ``dp[x][y] + M[i][j]);``        ``}``        ``dp[i][j] = mx;``      ``}``    ``}` `    ``int` `ans = Integer.MIN_VALUE;` `    ``// find max value from last column of dp table``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``ans = Math.max(ans, dp[i][m - ``1``]);``    ``}``    ``return` `ans;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `n = ``4``;``    ``int` `m = ``4``;` `    ``int``[][] gold = ``new` `int``[][] { { ``1``, ``3``, ``1``, ``5` `},``                                ``{ ``2``, ``2``, ``4``, ``1` `},``                                ``{ ``5``, ``0``, ``2``, ``3` `},``                                ``{ ``0``, ``6``, ``1``, ``2` `} };` `    ``// Function call``    ``System.out.println(``"Max Amount of gold collected = "``                       ``+ maxGold(n, m, gold));``  ``}``}` `// This code is contributed by phasing17.`

## Python3

 `# Python3 code to implement the approach``dx ``=` `[``-``1``, ``0``, ``1``]``dy ``=` `[``-``1``, ``-``1``, ``-``1``]` `# This function checks if a given coordinate is valid``def` `is_valid(x, y, n, m):``    ``if` `x >``=` `0` `and` `x < n ``and` `y >``=` `0` `and` `y < m:``        ``return` `True``    ``return` `False` `# This function finds the maximum gold quantity``def` `max_gold(n, m, M):``    ` `    ``# Initializing dp``    ``dp ``=` `[[``0` `for` `j ``in` `range``(m)] ``for` `i ``in` `range``(n)]``    ``for` `i ``in` `range``(n):``        ``dp[i][``0``] ``=` `M[i][``0``]``        ` `    ``# Building the dp``    ``for` `j ``in` `range``(``1``, m):``        ``for` `i ``in` `range``(n):``            ``mx ``=` `float``(``'-inf'``)``            ``for` `k ``in` `range``(``3``):``                ``x ``=` `i ``+` `dx[k]``                ``y ``=` `j ``+` `dy[k]``                ``if` `is_valid(x, y, n, m):``                    ``mx ``=` `max``(mx, dp[x][y] ``+` `M[i][j])``            ``dp[i][j] ``=` `mx``    ``ans ``=` `float``(``'-inf'``)``    ` `    ``# Getting the final answer``    ``for` `i ``in` `range``(n):``        ``ans ``=` `max``(ans, dp[i][m ``-` `1``])``    ``return` `ans`  `# Driver code``n ``=` `4``m ``=` `4``gold ``=` `[``    ``[``1``, ``3``, ``1``, ``5``],``    ``[``2``, ``2``, ``4``, ``1``],``    ``[``5``, ``0``, ``2``, ``3``],``    ``[``0``, ``6``, ``1``, ``2``],``]` `# Function call``print``(``"Max Amount of gold collected = "``, max_gold(n, m, gold))` `# This code is contributed by phasing17`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `GFG {``  ``static` `int``[] dx``    ``= ``new` `int``[] { -1, 0, 1 }; ``// used to traverse grid``  ``static` `int``[] dy``    ``= ``new` `int``[] { -1, -1, -1 }; ``// used to traverse grid` `  ``// method to check if given point is valid or not``  ``static` `bool` `isValid(``int` `x, ``int` `y, ``int` `n, ``int` `m)``  ``{``    ``if` `(x >= 0 && x < n && y >= 0 && y < m)``      ``return` `true``;``    ``return` `false``;``  ``}` `  ``// method to find the max amount of gold that can be``  ``// collected``  ``static` `int` `maxGold(``int` `n, ``int` `m, ``int``[][] M)``  ``{``    ``int``[][] dp = ``new` `int``[n][];``    ``for` `(``int` `i = 0; i < n; i++)``      ``dp[i] = ``new` `int``[m];` `    ``// initialisation of first col``    ``for` `(``int` `i = 0; i < n; i++)``      ``dp[i][0] = M[i][0];` `    ``// Dynamic programming``    ``for` `(``int` `j = 1; j < m; j++) {``      ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `mx = Int32.MinValue;``        ``for` `(``int` `k = 0; k < 3; k++) {``          ``int` `x = i + dx[k];``          ``int` `y = j + dy[k];` `          ``if` `(isValid(x, y, n, m))``            ``mx = Math.Max(mx,``                          ``dp[x][y] + M[i][j]);``        ``}``        ``dp[i][j] = mx;``      ``}``    ``}` `    ``int` `ans = Int32.MinValue;` `    ``// find max value from last column of dp table``    ``for` `(``int` `i = 0; i < n; i++) {``      ``ans = Math.Max(ans, dp[i][m - 1]);``    ``}``    ``return` `ans;``  ``}` `  ``// Driver code``  ``static` `void` `Main(``string``[] args)``  ``{``    ``int` `n = 4;``    ``int` `m = 4;` `    ``int``[][] gold``      ``= ``new` `int``[][] { ``new` `int``[] { 1, 3, 1, 5 },``                     ``new` `int``[] { 2, 2, 4, 1 },``                     ``new` `int``[] { 5, 0, 2, 3 },``                     ``new` `int``[] { 0, 6, 1, 2 } };` `    ``// Function call``    ``Console.WriteLine(``"Max Amount of gold collected = "``                      ``+ maxGold(n, m, gold));``  ``}``}` `// This code is contributed by phasing17.`

## Javascript

 `// JavaScript implementation of the above approach` `const dx = [-1, 0, 1];``const dy = [-1, -1, -1];` `// This function checks if a given point coordinate location is valid``function` `isValid(x, y, n, m) {``    ``if` `(x >= 0 && x < n && y >= 0 && y < m) {``        ``return` `true``;``    ``}``    ``return` `false``;``}` `function` `maxGold(n, m, M) {``    ` `    ``// Initializing DP array ``    ` `    ``let dp = ``new` `Array(n);``    ``for` `(let i = 0; i < dp.length; i++) {``        ``dp[i] = ``new` `Array(m);``    ``}` `    ``// initialisation of first col``    ``for` `(let i = 0; i < n; i++) {``        ``dp[i][0] = M[i][0];``    ``}``    ` `    ` `    ``// Performing DP``    ``for` `(let j = 1; j < m; j++) {``        ``for` `(let i = 0; i < n; i++) {``            ``let mx = Number.MIN_SAFE_INTEGER;``            ``for` `(let k = 0; k < 3; k++) {``                ``let x = i + dx[k];``                ``let y = j + dy[k];` `                ``if` `(isValid(x, y, n, m)) {``                    ``mx = Math.max(mx, dp[x][y] + M[i][j]);``                ``}``            ``}``            ``dp[i][j] = mx;``        ``}``    ``}` `    ``let ans = Number.MIN_SAFE_INTEGER;``    ` `    ``// Getting the answer``    ``for` `(let i = 0; i < n; i++) {``        ``ans = Math.max(ans, dp[i][m - 1]);``    ``}``    ``return` `ans;``}` `// Driver Code``const n = 4;``const m = 4;` `const gold = [``    ``[1, 3, 1, 5],``    ``[2, 2, 4, 1],``    ``[5, 0, 2, 3],``    ``[0, 6, 1, 2],``];` `console.log(``"Max Amount of gold collected = "` `+ maxGold(n, m, gold));`  `// This code is contributed by phasing17`

Output
`Max Amount of gold collected = 16`

Previous
Next