# 5 Best Ways to Find Maximum Coins Collected from Top-Left to Bottom-Right Cell in Python

Rate this post

π‘ Problem Formulation: Given a two-dimensional grid representing a board of coins, we aim to find the maximum number of coins one can collect by moving from the top-left corner to the bottom-right corner, moving only down or to the right. For example, given a grid with the values [[0,3,1,1], [2,0,0,4], [1,5,3,1]], the desired output is the maximum possible coins collected along the path, in this case, 12 (0β3β1β0β5β3β1).

## Method 1: Dynamic Programming Approach

Dynamic programming is a method used to solve problems by breaking them down into simpler subproblems. In this context, we calculate the maximum coins that can be collected up to each cell by considering the maximum coins we could have had from the cell above it and to its left. We then take the larger value and add the coins in the current cell.

Here’s an example:

```def maxCoins(grid):
rows = len(grid)
cols = 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]
if i > 0: dp[i][j] += dp[i-1][j]
if j > 0: dp[i][j] += dp[i][j-1]
if i > 0 and j > 0: dp[i][j] -= dp[i-1][j-1]
return dp[-1][-1]

grid = [[0,3,1,1], [2,0,0,4], [1,5,3,1]]
print(maxCoins(grid))
```

Output:

`12`

This code snippet defines the function `maxCoins()` which takes a grid as input and returns the maximum coins that can be collected. The function creates a 2D array `dp` to store the maximum coins at each cell with the aid of dynamic programming. The nested loops iterate through the grid, updating the dp array with the maximum coins collectable up to that point.

## Method 2: Recursive with Memoization

Recursive approaches solve problems by breaking them into smaller instances of the same problem. Memoization enhances this by storing the results of expensive function calls and returning the cached result when the same inputs occur again to prevent unnecessary calculations.

Here’s an example:

```def collectCoins(grid, row, col, memo):
if row >= len(grid) or col >= len(grid[0]):
return 0
if memo[row][col] != -1:
return memo[row][col]

# Recursively collect coins from the right and down paths
right = collectCoins(grid, row, col + 1, memo)
down = collectCoins(grid, row + 1, col, memo)

memo[row][col] = grid[row][col] + max(right, down)
return memo[row][col]

grid = [[0,3,1,1], [2,0,0,4], [1,5,3,1]]
memo = [[-1 for _ in range(len(grid[0]))] for _ in range(len(grid))]
print(collectCoins(grid, 0, 0, memo))
```

Output:

`12`

The function `collectCoins()` calculates the maximum number of coins by recursively exploring paths to the right and downwards. It then stores the result in a memoization matrix `memo` to avoid recalculating the maximum coins for a cell that has been previously solved. It kickstarts the process from the top-left cell.

## Method 3: Iterative with Space Optimization

This method is a space-optimized version of the dynamic programming approach. Instead of maintaining a 2D array, it uses a 1D array to store the maximum coins collectable to reach each cell in the current row, taking into account only the current and previous rows.

Here’s an example:

```def maxCoinsOptimized(grid):
rows = len(grid)
cols = len(grid[0])
prev = [0] * cols

for i in range(rows):
curr = [0] * cols
for j in range(cols):
curr[j] = grid[i][j] + max(prev[j], curr[j-1] if j > 0 else 0)
prev = curr
return prev[-1]

grid = [[0,3,1,1], [2,0,0,4], [1,5,3,1]]
print(maxCoinsOptimized(grid))
```

Output:

`12`

In `maxCoinsOptimized()`, a 1D array `prev` stores the maximum coins collected up to each cell in the previous row. In each iteration, the function updates a current row array `curr` using the values from `prev` and `curr`. This saves space as the full 2D dp array is not needed.

## Method 4: Using Python Libraries

Some Python libraries, such as NumPy, can simplify handling grid-based problems thanks to their efficient array operations. This method leverages NumPy’s array slicing and vectorized operations to compute the maximum coins in an elegant way.

Here’s an example:

```import numpy as np

def maxCoinsNumpy(grid):
grid = np.array(grid)
rows, cols = grid.shape

for r in range(1, rows):
grid[r, 0] += grid[r-1, 0]
for c in range(1, cols):
grid[0, c] += grid[0, c-1]

for r in range(1, rows):
for c in range(1, cols):
grid[r, c] += max(grid[r-1, c], grid[r, c-1])

return grid[-1, -1]

grid = [[0,3,1,1], [2,0,0,4], [1,5,3,1]]
print(maxCoinsNumpy(grid))
```

Output:

`12`

The function `maxCoinsNumpy()` converts the list of lists grid into a NumPy array and then iteratively updates the array in place. The code benefits from NumPy’s optimized array manipulations, which can be faster and more concise than pure Python implementations.

## Bonus One-Liner Method 5: Python’s Reduce and Lambda Functions

Python’s functional programming features can be utilized to solve this problem in a compact manner using `functools.reduce()` and lambda functions, which apply a rolling computation to sequential pairs of values in an iterable.

Here’s an example:

```from functools import reduce

maxCoinsOneLiner = lambda grid: reduce(lambda x, y: [xi + max(yi, x[i+1] if i+1<len(x) else 0) for i, xi in enumerate(y)], reversed(grid), [0]*len(grid[0]))[0]

grid = [[0,3,1,1], [2,0,0,4], [1,5,3,1]]
print(maxCoinsOneLiner(grid))
```

Output:

`12`

This one-liner `maxCoinsOneLiner()` uses a lambda function to intricately combine `reduce()` and list comprehensions to solve the problem from the bottom row upwards. It cleverly avoids explicit loops and nested function definitions, making it a nifty trick for those who love Python’s conciseness.

## Summary/Discussion

• Method 1: Dynamic Programming Approach. This is a classic and efficient approach. It can handle large grids but may consume more memory due to the dp table.
• Method 2: Recursive with Memoization. It’s a more intuitive method that simulates the decision-making process. However, it can lead to a stack overflow for very large grids due to deep recursion.
• Method 3: Iterative with Space Optimization. It optimizes memory usage compared to the original dynamic programming approach. It’s more efficient for larger grids but may be less intuitive to understand at first.
• Method 4: Using Python Libraries. Libraries like NumPy offer concise syntax and potentially faster execution through optimized native code. However, it adds a dependency on an external library.
• Method 5: Python’s Reduce and Lambda Functions. This one-liner is a clever and concise solution, showcasing Python’s functional programming power. However, it may sacrifice readability for brevity and can be tricky for those not familiar with these concepts.