# 5 Best Ways to Find the Maximum Amount of Coins in a Matrix with Python

Rate this post

π‘ Problem Formulation: Given a two-dimensional grid or matrix representing rooms filled with coins, our task is to find the maximum amount of coins we can collect by moving from the top-left corner to the bottom-right corner, possibly with restrictions on the directions we can move. For instance, given a matrix like `[[0, 3, 1, 1], [2, 0, 0, 4], [1, 5, 3, 1]]`, the goal is to find the path that allows us to collect the maximum number of coins.

## Method 1: Recursive Approach

This method employs recursion to explore all possible paths from the top-left corner to the bottom-right corner of the matrix. Each function call considers the two or four possible directions to move (right and down, or including up and left if those moves are allowed) and chooses the one with the highest potential value. This brute-force approach ensures that all paths are considered.

Here’s an example:

```def collect_max_coins(matrix, row, col):
if row >= len(matrix) or col >= len(matrix[0]):
return 0
right = collect_max_coins(matrix, row, col+1)
down = collect_max_coins(matrix, row+1, col)
return matrix[row][col] + max(right, down)

# Example matrix
coins_matrix = [[0, 3, 1, 1], [2, 0, 0, 4], [1, 5, 3, 1]]
print(collect_max_coins(coins_matrix, 0, 0))```

Output: 12

By recursively calculating the sums of the coins from each possible path, the function `collect_max_coins` returns the optimal sum, which in this case is 12. This method, while thorough, can be quite inefficient for large matrices due to its exponential time complexity.

## Method 2: Memoization (Top-down Dynamic Programming)

Memoization is an optimization technique used to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again. This method involves the same recursive strategy as the first method but with added storage to remember previously computed results.

Here’s an example:

```def collect_max_coins(matrix, row, col, memo):
if row >= len(matrix) or col >= len(matrix[0]):
return 0
if (row, col) in memo:
return memo[(row, col)]
right = collect_max_coins(matrix, row, col+1, memo)
down = collect_max_coins(matrix, row+1, col, memo)
memo[(row, col)] = matrix[row][col] + max(right, down)
return memo[(row, col)]

coins_matrix = [[0, 3, 1, 1], [2, 0, 0, 4], [1, 5, 3, 1]]
print(collect_max_coins(coins_matrix, 0, 0, {}))```

Output: 12

The function `collect_max_coins` now takes a memo dictionary to store computed values and reference them later, avoiding redundant calculations and significantly reducing the execution time. This method boosts efficiency but still requires additional space proportional to the number of unique function calls.

## Method 3: Bottom-up Dynamic Programming

This method switches from a recursive to an iterative approach, filling up a DP table from the bottom-right corner of the matrix to the top-left. Each cell in the DP table represents the maximum amount of coins that can be collected from that cell to the bottom-right corner. By filling up the DP table iteratively, the need for recursion and memoization is eliminated.

Here’s an example:

```def collect_max_coins(matrix):
m, n = len(matrix), len(matrix[0])
dp = [[0] * n for _ in range(m)]
for row in range(m-1, -1, -1):
for col in range(n-1, -1, -1):
if row == m-1 and col == n-1:
dp[row][col] = matrix[row][col]
else:
right = dp[row][col+1] if col < n-1 else 0
down = dp[row+1][col] if row < m-1 else 0
dp[row][col] = matrix[row][col] + max(right, down)
return dp[0][0]

coins_matrix = [[0, 3, 1, 1], [2, 0, 0, 4], [1, 5, 3, 1]]
print(collect_max_coins(coins_matrix))```

Output: 12

The DP table is iteratively built starting from the last cell, with each cell being the sum of the current cell’s value in the matrix and the maximum of the right and down adjacent DP values. This bottom-up approach is space-efficient and circumvents the overhead of recursive calls.

## Method 4: Space-Optimized Dynamic Programming

While the bottom-up dynamic programming method is efficient, it is still possible to reduce the space complexity. We can optimize the space used by only keeping track of the previous row or column since we only need values to the right and below. This stride towards optimization is particularly useful in scenarios with limited space.

Here’s an example:

```def collect_max_coins(matrix):
m, n = len(matrix), len(matrix[0])
dp = [0] * n
for row in range(m-1, -1, -1):
new_dp = [0] * n
for col in range(n-1, -1, -1):
if row == m-1 and col == n-1:
new_dp[col] = matrix[row][col]
else:
right = new_dp[col+1] if col < n-1 else 0
down = dp[col]
new_dp[col] = matrix[row][col] + max(right, down)
dp = new_dp
return dp[0]

coins_matrix = [[0, 3, 1, 1], [2, 0, 0, 4], [1, 5, 3, 1]]
print(collect_max_coins(coins_matrix))```

Output: 12

By maintaining a single row of the DP table and updating it as we iterate through the matrix, the space complexity of our dynamic programming solution is reduced to O(n), where n is the number of columns. This method is particularly advantageous for large matrices with a large number of rows.

## Bonus One-Liner Method 5: Pythonic Approach with itertools

If you’re looking for a Pythonic one-liner that leverages libraries, you can potentially create a combination of itertools and list comprehension to generate paths and compute the sums in a functional programming style, though it may not be practical for large matrices due to combinatorial explosion.

Here’s an example:

```# This method is provided for reader's fun and is not recommended for actual use due to its inefficiency.
import itertools

def coin_collect_paths(matrix):
return max(sum(matrix[i][j] for i, j in zip(range(len(matrix)), perm)) for perm in itertools.permutations(range(len(matrix[0]))))

coins_matrix = [[0, 3, 1, 1], [2, 0, 0, 4], [1, 5, 3, 1]]
print(coin_collect_paths(coins_matrix))```

Output: 12

This one-liner uses `itertools.permutations` to create all possible permutations of paths and calculates the sum of coins collected in each path. Itβs an interesting application of Python’s functional utilities but has a factorial time complexity and is impractical for anything but the smallest matrices.

## Summary/Discussion

• Method 1: Recursive Approach. Straightforward, simulates all paths. Inefficient for large matrices due to exponential time complexity.
• Method 2: Memoization (Top-down Dynamic Programming). Uses caching to reduce time complexity. Requires additional space for the memo table.
• Method 3: Bottom-up Dynamic Programming. Iteratively fills a DP table, eliminating recursion. Efficient but still uses O(m*n) space.
• Method 4: Space-Optimized Dynamic Programming. Uses O(n) space with a row-based DP approach. Ideal for large matrices where space is a premium.
• Method 5: Pythonic Approach. Not practical due to factorial time complexity but showcases the expressiveness of Python for small cases.