Why does only backtracking work in this scenario? - c++

Question

I am solving this question on LeetCode.com:
In a gold mine grid of size m * 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:- (a) Every time you are located in a cell you will collect all the gold in that cell; (b) From your position you can walk one step to the left, right, up or down. (c) You can't visit the same cell more than once; (d) Never visit a cell with 0 gold. (e) You can start and stop collecting gold from any position in the grid that has some gold.
For the grid: [[0,6,0],[5,8,7],[0,9,0]] the output is: 24.
I wrote the code below:
class Solution {
public:
int dig(vector<vector<int>>& grid, int i, int j) {
if(i>=grid.size() || i<0 || j>=grid[0].size() || j<0 || grid[i][j]==0) return 0;
//change begins...
int gold=0;
gold+=grid[i][j];
grid[i][j]=0;
gold+=max(dig(grid, i+1, j), max(dig(grid, i, j+1), max(dig(grid, i-1, j), dig(grid, i, j-1))));
return gold;
//change ends...
}
int getMaximumGold(vector<vector<int>>& grid) {
vector<vector<int>> gridCopy=grid;
int maxGold=0;
for(int i=0; i<grid.size(); i++) {
for(int j=0; j<grid[0].size(); j++) {
if(grid[i][j]!=0) {
maxGold=max(maxGold, dig(gridCopy, i, j));
gridCopy=grid;
}
}
}
return maxGold;
}
};
However, it breaks on the input [[1,0,7,0,0,0],[2,0,6,0,1,0],[3,5,6,7,4,2],[4,3,1,0,2,0],[3,0,5,0,20,0]]; yielding 58 instead of 60.
There's another code that I found here, which is identical, except in the commented part above, wherein they have the below lines instead:
g[i][j] = -g[i][j];
auto res = max({ dfs(g, i + 1, j), dfs(g, i, j + 1), dfs(g, i - 1, j), dfs(g, i, j - 1) });
g[i][j] = -g[i][j];
return g[i][j] + res;
(And of course, they don't assign grid to gridCopy in the nested for loop, since they revert the modified grid back to its original form).
I understand they are backtracking, while I am not. But I am unable to understand what I am doing incorrect, since logically, I am doing the exact same thing. I used debug statements to trace the issue, but it is becoming difficult to follow along since there are many recursive calls.
Could someone please point out what is the logical fallacy in my code above?
Thanks!

Answer 1

All your recursive calls might modify the grid, and don't restore it.
That means that the first visit to a cell will block it for all other subsequent attempts.
For instance, if dig(grid, i+1, j) is evaluated first, none of the cells that were visited during that computation are available when you do the other three directions.
If your code happens to start in the top left corner and go downwards first in your example, you will visit 1-2-3-4-3 and get stuck.
After that walk, there is no path from the top left corner any more, even though there were plenty of them from the beginning, and some of them pay a lot more than 13.
(You might think that you're going to find a path from either direction, but it depends on the evaluation order.)
Shared mutable state and recursion is a very tricky combination.

Answer 2

One thing which seems wrong in your code is:
//change begins...
int gold=0;
gold+=grid[i][j];
grid[i][j]=0;
gold+=max(dig(grid, i+1, j), max(dig(grid, i, j+1), max(dig(grid, i-1, j), dig(grid, i, j-1))));
return gold;
//change ends...
Here you have mutated the value of grid[i][j] and that changed value is impacting your input, i.e. your input set is wrong now. Since the value of the grid[i][j] is changed and thus this will impact the rest of the calculation.
What you can do is store the initial value of grid[i][j] somewhere in that recursion stack and reassign back to the grid[i][j] after you are done exploring all paths from that node.
eg: a slight modification in your logic
//change begins...
int gold=0;
gold+=grid[i][j];
int temp = grid[i][j];
grid[i][j]=0;
gold+=max(dig(grid, i+1, j), max(dig(grid, i, j+1), max(dig(grid, i-1, j), dig(grid, i, j-1))));
grid[i][j] = temp;
return gold;
//change ends...
You can also save creating a memory in your recursion stack if you use the solution there in your question.
Just to answer your concern why only backtracking can solve this problem:
You need to understand your solution, which seems like:
look at each grid item if that can be part of the solution set.
for that, you select one grid item (where item value should be greater than 0)
then you explore all surroundings from that item. And using DFS you keep on exploring their surroundings and their surroundings, etc, until the exit condition is met.
Now, in your solution, you have mutated the value of grid[i][j] (for understanding purpose, let us say grid[2][3] is mutated) which is fine if and only if that item selected is present in the final solution set.
But, while exploring other possibilities, if you may happen to find some possibility with a greater number of golds present. Then there also grid[2][3] will be involved. Which you have marked as 0, i.e. the calculation for that node will go wrong.
So, you need to restore the original value to the grid item grid[i][j]. The reason you are making that 0 is you don't want to include it again as you have already visited. But for other solution sets, you need the original value to be present there.