Maximize the value of coins that cannot be collected in adjacent rows and columns

Dynamic programming is an optimization algorithm technique that solves specific problems by breaking them into a number of simple sub-problems. Through this process, we can combine qualities, conditions, or facts from a complete search to obtain a precise and accurate greedy algorithm. But this approach itself is a contradiction, because it has great advantages, but it is also its greatest disadvantage and limitation. We can divide a problem into sub-problems, but we cannot divide it into sub-problems. They should resolve themselves. The concept of subproblems can be used to solve more important problems because they are highly optimizing in nature.

What is a coin and how to redeem it?

Coins are components of an array representing the sum of integers representing the total amount. In the process, you should return some coins to balance the total. If not built, returns -1.

There are two solutions for changing coins -

• Recursion - Simple and slow method.

• Dynamic programming - a timely and efficient method

Applications of coins in computer science -

• is used to distribute changes.

Coin operation algorithm

Here is the process of how we gradually increase the value of coins in adjacent rows.

• Step One - Start

• Step 2 - Construct a new array of length n 1

• Step 3 - Set dynamic prog[0] to 1 for one-way processing

• Step 4 - Iterate over the value

• Step 5 - Add the value of dynamicprog[index-coins[i]] to dynamicprog[index]

• Step 6 - Set a range from 1 to n

• Step 7 − Return a value

• Step 8 - Termination

The syntax of coins

If the coin value is greater than the dynamicprogSum, the coin is ignored, i.e.
dynamicprogTable[i][j]=dynamicprogTable[i-1][j].
If the coin value is less than the dynamicprogSum, you can consider it, i.e.
dynamicprogTable[i][j]=dynamicprogTable[i-
1].[dynamicprogSum]+dynamicprogTable[i][j-coins[i-1]].
Or;
maxCoins(i, j, d): Maximum number of coins that can be
collected if we begin at cell (i, j) and direction d.
   d can be either 0 (left) or 1 (right)
If (arr[i][j] == ‘#’ or isValid(i, j) == false)
   return 0
If (arr[i][j] == ‘C’)
   result = 1;
Else
   result = 0;
If (d == 0)
return result + max(maxCoins(i+1, j, 1),
   maxCoins(i, j-1, 0));
If (d == 1)
return result + max(maxCoins(i+1, j, 1),
   maxCoins(i, j+1, 0));

Here is the possible coin change syntax in a C environment. By applying this syntax, we will build some code to fully understand this coin.

Method to follow:

• Method 1 - Recursive C program to find maximum number of coins

• Method 2−Maximize the value of coins when coins in adjacent rows and columns cannot be collected

Recursive C program to find the maximum number of coins

In this code, we apply dynamic programming. The logic is: arr[i][j 1] and arr[i][j – 1].

The Chinese translation of

Example 1

is:

Example 1

#include<bits/stdc++.h>
using namespace std;
#define R 5
#define C 5
bool isValid(int i, int j) {
   return (i >=0 && i < R && j >=0 && j < C);
}
int maxCoinsRec(char arr[R][C], int i, int j, int dir){
   if (isValid(i,j) == false || arr[i][j] == '#')
      return 0;
   int result = (arr[i][j] == 'C')? 1: 0;
   if (dir == 1)
      return result + max(maxCoinsRec(arr, i+1, j, 0),
   maxCoinsRec(arr, i, j+1, 1));
   return result + max(maxCoinsRec(arr, i+1, j, 1),
   maxCoinsRec(arr, i, j-1, 0));
}
int main() {
   char arr[R][C] = {
      {'E', 'C', 'C', 'C', 'C'},
      {'C', '#', 'C', '#', 'E'},
      {'#', 'C', 'C', '#', 'C'},
      {'C', 'E', 'E', 'C', 'E'},
      {'C', 'E', '#', 'C', 'E'}
   };
   cout << "Maximum number of collected coins is "<< maxCoinsRec(arr, 0, 0, 1);
   return 0;
}

Output

Maximum number of collected coins is 8

Maximize coin value when coins in adjacent rows and columns cannot be collected

In this C code, we apply the method of finding and collecting the most coins before hitting a dead end.

• Move forward one step, that is, cell (i, j 1), the direction remains unchanged.

• Move one step down and face left, i.e. cell (i 1, j) and the direction changes to left.

Example 2

is translated as:

Example 2

#include <bits/stdc++.h>
using namespace std;
int findMax(vector<int>& arr) {
   int n = arr.size(), result = 0;
   vector<int> dp(n);
   dp[0] = arr[0];
   result = dp[0];
   if (n <= 1)
      return result;
   dp[1] = max(arr[1], arr[0]);
   result = max(result, dp[1]);
   for (int i = 2; i < n; i++) {
      dp[i] = max(dp[i - 1], arr[i] + dp[i - 2]);
      result = max(result, dp[i]);
   }
   return result;
}
int solve(vector<vector<int> >& matrix){
   int m = matrix.size();
   if (m == 0)
      return 0;
   vector<int> dp;
   for (int i = 0; i < m; i++) {
      int val = findMax(matrix[i]);
   dp.push_back(val);
   }
   return findMax(dp);
}
int main() {
   vector<vector<int> > arr = { { 2, 7, 6, 5 },
      { 9, 9, 1, 2 },
      { 3, 8, 1, 5 } };
   int result = solve(arr);
   cout << result;
   return 0;
}

Output

25

in conclusion

Today in this post we learned how to maximize the value of coins from columns that cannot be collected from adjacent rows by building code and algorithms in possible C.

The above is the detailed content of Maximize the value of coins that cannot be collected in adjacent rows and columns. For more information, please follow other related articles on the PHP Chinese website!