Matrix traversal not doing optimal path - arrays

Question

I have encountered the following problem that I am attempting to solve:
In a N x N grid representing a field of cherries, each cell is one of three possible integers.
0 means the cell is empty, so you can pass through;
1 means the cell contains a cherry, that you can pick up and pass through;
-1 means the cell contains a thorn that blocks your way.
Your task is to collect maximum number of cherries possible by following the rules below:
Starting at the position (0, 0) and reaching (N-1, N-1) by moving right or down through valid path cells (cells with > value 0 or 1);
After reaching (N-1, N-1), returning to (0, 0) by moving left or up through valid path cells;
When passing through a path cell containing a cherry, you pick it up and the cell becomes an empty cell (0);
If there is no valid path between (0, 0) and (N-1, N-1), then no cherries can be collected.
Example 1:
Input: grid =
[[0, 1, -1],
[1, 0, -1],
[1, 1, 1]]
Output: 5
Explanation:
The player started at (0, 0) and went down, down, right right to reach (2, 2).
4 cherries were picked up during this single trip, and the matrix becomes [[0,1,-1],[0,0,-1],[0,0,0]].
Then, the player went left, up, up, left to return home, picking up one more cherry.
The total number of cherries picked up is 5, and this is the maximum possible.
Note:
grid is an N by N 2D array, with 1 <= N <= 50.
Each grid[i][j] is an integer in the set {-1, 0, 1}.
It is guaranteed that grid[0][0] and grid[N-1][N-1] are not -1.
So I need to write a function cherryPickup that takes a grid and returns the maximum score.
My first suboptimal attempt (written in Go) is the following, which supposedly would try to walk every possible path, storing the score in a slice upon round-trip path completion, and then return the greatest score present in the slice:
func cherryPickup(grid [][]int) int {
values := []int{}
pVals := &values
finalPoints := 0
// Begin top-down path
traverseAndCollectTopDown(grid, 0, 0, 0, pVals)
// Find max value in slice
for i, pathPoints := range values {
if i == 0 || pathPoints > finalPoints {
finalPoints = pathPoints
}
}
return finalPoints
}
func isTraversable(grid [][]int, x, y int) bool {
return (grid[x][y] != -1)
}
func isOnBounds(grid [][]int, x, y int) bool {
return (x < len(grid) && y < len(grid[0]) && x >= 0 && y >= 0)
}
func traverseAndCollectTopDown(grid [][]int, x, y, points int, vals *[]int) {
// Collect point before continuing
if grid[x][y] == 1 {
grid[x][y] = 0
points++
}
// If reached bottom, begin bottom-up path
if (x == len(grid)-1) && (y == len(grid[0])-1) {
traverseAndCollectBottomUp(grid, x, y, points, vals)
return
}
// Go Down
if isOnBounds(grid, x+1, y) && isTraversable(grid, x+1, y) {
traverseAndCollectTopDown(grid, x+1, y, points, vals)
}
// Go Right
if isOnBounds(grid, x, y+1) && isTraversable(grid, x, y+1) {
traverseAndCollectTopDown(grid, x, y+1, points, vals)
}
}
func traverseAndCollectBottomUp(grid [][]int, x, y, points int, vals *[]int) {
if grid[x][y] == 1 {
grid[x][y] = 0
points++
}
if x == 0 && y == 0 {
*vals = append(*vals, points)
return
}
// Go Up
if isOnBounds(grid, x-1, y) && isTraversable(grid, x-1, y) {
traverseAndCollectBottomUp(grid, x-1, y, points, vals)
}
// Go Left
if isOnBounds(grid, x, y-1) && isTraversable(grid, x, y-1) {
traverseAndCollectBottomUp(grid, x, y-1, points, vals)
}
}
Currently it passes a bunch of tests, but this one is failing and I don't know why.
Input: [[1,1,1,1,0,0,0],[0,0,0,1,0,0,0],[0,0,0,1,0,0,1],[1,0,0,1,0,0,0],[0,0,0,1,0,0,0],[0,0,0,1,0,0,0],[0,0,0,1,1,1,1]]
Output: 10
Expected: 15
I get the way this grid must score the 15 points, however, why does my code fail to travel the winning path and only scores 10? Also, do you recommend any terminal utilities, programs or strategies to help visualize better what is happening on every run?
Thanks in advance!

Answer 1

The parameter you are using to traverseAndCollectTopDown / traverseAndCollectBottomUp is a grid [][]int. You are modifying that and then passing it directly into other functions (recursively). In go a slice is effectively passed by reference meaning that when one of your routines edits the slice this impacts the slice held by all of the other routines too (so as soon as one path finds a '1' it gets removed and another path going through the same cell will find a '0' there).
To fix this take a copy of grid before making a recursive call e.g. call grid = copyGrid(grid) in traverseAndCollectTopDown / traverseAndCollectBottomUp before modifying grid.
func copyGrid(in [][]int) [][]int {
duplicate := make([][]int, len(in))
for i := range in {
duplicate[i] = make([]int, len(in[i]))
copy(duplicate[i], in[i])
}
return duplicate
}