Related Articles
Gold Mine Problem
• Difficulty Level : Medium
• Last Updated : 21 Apr, 2021

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 at first column but can be at 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 right or diagonally down towards the right. Find out 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)->(2,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

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++14

 `// 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;``    ``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 rigth(->)``            ``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 rigth(->)``            ``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`` ;``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$m``; ``\$i``++)``        ``\$res` `= max(``\$res``, ``\$goldTable``[``\$i``]);` `    ``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``?>`
Output
`16`

Time Complexity :O(m*n)
Space Complexity :O(m*n)
This article is contributed by Rakesh Kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.