# 5 Best Ways to Find the Maximum Number of Coins You Can Collect in Python

Rate this post

π‘ Problem Formulation: Imagine a board game where coins are scattered across various cells of a grid. The objective is to collect the maximum number of coins following certain rules, such as only moving right or down. Given a grid with non-negative integers representing coin counts, how can we program a Python function to return the maximum number of coins that can be collected? For instance, input [[0,3,1], [2,0,0], [4,6,0]] should yield an output of 13.

## Method 1: Recursive Approach

This method uses a straightforward recursive algorithm that navigates the grid from the bottom-right corner to the top-left. At each cell, it selects the maximum coins it can collect from either moving left or up. The base case occurs when the start of the grid is reached.

Here’s an example:

```def maxCoinsRecursive(grid, i, j):
if i == 0 and j == 0:  # start
return grid[i][j]
if i < 0 or j < 0:  # out of bounds
return 0
return grid[i][j] + max(maxCoinsRecursive(grid, i-1, j), maxCoinsRecursive(grid, i, j-1))

grid = [[0,3,1], [2,0,0], [4,6,0]]
print(maxCoinsRecursive(grid, len(grid)-1, len(grid[0])-1))
```

Output: 13

This snippet defines the `maxCoinsRecursive()` function, which uses a simple recursive formulation to navigate through the grid. It cumulatively adds the coin value of the current cell to the maximum accumulated coins from neighboring cells. The function is then called with the bottom-right indices and prints the collected coins for the provided grid.

## Method 2: Memoization Technique

Memoization is an optimization technique used to speed up programs by storing the results of expensive function calls. In the context of finding the maximum coins, it ensures that the coin count for each cell is only computed once by caching previous computations.

Here’s an example:

```def maxCoinsMemo(grid):
def collect(r, c, memo):
if (r, c) in memo:
return memo[(r, c)]
if r == 0 and c == 0:
return grid[0][0]
if r < 0 or c < 0:
return 0
memo[(r, c)] = grid[r][c] + max(collect(r-1, c, memo), collect(r, c-1, memo))
return memo[(r, c)]

return collect(len(grid)-1, len(grid[0])-1, {})

grid = [[0,3,1], [2,0,0], [4,6,0]]
print(maxCoinsMemo(grid))
```

Output: 13

The code demonstrates a memoization strategy by using a private function `collect()` inside `maxCoinsMemo()`. It keeps a `memo` dictionary to record the maximum coins collected at each position. The values are computed once and retrieved from the memo when needed, thus avoiding redundant calculations.

## Method 3: Dynamic Programming

Dynamic programming constructs a bottom-up approach by solving smaller subproblems and using these solutions to construct solutions to larger subproblems. For the coin collection problem, this means iteratively updating a grid to contain the maximum coins collected from the bottom-right to every cell.

Here’s an example:

```def maxCoinsDP(grid):
rows, cols = len(grid), len(grid[0])
dp = [[0]*cols for _ in range(rows)]
for i in range(rows):
for j in range(cols):
dp[i][j] = grid[i][j] + max(dp[i-1][j] if i > 0 else 0, dp[i][j-1] if j > 0 else 0)
return dp[-1][-1]

grid = [[0,3,1], [2,0,0], [4,6,0]]
print(maxCoinsDP(grid))
```

Output: 13

The `maxCoinsDP()` function initializes a `dp` matrix to facilitate bottom-up calculations. It iterates over the grid, updating the `dp` matrix with the maximum coins that can be collected at each cell by also considering previously computed results. The function finally returns the value at the bottom-right of the `dp` matrix, representing the total coins collected.

## Method 4: Dynamic Programming with Space Optimization

Instead of using a full 2D matrix for dynamic programming, this method uses a single array that is iteratively updated to store the maximum coin counts. This approach reduces the space complexity from O(rows*cols) to O(cols), which can be beneficial for large grids.

Here’s an example:

```def maxCoinsDPSpaceOptimized(grid):
rows, cols = len(grid), len(grid[0])
dp = [0]*cols
for i in range(rows):
for j in range(cols):
left = dp[j-1] if j > 0 else 0
above = dp[j]
dp[j] = grid[i][j] + max(left, above)
return dp[-1]

grid = [[0,3,1], [2,0,0], [4,6,0]]
print(maxCoinsDPSpaceOptimized(grid))
```

Output: 13

The `maxCoinsDPSpaceOptimized()` function employs dynamic programming while using a one-dimensional array `dp` to record the coin counts, efficiently reducing the space complexity. Each iteration through the grid updates `dp` with the maximum coins for the current row based on the values from the current and previous rows.

## Bonus One-Liner Method 5: Recursive Lambda Function

Although not recommended for production due to readability and scalability concerns, a recursive lambda function can be a fun and terse method to solve the problem in a single line of code using Python’s functional programming capabilities.

Here’s an example:

```maxCoinsLambda = (lambda rec, grid, i, j: grid[i][j] + max(rec(rec, grid, i-1, j), rec(rec, grid, i, j-1)) if i >= 0 and j >= 0 else 0)(lambda f, g, r, c: f(f, g, r, c), [[0,3,1], [2,0,0], [4,6,0]], len(grid)-1, len(grid[0])-1)
print(maxCoinsLambda)
```

Output: 13

The one-liner defines an anonymous recursive function using `lambda` to simulate the behavior of the recursive approach. It computes the maximum coins collectable in a grid in an elegant, albeit somewhat inscrutable, functional programming style.

## Summary/Discussion

• Method 1: Recursive Approach. Strengths: It’s easy to understand and implement. Weaknesses: Highly inefficient for large grids due to exponential time complexity without memoization.
• Method 2: Memoization Technique. Strengths: More efficient than plain recursion by reusing results. Weaknesses: Uses extra memory for storing intermediate results and can be a bit harder to understand.
• Method 3: Dynamic Programming. Strengths: Highly efficient with a clear iterative structure. Weaknesses: It can be memory-intensive for large grids as it requires to store additional state.
• Method 4: Dynamic Programming with Space Optimization. Strengths: Optimizes space complexity without sacrificing the performance benefits of dynamic programming. Weaknesses: Slightly more complex logic than regular dynamic programming.
• Bonus Method 5: Recursive Lambda Function. Strengths: Compact and elegant one-liner. Weaknesses: Poor readability and maintainability; not advisable in larger or more complex codebases.