# 5 Best Ways to Find the Maximum Number of Coins Collected in Python

Rate this post

π‘ Problem Formulation: Assume we are given a two-dimensional grid representing rooms filled with coins. The goal is to determine the maximum number of coins we can collect by moving right or down through the grid. For instance, given a grid like `[[0, 3, 1, 1], [2, 0, 0, 4], [1, 5, 3, 1]]`, the maximum coins that can be collected, starting from the top-left corner (0,0) and moving only right or down to reach the bottom-right corner, would be 12.

## Method 1: Recursive Approach

This method involves creating a recursive function that explores every possible path from the initial position to the end of the grid, summing up the coins from each cell visited along the way. The base case of the recursion happens when we reach the bottom-right corner of the grid. This method captures the intuitive brute-force approach very well, however, it is not efficient for larger grids.

Here’s an example:

```def collect_coins(grid, x, y):
if x == len(grid) - 1 and y == len(grid[0]) - 1:
return grid[x][y]
if x < len(grid) - 1 and y < len(grid[0]) - 1:
return grid[x][y] + max(collect_coins(grid, x + 1, y), collect_coins(grid, x, y + 1))
if x < len(grid) - 1:
return grid[x][y] + collect_coins(grid, x + 1, y)
if y < len(grid[0]) - 1:
return grid[x][y] + collect_coins(grid, x, y + 1)

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

Output: `12`

This code snippet defines a recursive function `collect_coins` which uses conditions to check the boundaries of the grid and ensure it chooses the maximum coins path at each decision point. It starts from the position (0, 0) and recursively explores the right and down paths. Though clear, this method computes many subproblems multiple times, leading to exponential time complexity.

## Method 2: Dynamic Programming (Top-Down)

Dynamic Programming (Top-Down) approach, also known as memoization, involves storing the results of subproblems in a cache to avoid redundant calculations. This method significantly improves the complexity compared to the recursive approach by ensuring each subproblem is solved only once.

Here’s an example:

```def collect_coins_memo(grid, x, y, memo):
if x == len(grid) - 1 and y == len(grid[0]) - 1:
return grid[x][y]
if (x, y) in memo:
return memo[(x, y)]
right = down = 0
if x < len(grid) - 1:
down = collect_coins_memo(grid, x + 1, y, memo)
if y < len(grid[0]) - 1:
right = collect_coins_memo(grid, x, y + 1, memo)
memo[(x, y)] = grid[x][y] + max(right, down)
return memo[(x, y)]

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

Output: `12`

This code snippet incorporates memoization in the recursive `collect_coins_memo` function through a dictionary named `memo`. Each time a subproblem is solved, its result is stored with the current position used as the key. This alteration drastically reduces the number of calculations and thus improves performance over plain recursion.

## Method 3: Dynamic Programming (Bottom-Up)

Dynamic Programming (Bottom-Up), or tabulation, is an iterative approach that solves problems by systematically filling up a table (usually an array) based on previously computed entries. Compared to Top-Down, this approach is often more space-efficient and avoids the overhead of recursion.

Here’s an example:

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

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

Output: `12`

This example illustrates a Bottom-Up approach to the problem. By iterating through the rows and columns of a new 2D list `dp`, we progressively build up the solution. The key idea here is that to calculate the maximum coins for the current cell, we only need the values from the cell directly to its left and directly above it, allowing us to build the solution iteratively.

## Method 4: Greedy Algorithm

A Greedy Algorithm approach attempts to find the maximum number of coins by always choosing the local optimum at each step (the cell with the highest coins between the right and down options). Notably, this method does not guarantee a global optimum solution and may fail for certain configurations of the grid.

Here’s an example:

```def collect_coins_greedy(grid):
x = y = 0
coins = 0
while x < len(grid) - 1 or y  grid[x][y+1]:
x += 1
else:
y += 1
coins += grid[x][y]
return coins

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

Output: `10`

This code example implements a Greedy Algorithm to navigate through the grid, illustrating how it could potentially result in a suboptimal solution. The algorithm naively selects the next step with the most coins and continues until the bottom-right corner is reached. This example demonstrates the main weakness of the Greedy Algorithm: it’s not always correct.

## Bonus One-Liner Method 5: Pythonic Approach

For a playful twist, a Python-centric approach might involve using advanced Python features like list comprehensions and built-in functions to minimize the code footprint. Note that while concise, this usually isn’t the most efficient method and is more of a programming exercise rather than a practical solution.

Here’s an example:

```collect_coins_pythonic = lambda g: max(sum(row) for row in g)

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

Output: `9`

This one-liner takes a distinctly Pythonic approach to the problem by calculating the sum of coins in each row and then finding the maximum sum. It’s simple, but it doesn’t solve the problem correctly, as it assumes the best path can always be found in a single row, which is not the case with the given problem.

## Summary/Discussion

• Method 1: Recursive Approach. Straightforward implementation. Exponential time complexity.
• Method 2: Dynamic Programming (Top-Down). Reuses subproblem solutions. Requires additional space for memoization.
• Method 3: Dynamic Programming (Bottom-Up). Reduces recursive calls. Good for small to medium-sized problems.
• Method 4: Greedy Algorithm. Simple and fast for specific scenarios. Does not guarantee the optimal solution.
• One-Liner Method 5: Pythonic Approach. Very concise code. Not an accurate solution for this specific problem.