Optimal cell in matrix to collect maximum coins

Introduction

Finding the optimal beginning position for collecting coins in a grid is a typical task in a variety of computational applications. One such issue includes a grid with a fixed amount of coins in each cell. The aim is to choose the ideal cell to begin collecting coins from, ensuring that the maximum total sum is achieved while adhering to particular movement constraints. This topic has practical applications in dynamic programming, game tactics, and path optimization. In this post, we look at an algorithmic technique to determine the ideal cell for coin collecting in a grid.

Understanding the Problem

Imagine a grid with each cell displaying the number of pennies available. You start in the top-left cell and can only move right or down. The goal is to gather the most coins while moving to the bottom-right cell. But here's the catch: once you reach a cell, you collect all of the coins within, and that cell is no longer available for further collection.

Algorithm

Calculation: Finding the Optimal Cell for Maximum Coin Collection in a Matrix

Given:

Matrix M of aspects n x m addressing cells with various quantities of coins.
DP table of aspects n x m to store the greatest combined amount of coins gathered up to every cell.

Initialization:

1. Introduce the DP table with similar aspects as grid M.

2. Set DP[0][0] = M[0][0] since it addresses the underlying cell.

Calculation Steps:

3. Cross the grid M line by line and segment by column (start to finish, left to right).

4. For every cell (I, j) in M:

a. If i> 0 and j > 0 (not in the principal line or segment):

Ascertain the most extreme combined aggregate DP[i][j] that can be acquired up to cell (i, j), taking into account the greatest total from its adjoining cells.

DP[i][j] = M[i][j] + max(DP[i-1][j], DP[i][j-1])

b. If i = 0 (first line yet not first section):

Work out DP[i][j] by thinking about just the cell to one side: DP[i][j] = M[i][j] + DP[i][j-1]

c. If j = 0 (first segment however not first column):

Ascertain DP[i][j] by thinking about just the cell above: DP[i][j] = M[i][j] + DP[i-1][j]

d. Assuming both I and j are 0 (upper left corner cell):

No different cells to consider, so DP[i][j] = M[i][j].

e. When the DP table is filled, the greatest total aggregate will be put away in DP[n-1][m-1], where n and m are the components of the framework.

Finding the Optimal Cell:

5. To track down the ideal cell for gathering the most extreme coins, begin from the base right cell (DP[n-1][m-1]).

6. Follow back the way that prompts this cell by choosing the cell with the most extreme combined aggregate among its nearby cells in the DP table.

7. Keep following back until arriving at the upper left cell (DP[0][0]).

Output:

The ideal way recognized by the calculation addresses the arrangement of cells to gather the greatest coins.

Complexity analysis

Time Complexity: O(n * m), where n and m are the elements of the framework.
Space Complexity: O(n * m) for the DP table.

This calculation effectively tracks down the ideal cell for gathering the greatest coins in a framework by utilizing dynamic programming standards.

Example

In a speculative situation, we should consider a 5x5 matrix addressing a fortune map, where every cell holds a specific number of coins. We want to explore this matrix to gather the most extreme number of coins while complying with explicit development rules.

As we start our investigation, we end up at the upper left cell of the matrix. Here is an illustration of such a lattice:

Grid:

We can drop either right or down in each step. After arriving at a cell, we gather every one of the coins in that cell, and it becomes blocked off for future assortments.
To expand our coin assortment, we utilize dynamic programming to decide the ideal way. We make a unique programming table (DP table) of similar aspects as the lattice to store the greatest combined amount of coins gathered up to every cell.
Beginning from the upper left cell, we navigate the lattice line by line and section by segment. At every cell, we work out the most extreme aggregate amount of coins that can be gotten up to that cell. It is not set in stone by thinking about the most extreme combined total from its nearby cells.

We update the DP table likewise:

DP Table:

10 12 20 21
14 19 22 25
20 28 23 32
26 31 25 38
35 36 29 43

When the DP table is filled, the most extreme aggregate total will be put away in the base right cell of the table, which addresses the greatest number of coins that can be gathered. In this model, the base right cell has a worth of 43.
To find the ideal way to prompt this most extreme number of coins, we follow back from the base right cell to the upper left cell. At each step, we select the cell with the greatest aggregate total among its nearby cells in the DP table. This cycle guides us through the way that gathers the most extreme number of coins.

In this model, the ideal way could look something like this:

Optimal Path:

This way shows the succession of cells we navigate to gather the most extreme number of coins. By following this way, we guarantee that we gather the greatest conceivable amount of coins while exploring the lattice.

Implementation

#include <stdio.h>
int maxCollectedCoins(char matrix[][4], int rows, int cols) {
	int dp[rows][cols];
	for (int i = 0; i< rows; ++i) {
		for (int j = 0; j < cols; ++j) {
			dp[i][j] = 0;
		}
	}
	for (int i = 0; i< rows; ++i) {
		int coinCount = 0;
		for (int j = 0; j < cols; ++j) {
			if (matrix[i][j] == '#') {
				coinCount = 0;
			}
			else if (matrix[i][j] == 'C') {
				++coinCount; 
			}
			dp[i][j] += coinCount; 
		}
		coinCount = 0;
		for (int j = cols - 1; j >= 0; --j) {
			if (matrix[i][j] == '#') {
				coinCount = 0; 
			}
			else if (matrix[i][j] == 'C') {
				++coinCount;
			}
			dp[i][j] += coinCount; 
		}
	}
	for (int j = 0; j < cols; ++j) {
		int coinCount = 0;
		for (int i = 0; i< rows; ++i) {
			if (matrix[i][j] == '#') {
				coinCount = 0; 
			}
			else if (matrix[i][j] == 'C') {
				++coinCount; 
			}
			dp[i][j] += coinCount; 
		}
		coinCount = 0;
		for (int i = rows - 1; i>= 0; --i) {
			if (matrix[i][j] == '#') {
				coinCount = 0; 
			}
			else if (matrix[i][j] == 'C') {
				++coinCount; 
			}
			dp[i][j] += coinCount; 
		}
	}
	int maxCoins = 0;
	for (int i = 0; i< rows; ++i) {
		for (int j = 0; j < cols; ++j) {
			if (matrix[i][j] == '0') {
				maxCoins = (maxCoins>dp[i][j]) ?maxCoins : dp[i][j]; 
			}
		}
	}
	return maxCoins;
}
int main() {
	char matrix[3][4] = { { '0', 'C', '0', '0' },
			{ 'C', '0', '#', 'C' },
			{ '0', 'C', '0', '0' } };
	int rows = 3;
	int cols = 4;
	int result = maxCollectedCoins(matrix, rows, cols);
	printf("Max Collected Coins: %d\n", result);
	return 0;
}

Output:

Optimal cell in matrix to collect maximum coins

Explanation

Input Matrix: We have a network (2D cluster) addressing a format with various characters:
- '0' addresses a vacant space where currencies can be gathered.
- 'C' addresses a cell containing a coin.
- '#' addresses a deterrent where currencies can't be gathered.
Total Currency Counting: The program goes through every cell of the lattice and computes the number of mint pieces that can be gathered from that cell and its contiguous cells. It does this in four bearings: left to right, right to left, top to base to perpetually top.
Dynamic Programming: It keeps a powerful programming table (dp) to store the combined count of coins for every cell. This table maintains a strategic distance from excess estimations.
Max Coin Count: In the wake of registering the combined counts, the program finds the greatest count of mint pieces that can be gathered from any unfilled cell ('0') in the network.
Output: At long last, the program prints the most extreme count of mint pieces that can be gathered from the lattice.

Next TopicMaximizing Chocolates in Grid using 2 robots

← prev next →